一、函数简介

函数是组织代码的模块化方式，可以将一段代码封装起来，以便重复使用和维护。Python中的函数通过def关键字定义，可以接受参数并返回值。

1. 定义函数

使用def关键字定义函数，后跟函数名和圆括号。圆括号内可以包含参数列表，最后以冒号结束。函数体由缩进的代码块组成。

def greet(name):
    """
    打印问候语。
    
    参数:
    name (str): 要问候的人的名字。
    """
    print(f"Hello, {name}!")

# 调用函数
greet("Alice")

# 解释：
# - `def greet(name):` 定义一个名为 `greet` 的函数，接受一个参数 `name`
# - `print(f"Hello, {name}!")` 是函数体，打印问候语
# - `greet("Alice")` 调用函数，并传递参数 "Alice"

2. 返回值

使用return语句从函数中返回一个值。如果没有return语句，函数默认返回None。

def add(a, b):
    """
    返回两个数的和。
    
    参数:
    a (int/float): 第一个加数。
    b (int/float): 第二个加数。
    
    返回:
    int/float: 两个数的和。
    """
    return a + b

# 使用返回值
result = add(3, 5)
print(result)  # 输出 8

# 解释：
# - `return a + b` 返回两个数的和
# - `result = add(3, 5)` 将返回值赋给变量 `result`
# - `print(result)` 打印返回值

二、函数参数

1. 位置参数

按顺序传递参数。

def greet(name, greeting="Hello"):
    """
    打印问候语。
    
    参数:
    name (str): 要问候的人的名字。
    greeting (str, optional): 问候语，默认为 "Hello"。
    """
    print(f"{greeting}, {name}!")

# 使用位置参数
greet("Alice", "Hi")
greet("Bob")  # 使用默认参数

# 解释：
# - `greet("Alice", "Hi")` 按顺序传递参数 "Alice" 和 "Hi"
# - `greet("Bob")` 只传递第一个参数，第二个参数使用默认值 "Hello"

2. 关键字参数

使用参数名传递参数，顺序无关紧要。

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

# 使用关键字参数
greet(greeting="Hi", name="Alice")
greet(name="Bob")

# 解释：
# - `greet(greeting="Hi", name="Alice")` 使用关键字参数传递 "Hi" 和 "Alice"
# - `greet(name="Bob")` 只传递 `name` 参数，`greeting` 使用默认值

3. 默认参数

为参数提供默认值，如果调用时未提供该参数，则使用默认值。

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

# 使用默认参数
greet("Alice")  # 输出 Hello, Alice!
greet("Bob", "Hi")  # 输出 Hi, Bob!

# 解释：
# - `greet("Alice")` 使用默认值 "Hello"
# - `greet("Bob", "Hi")` 提供了 `greeting` 参数 "Hi"

4. 可变参数（*args）

允许函数接受任意数量的位置参数，这些参数会被打包成一个元组。

def sum_numbers(*args):
    """
    计算多个数的和。
    
    参数:
    *args: 任意数量的数字。
    
    返回:
    float/int: 数字的和。
    """
    return sum(args)

# 使用可变参数
print(sum_numbers(1, 2, 3, 4))  # 输出 10
print(sum_numbers(1, 2, 3, 4, 5, 6))  # 输出 21

# 解释：
# - `*args` 允许传递任意数量的位置参数
# - `sum(args)` 计算所有参数的和

5. 关键字参数（**kwargs）

允许函数接受任意数量的关键字参数，这些参数会被打包成一个字典。

def print_info(**kwargs):
    """
    打印传入的关键字参数。
    
    参数:
    **kwargs: 任意数量的关键字参数。
    """
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 使用关键字参数
print_info(name="Alice", age=25, city="Beijing")

# 解释：
# - `**kwargs` 允许传递任意数量的关键字参数
# - `for key, value in kwargs.items()` 遍历关键字参数字典

6. 组合使用参数

可以组合使用位置参数、默认参数、*args和**kwargs。

def complex_function(a, b, c=0, *args, **kwargs):
    """
    复杂函数示例。
    
    参数:
    a (int/float): 第一个参数。
    b (int/float): 第二个参数。
    c (int/float, optional): 第三个参数，默认为 0。
    *args: 任意数量的位置参数。
    **kwargs: 任意数量的关键字参数。
    
    返回:
    tuple: 包含所有参数的元组。
    """
    print(f"a={a}, b={b}, c={c}")
    print("args:", args)
    print("kwargs:", kwargs)
    return (a, b, c, args, kwargs)

# 调用复杂函数
result = complex_function(1, 2, 3, 4, 5, name="Alice", age=25)
print(result)

# 解释：
# - `complex_function` 接受多种类型的参数
# - `a`, `b`, `c` 是位置参数和默认参数
# - `*args` 是可变参数，`**kwargs` 是关键字参数
# - `result` 包含所有参数的元组

三、匿名函数（Lambda）

1. 定义匿名函数

使用lambda关键字定义匿名函数，通常用于需要简单函数的地方，如排序或过滤。

# 定义一个简单的匿名函数
add = lambda x, y: x + y

# 使用匿名函数
print(add(3, 5))  # 输出 8

# 解释：
# - `lambda x, y: x + y` 定义一个匿名函数，接受两个参数并返回它们的和
# - `add(3, 5)` 调用匿名函数并传递参数 3 和 5

2. 应用场景：排序和过滤

匿名函数常用于sorted()、filter()等内置函数中。

# 使用匿名函数进行排序
numbers = [1, 3, 5, 2, 4]
sorted_numbers = sorted(numbers, key=lambda x: -x)
print(sorted_numbers)  # 输出 [5, 4, 3, 2, 1]

# 使用匿名函数进行过滤
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出 [2, 4]

# 解释：
# - `sorted(numbers, key=lambda x: -x)` 按降序排序
# - `filter(lambda x: x % 2 == 0, numbers)` 过滤出偶数

四、递归函数

1. 递归函数简介

递归函数是指在函数体内调用自身的函数。递归函数通常用于解决可以通过更小规模的子问题来解决的问题。

def factorial(n):
    """
    计算n的阶乘。
    
    参数:
    n (int): 非负整数。
    
    返回:
    int: n的阶乘。
    """
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

# 使用递归函数
print(factorial(5))  # 输出 120

# 解释：
# - `factorial(n)` 计算 n 的阶乘
# - 如果 n 是 0 或 1，返回 1
# - 否则，返回 n * factorial(n - 1)，即 n * (n-1) * ... * 1

2. 应用场景：斐波那契数列

递归函数常用于生成斐波那契数列。

def fibonacci(n):
    """
    计算第n个斐波那契数。
    
    参数:
    n (int): 非负整数。
    
    返回:
    int: 第n个斐波那契数。
    """
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

# 使用递归函数
print(fibonacci(10))  # 输出 55

# 解释：
# - `fibonacci(n)` 计算第 n 个斐波那契数
# - 如果 n 是 0 或 1，返回 n
# - 否则，返回 fibonacci(n - 1) + fibonacci(n - 2)

五、总结

函数是Python编程中非常重要的概念，提供了模块化和复用代码的能力。主要特点包括：

• 定义函数：使用def关键字定义函数，可以接受参数并返回值。
• 函数参数：支持位置参数、关键字参数、默认参数、可变参数和关键字参数。
• 匿名函数：使用lambda关键字定义匿名函数，适用于简单操作。
• 递归函数：函数可以在函数体内调用自身，适合解决递归问题。

这些工具广泛应用于各种编程场景中，例如：

• 数据处理：编写函数处理和转换数据。
• 数学计算：实现复杂的数学算法。
• 逻辑控制：封装业务逻辑，提高代码可读性和可维护性。