函数

参数类型

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

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

introduce("Bob", 25)

• 关键字参数：通过参数名=值的形式传递参数，这种情况下不需要保证实参和形参的顺序。

introduce(age=25, name="Bob")

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

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

introduce("Bob")
introduce("Bob", 25)

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

def introduce(name, age=20, *args):
    print(f"I'm {name}, {age} years old.")
    print(args)  # 输出 ('Engineer', 'Python', 'USA')

introduce("Bob", 25, "Engineer", "Python", "USA")

• 可变关键字参数：使用**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)

返回值

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

返回单个值

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

返回多个值

不返回任何值

四、作用域（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

introduce = lambda name, age: print(f"I'm {name}, {age} years old.")
introduce("Bob", 25)

常用于高阶函数，如 map、filter、sorted

numbers = [1, 2, 3, 4]

squared = list(map(lambda x: x**2, numbers))    # [1, 4, 9, 16]

str_nums = list(map(lambda x: str(x), nums))    # ['1', '2', '3']

装饰器（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）使用