函数是 Python 编程的核心。它们使您能够有效地构建代码，使其可重用、可维护且更易于调试。

1. 函数介绍

函数是可重用的代码块，旨在执行特定任务。可以将 logic 封装到函数中，而不是重复代码，从而提高代码的模块化和可读性。例如，在 AI 项目中，可以编写一个函数来规范化数据或计算精度和召回率等指标。

下面是一个简单的示例：

def greet(name):
    return f"Hello, {name}!"

print(greet("Ebrahim"))
# Hello, Ebrahim!

函数包括以下内容：

• 名称：您调用函数时使用的标识符。
• 参数：函数可以接受的输入（可选）。
• Body：调用函数时运行的代码。
• 返回值：函数的输出（可选）。

2. 定义函数

函数是使用 def 关键字定义的。您必须提供名称、括号（用于参数）和冒号才能开始正文。

例：

def add(a, b):
    """This function adds two numbers."""
    return a + b

result = add(5, 3)
print("Sum:", result)  
# Output: Sum: 8

要点：

• 文档字符串（用三引号括起来）记录了函数的用途。
• return 语句提供输出。如果没有它，该函数将返回 None。
• 缩进是强制性的，它定义了函数的主体。

3. 函数参数和参数

参数和参数

在 Python 中，parameters 是函数定义中列出的变量，而 argument 是调用函数时发送到函数的值。这种区别对于理解函数的运作方式至关重要。

例如，定义另一个计算矩形面积的函数。它需要两个参数：length 和 width。

def calculate_area(length, width):  
    return length * width

这里，length 和 width 是 calculate_area 函数的参数。调用此函数时，您可以为这些参数提供特定值 （参数）：

area = calculate_area(5, 3)  
print(area)  
# Outputs: 15

在这种情况下，当我们调用 calculate_area（5， 3） 时，参数 5 和 3 将分别传递给参数 length 和 width，从而计算矩形的面积。

不同类型的参数语法

一、 位置参数：

直接在函数中定义。传递的值必须按顺序匹配。

def multiply(x, y):  
    return x * y  

# Calling the function  
result = multiply(3, 5)  # x=3, y=5  
print(result)  # Output: 15

二、默认参数：

允许您设置参数的默认值。如果未提供参数，则使用默认值。

def greet(name, greeting="Hello"):  
    print(f"{greeting}, {name}!")  

# Using default parameter  
greet("Ebrahim")  # Output: Hello, Ebrahim!  
greet("Ela", "Welcome")  # Output: Welcome, Ela!

三、关键词参数：

可以在调用函数时指定参数的名称，从而允许按任意顺序传递它们。

def display_info(name, age):  
    print(f"Name: {name}, Age: {age}")  

# Calling with keyword arguments  
display_info(age=34, name="Ebi")  # Order does not matter

IV. 可变长度参数：
使用 *args 允许函数接受任意数量的位置参数，使用 **kwargs 表示任意数量的关键字参数。

• 使用 *args：

def sum_numbers(*args):  
    return sum(args)  

# Calling with multiple arguments  
total = sum_numbers(1, 2, 3, 4, 5)  # Output: 15

• 使用 **kwargs：

def print_student_info(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key}: {value}")  

# Calling with variable keyword arguments  
print_student_info(name="Ebi", age=34, course="AI")  
# Output:  
# name: Ebi  
# age: 34  
# course: AI

V. 组合不同类型的：
可以将位置参数、默认参数、*args、关键字参数和 **kwargs 组合到一个函数中。

def mixed_arguments(a, b=2, *args, c=4, **kwargs):  
    print(f"a: {a}, b: {b}, args: {args}, c: {c}, kwargs: {kwargs}")  

# Example call  
mixed_arguments(1, 3, 5, 6, c=7, name="Ebi")  

# Output:  
# a: 1, b: 3, args: (5, 6), c: 7, kwargs: {'name': 'Ebi'}

不同类型的参数语法

I. 位置参数：

按定义参数的顺序传递。该数字必须与参数的数量匹配。

def divide(x, y):  
    return x / y  

# Positional arguments  
result = divide(10, 2)  # x=10, y=2  
print(result)  # Output: 5.0

II. 关键字参数：
允许在函数调用期间指定参数名称。这有助于清晰起见，并允许更改顺序。

def display_info(name, age):  
    print(f"Name: {name}, Age: {age}")  

# Keyword arguments  
display_info(age=30, name="Ervin")  # Output: Name: Ervin, Age: 30

III. 默认参数：
当没有为具有 default 的参数提供值时自动采用的值。

def introduce(name, country="Iran"):  
    print(f"Hello, my name is {name} and I’m from {country}.")  

# Calling with and without default  
introduce("Ebi")  # Output: Hello, my name is Ebi and I’m from Iran.  
introduce("Caterine", "Canada")  # Output: Hello, my name is Caterine and I’m from Canada.

IV. 可变长度参数：
可以使用 *args 作为位置参数，使用 **kwargs 作为关键字参数来传递不同数量的参数。

• 使用 *args：

def concatenate(*args):  
    return ' '.join(args)  

# Variable-length positional arguments  
result = concatenate("Hello", "world", "from", "Medium")  
print(result)  
# Output: Hello world from Medium

• 使用 **kwargs：

def print_game_info(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key}: {value}")  

# Variable-length keyword arguments  
print_game_info(title="Chess", players=2, duration="30 min")  
# Output:  
# title: Chess  
# players: 2  
# duration: 30 min

V. 组合参数：
可以在一个函数调用中混合使用位置参数、关键字参数和可变长度参数。

def complete_info(a, b=2, *args, c=10, **kwargs):  
    print(f"a: {a}, b: {b}, args: {args}, c: {c}, kwargs: {kwargs}")  

# Example call  
complete_info(1, 5, 8, c=3, name="Ebi", age=34)  

# Output:  
# a: 1, b: 5, args: (8,), c: 3, kwargs: {'name': 'Ebi', 'age': 34}

4. 函数中的范围

什么是范围？

Scope 是指可以访问变量的程序区域。Python 具有不同的范围：

1. Local Scope：在函数内部定义的变量，只能在该函数内访问。
2. Global Scope：在所有函数之外定义的变量，可在整个程序中访问。
3. Enclosing Scope：嵌套函数 （closure） 的 enclosing 函数中的变量。
4. Built-in Scope：在 Python 中预先分配的名称（例如，print、len）。

了解范围

1. Local Scope：函数中定义的变量位于 local 范围内。它们只能从该函数中访问。例如：

def local_scope_example():  
    x = 10  # x is a local variable  
    print(x)  

local_scope_example()  # Outputs: 10  
# print(x)  # Uncommenting this line would raise a NameError

2. 全局范围：在任何函数外部定义的变量都位于全局范围内，并且可以从代码中的任何位置（包括函数内部）访问，除非被局部变量遮蔽。例如：

y = 20  # y is a global variable  

def global_scope_example():  
    print(y)  # Accessing global variable y  
global_scope_example()  # Outputs: 20

修改全局变量

但是，如果要修改函数内的全局变量，则需要将其声明为全局变量：

counter = 0

def increment():
    global counter
    counter += 1

increment()
print(counter)  # Output: 1

不同范围的示例：

x = "global variable"

def outer_function():
    x = "enclosing variable"
    
    def inner_function():
        x = "local variable"
        print(x)  # Prints "local variable"
    
    inner_function()
    print(x)  # Prints "enclosing variable"

outer_function()
print(x)  # Prints "global variable"

最佳实践：

避免过度使用全局变量，以保持函数纯度并防止意外的副作用。

5. 函数注释

注释提供有关函数的预期输入类型和返回类型的提示。

def add(a: int, b: int) -> int:
    """Adds two integers."""
    return a + b

print(add(3, 4))  # Output: 7

注释不强制类型，而是用作文档和支持工具，如类型检查器和 IDE。

6. Lambda 函数

Lambda 函数是简洁的匿名函数。它们非常适合排序或筛选等短操作。

square = lambda x: x ** 2
print(square(5))  # Output: 25

numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)  # Output: [1, 4, 9, 16]

7. 闭包和嵌套函数

嵌套函数

另一个函数内的函数称为嵌套函数。

def outer_function(msg):
    def inner_function():
        return f"Inner says: {msg}"
    return inner_function()

print(outer_function("Hello!"))

闭 包

闭包从其封闭范围内捕获变量，即使在封闭函数完成执行之后也是如此。

def multiplier(factor):
    def multiply_by(number):
        return number * factor
    return multiply_by

double = multiplier(2)
print(double(5))  # Output: 10

8. 装饰器

装饰器是修改或扩展另一个函数行为的高阶函数。

def logger(func):
    """Logs the function call."""
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args} and {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@logger
def multiply(a, b):
    return a * b

print(multiply(3, 5))  # Logs the call and outputs: 15