1. 函数基础

1.1 什么是函数

函数是一段可重复使用的代码块，用于执行特定任务。它通过名称调用，可以接收输入参数，并返回处理结果。函数的主要目的是提高代码的复用性、可读性和模块化程度。

1.2 函数的定义与调用

在 Python 中，使用 def 关键字定义函数：

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

函数定义包含函数名、参数列表、冒号和函数体。调用时使用函数名加括号，并传入实际参数。

1.3 函数的返回值

使用 return 语句返回函数执行结果。如果没有 return 语句，函数默认返回 None。

def add(a, b):
    """返回两个数的和"""
    return a + b
result = add(3, 5)  # result = 8

函数可以返回多个值（实际上是返回一个元组）：

def get_min_max(numbers):
    """返回列表中的最小值和最大值"""
    return min(numbers), max(numbers)
min_val, max_val = get_min_max([1, 5, 3, 9, 2])

2. 函数参数

2.1 位置参数

位置参数是按照定义时的顺序传递的参数：

def power(base, exponent):
    """计算 base 的 exponent 次方"""
    return base ** exponent
power(2, 3)  # 2的3次方 = 8

2.2 默认参数

为参数指定默认值，调用时可省略：

def greet(name, greeting="Hello"):
    """使用指定或默认的问候语打招呼"""
    print(f"{greeting}, {name}!")
greet("Bob")              # 输出：Hello, Bob!
greet("Alice", "Hi")      # 输出：Hi, Alice!

注意：默认参数必须放在非默认参数之后。

2.3 关键字参数

调用时通过参数名指定值，可以不按顺序：

def create_user(name, age, city):
    print(f"Name: {name}, Age: {age}, City: {city}")
create_user(age=25, city="Beijing", name="Charlie")

2.4 可变参数 *args 与 **kwargs

*args 接收任意数量的位置参数，**kwargs 接收任意数量的关键字参数：

def print_args(*args, **kwargs):
    """打印所有位置参数和关键字参数"""
    print("位置参数:", args)
    print("关键字参数:", kwargs)
print_args(1, 2, 3, name="Alice", age=30)
输出：
位置参数: (1, 2, 3)
关键字参数: {'name': 'Alice', 'age': 30}

2.5 参数解包

使用 * 解包序列作为位置参数，** 解包字典作为关键字参数：

def connect(host, port, timeout):
    print(f"连接到 {host}:{port}, 超时: {timeout}")
参数解包
params = ("localhost", 8080, 30)
connect(*params)  # 相当于 connect("localhost", 8080, 30)
config = {"host": "example.com", "port": 443, "timeout": 10}
connect(**config)  # 相当于 connect(host="example.com", port=443, timeout=10)

3. 变量作用域

3.1 局部变量与全局变量

局部变量在函数内部定义，只在函数内有效。全局变量在函数外部定义，在整个模块中有效。

global_var = "I'm global"
def test_scope():
local_var = "I'm local"
print(local_var)      # 可以访问局部变量
print(global_var)     # 可以访问全局变量
test_scope()
print(local_var)  # 错误！无法在函数外访问局部变量

3.2 global 与 nonlocal 关键字

global 声明使用全局变量，nonlocal 声明使用外层嵌套函数的变量：

count = 0
def increment():
global count  # 声明使用全局变量 count
count += 1
def outer():
x = "outer"
def inner():
nonlocal x  # 声明使用外层函数的变量 x
x = "inner"
inner()
print(x)  # 输出：inner

3.3 globals() 与 locals()

globals() 返回全局符号表字典，locals() 返回局部符号表字典：

x = 10
y = 20
def show_vars():
a = 1
b = 2
print("局部变量:", locals())  # {'a': 1, 'b': 2}
print("全局变量中的x:", globals()['x'])  # 10
show_vars()

4. 高级函数特性

4.1 匿名函数（lambda）

使用 lambda 创建小型匿名函数，适合简单操作：

# 普通函数
def square(x):
    return x * x
等价lambda表达式
square_lambda = lambda x: x * x
print(square(5))          # 25
print(square_lambda(5))   # 25
常用场景：排序
students = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
students.sort(key=lambda student: student[1])  # 按分数排序

4.2 高阶函数

接收函数作为参数或返回函数的函数：

# map: 对每个元素应用函数
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))  # [1, 4, 9, 16]
filter: 过滤满足条件的元素
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4]
sorted: 自定义排序
words = ["apple", "banana", "cherry", "date"]
sorted_by_length = sorted(words, key=len)  # 按长度排序

4.3 递归函数

函数调用自身，必须有终止条件：

def factorial(n):
    """计算阶乘（递归实现）"""
    if n <= 1:
        return 1
    return n * factorial(n - 1)
print(factorial(5))  # 120
def fibonacci(n):
"""斐波那契数列（递归实现）"""
if n <= 1:
return n
return fibonacci(n-1) + fibonacci(n-2)
print(fibonacci(6))  # 8

5. 闭包与装饰器

5.1 闭包

内部函数引用外部函数变量，即使外部函数已执行完毕：

def outer_func(msg):
    """外部函数"""
    message = msg
def inner_func():
    """内部函数（闭包）"""
    print(f"Message: {message}")

return inner_func  # 返回内部函数，而不是调用它
closure = outer_func("Hello")
closure()  # 输出：Message: Hello

5.2 装饰器

装饰器是修改或增强函数功能的工具，使用 @decorator 语法糖：

def timer_decorator(func):
    """计时装饰器"""
    import time
def wrapper(*args, **kwargs):
    start = time.time()
    result = func(*args, **kwargs)
    end = time.time()
    print(f"{func.__name__} 执行时间: {end - start:.4f}秒")
    return result

return wrapper
@timer_decorator
def slow_function():
"""模拟耗时操作"""
import time
time.sleep(1)
return "完成"
slow_function()  # 输出：slow_function 执行时间: 1.0002秒

5.3 装饰器常用案例简写

1. 日志装饰器：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完毕")
        return result
    return wrapper

2. 权限验证装饰器：

def require_login(func):
    def wrapper(user, *args, **kwargs):
        if user.get("is_authenticated"):
            return func(user, *args, **kwargs)
        else:
            return "请先登录"
    return wrapper

3. 缓存装饰器：

def cache_decorator(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            print("从缓存中获取结果")
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

4. 带参数的装饰器：

def repeat(n):
    """重复执行n次的装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(n):
                print(f"第{i+1}次执行")
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
@repeat(3)
def say_hello():
print("Hello!")
say_hello()  # 输出3次Hello