updates (#853)

Author: soyeric128

docs/en/developer/00-drivers/01-python.md

@@ -4,7 +4,7 @@ title: Python
 
 Databend offers the following Python packages enabling you to develop Python applications that interact with Databend:
 
-- [databend-py (**Recommendation**)](https://github.com/databendcloud/databend-py): Provides a direct interface to the Databend database. It allows you to perform standard Databend operations such as user login, database and table creation, data insertion/loading, and querying.
+- [databend-py (**Recommended**)](https://github.com/databendcloud/databend-py): Provides a direct interface to the Databend database. It allows you to perform standard Databend operations such as user login, database and table creation, data insertion/loading, and querying.
 - [databend-sqlalchemy](https://github.com/databendcloud/databend-sqlalchemy): Provides a SQL toolkit and [Object-Relational Mapping](https://en.wikipedia.org/wiki/Object%E2%80%93relational_mapping) to interface with the Databend database. [SQLAlchemy](https://www.sqlalchemy.org/) is a popular SQL toolkit and ORM for Python, and databend-SQLAlchemy is a dialect for SQLAlchemy that allows you to use SQLAlchemy to interact with Databend.
 
 Both packages require Python version 3.5 or higher. To check your Python version, run `python --version` in your command prompt. To install the latest `databend-py` or `databend-sqlalchemy` package:

docs/en/guides/54-query/03-udf.md

@@ -3,7 +3,7 @@ title: User-Defined Function
 ---
 import IndexOverviewList from '@site/src/components/IndexOverviewList';
 
-User-Defined Functions (UDFs) offer enhanced flexibility by supporting both anonymous lambda expressions and predefined handlers (JavaScript & WebAssembly) for defining UDFs. These features allow users to create custom operations tailored to their specific data processing needs. Databend UDFs are categorized into the following types:
+User-Defined Functions (UDFs) offer enhanced flexibility by supporting both anonymous lambda expressions and predefined handlers (Python, JavaScript & WebAssembly) for defining UDFs. These features allow users to create custom operations tailored to their specific data processing needs. Databend UDFs are categorized into the following types:
 
 - [Lambda UDFs](#lambda-udf)
 - [Embedded UDFs](#embedded-udfs)
@@ -42,16 +42,140 @@ SELECT get_v1(data), get_v2(data) FROM json_table;
 
 Embedded UDFs allow you to embed code written in the following programming languages within SQL:
 
+- [Python](#python)
 - [JavaScript](#javascript)
 - [WebAssembly](#webassembly)
 
 :::note
-If your program content is large, you can compress it and then pass it to the stage. See the [Usage Examples](#usage-examples-2) for WebAssembly.
+If your program content is large, you can compress it and then pass it to a stage. See the [Usage Examples](#usage-examples-2) for WebAssembly.
 :::
 
+### Python
+
+A Python UDF allows you to invoke Python code from a SQL query via Databend's built-in handler, enabling seamless integration of Python logic within your SQL queries.
+
+:::note
+The Python UDF must use only Python's standard library; third-party imports are not allowed.
+:::
+
+#### Data Type Mappings
+
+See [Data Type Mappings](/developer/drivers/python#data-type-mappings) in the Developer Guide.
+
+#### Usage Examples
+
+This example defines a Python UDF for sentiment analysis, creates a table, inserts sample data, and performs sentiment analysis on the text data.
+
+1. Define a Python UDF named `sentiment_analysis`.
+
+```sql
+-- Create the sentiment analysis function
+CREATE OR REPLACE FUNCTION sentiment_analysis(STRING) RETURNS STRING
+LANGUAGE python HANDLER = 'sentiment_analysis'
+AS $$
+def remove_stop_words(text, stop_words):
+    """
+    Removes common stop words from the text.
+    
+    Args:
+    text (str): The input text.
+    stop_words (set): A set of stop words to remove.
+    
+    Returns:
+    str: Text with stop words removed.
+    """
+    return ' '.join([word for word in text.split() if word.lower() not in stop_words])
+
+def calculate_sentiment(text, positive_words, negative_words):
+    """
+    Calculates the sentiment score of the text.
+    
+    Args:
+    text (str): The input text.
+    positive_words (set): A set of positive words.
+    negative_words (set): A set of negative words.
+    
+    Returns:
+    int: Sentiment score.
+    """
+    words = text.split()
+    score = sum(1 for word in words if word in positive_words) - sum(1 for word in words if word in negative_words)
+    return score
+
+def get_sentiment_label(score):
+    """
+    Determines the sentiment label based on the sentiment score.
+    
+    Args:
+    score (int): The sentiment score.
+    
+    Returns:
+    str: Sentiment label ('Positive', 'Negative', 'Neutral').
+    """
+    if score > 0:
+        return 'Positive'
+    elif score < 0:
+        return 'Negative'
+    else:
+        return 'Neutral'
+
+def sentiment_analysis(text):
+    """
+    Analyzes the sentiment of the input text.
+    
+    Args:
+    text (str): The input text.
+    
+    Returns:
+    str: Sentiment analysis result including the score and label.
+    """
+    stop_words = set(["a", "an", "the", "and", "or", "but", "if", "then", "so"])
+    positive_words = set(["good", "happy", "joy", "excellent", "positive", "love"])
+    negative_words = set(["bad", "sad", "pain", "terrible", "negative", "hate"])
+
+    clean_text = remove_stop_words(text, stop_words)
+    sentiment_score = calculate_sentiment(clean_text, positive_words, negative_words)
+    sentiment_label = get_sentiment_label(sentiment_score)
+    
+    return f'Sentiment Score: {sentiment_score}; Sentiment Label: {sentiment_label}'
+$$;
+```
+
+2. Perform sentiment analysis on the text data using the `sentiment_analysis` function.
+
+```sql
+CREATE OR REPLACE TABLE texts (
+    original_text STRING
+);
+
+-- Insert sample data
+INSERT INTO texts (original_text)
+VALUES 
+('The quick brown fox feels happy and joyful'),
+('A hard journey, but it was painful and sad'),
+('Uncertain outcomes leave everyone unsure and hesitant'),
+('The movie was excellent and everyone loved it'),
+('A terrible experience that made me feel bad');
+
+
+SELECT
+    original_text,
+    sentiment_analysis(original_text) AS processed_text
+FROM
+    texts;
+
+|   original_text                                          |   processed_text                                  |
+|----------------------------------------------------------|---------------------------------------------------|
+|   The quick brown fox feels happy and joyful             |   Sentiment Score: 1; Sentiment Label: Positive   |
+|   A hard journey, but it was painful and sad             |   Sentiment Score: -1; Sentiment Label: Negative  |
+|   Uncertain outcomes leave everyone unsure and hesitant  |   Sentiment Score: 0; Sentiment Label: Neutral    |
+|   The movie was excellent and everyone loved it          |   Sentiment Score: 1; Sentiment Label: Positive   |
+|   A terrible experience that made me feel bad            |   Sentiment Score: -2; Sentiment Label: Negative  |
+```
+
 ### JavaScript
 
-A JavaScript UDF allows you to invoke JavaScript code from a SQL query via Databend's built-in handler, enabling seamless integration of JavaScript logic within your SQL queries. 
+A JavaScript UDF allows you to invoke JavaScript code from a SQL query via Databend's built-in handler, enabling seamless integration of JavaScript logic within your SQL queries.
 
 #### Data Type Mappings