函数

一、函数的定义与调用

1. 使用def关键字定义函数。

2. 调用函数：通过函数名和括号来调用函数，括号内传入实际参数。

def 函数名(参数列表):
    """文档字符串（可选）"""
    # 函数体
    return 返回值  # 可选

示例：

def greet(name):
    """向指定名字的人问好"""
    print(f"Hello, {name}!")
    
# 调用函数
greet("Alice")  # 输出：Hello Alice

二、参数类型

• 必选参数（Positional Arguments）：参数按定义时的顺序传递。

def introduce(name, age):
    print(f"I'm {name}, {age} years old.")

introduce("Bob", 25)  # 正确
# introduce(25, "Bob") # 逻辑错误，但语法正确

• 关键字参数：通过参数名=值的形式传递参数，顺序无

introduce(age=30, name="Charlie")  # 输出: I'm Charlie, 30 years old.

• 默认参数：在定义函数时为参数指定默认值。默认参数必须放在非默认参数之后。

def power(base, exponent=2):
    return base ** exponent

print(power(2))  # 输出：9 (3^2)
print(power(2, 3))  # 输出 27 (3^3)

• 可变参数：使用*args接收任意数量的位置参数，args是一个元组。

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3, 4))  # 输出: 10
print(sum_all(10, 20))      # 输出: 30

• 可变关键字参数：使用**kwargs接收任意数量的关键字参数，kwargs是一个字典。

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

print_info(name="Alice", age=25, city="Beijing")
# 输出:
# name: Alice
# age: 25
# city: Beijing

• 参数组合顺序：定义函数时，参数的顺序必须是：def func(位置参数， *args，默认参数， **kwargs)：

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

complex_func(1, 2, 3, 4, c=20, x=100, y=200)
# 输出: a=1, b=2, args=(3, 4), c=20, kwargs={'x': 100, 'y': 200}

三、返回值

• 使用 return 语句返回值。

• 函数可以返回单个值、多个值（实际上是返回一个元组）、或不返回任何值（隐式返回 None）。

• return 会立即结束函数执行。

def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        return None  # 或抛出异常
    return a / b

def get_name_age():
    return "Alice", 25  # 返回元组

name, age = get_name_age()  # 元组解包

四、作用域（Scope）

Python 遵循 LEGB 规则来查找变量：

• Local：函数内部

• Enclosing：外层函数

• Global：全局作用域

• Built-in：内置作用域

x = "global"

def outer():
    x = "outer"
    def inner():
        x = "inner"
        print(x)  # inner
    inner()
    print(x)      # outer

outer()
print(x)          # global

global 和 nonlocal 关键字

• global：在函数内部修改全局变量。

• nonlocal：在嵌套函数中修改外层函数的变量。

# global 示例
counter = 0
def increment():
    global counter
    counter += 1

increment()
print(counter)  # 输出: 1

# nonlocal 示例
def outer():
    x = 10
    def inner():
        nonlocal x
        x += 5
    inner()
    print(x)  # 输出: 15
outer()

五、匿名函数（Lambda）

使用lambda关键字创建小型匿名函数。

# 语法: lambda 参数: 表达式
square = lambda x: x ** 2
print(square(4))  # 输出: 16

# 常用于高阶函数如 map, filter, sorted
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))  # [1, 4, 9, 16]

六、高阶函数

函数可以作为参数传递给其他函数，或作为返回值返回。

# 函数作为参数
def apply_func(func, value):
    return func(value)

result = apply_func(lambda x: x * 2, 5)  # 输出: 10

# 函数作为返回值
def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

double = make_multiplier(2)
print(double(5))  # 输出: 10

七、装饰器（Decorator）

装饰器是一种特殊类型的函数，它可以修改其他函数的功能。

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数执行前")
        result = func(*args, **kwargs)
        print("函数执行后")
        return result
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# 输出:
# 函数执行前
# Hello!
# 函数执行后

• 带参数的装饰器（多层嵌套）

def log(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] {func.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log("INFO")
def do_something():
    pass

八、文档字符串（Docstring）

使用三重引号 """ 编写函数的文档，可通过 help() 或 .__doc__ 查看。

def add(a, b):
    """
    计算两个数的和。

    参数:
        a (int): 第一个数
        b (int): 第二个数

    返回:
        int: 两数之和
    """
    return a + b

help(add)  # 显示文档

九、函数注解（Type Hints）

为参数和返回值提供类型提示，提高代码可读性和可维护性。

def greet(name: str, age: int) -> str:
    return f"Hello, {name}. You are {age} years old."

# 注解不会强制类型检查，但可被工具（如 mypy）使用