Python 函数完全指南

本文档系统讲解 Python 函数的核心知识，从零基础入门到高级应用，适合初学者学习和开发者复习。

---

一、函数基础概念

1.1 什么是函数

函数（Function） 是一段可重复使用的代码块，用于完成特定任务。通过将代码封装成函数，我们可以：

• 避免重复代码：写一次，多次调用
• 提高代码可读性：用有意义的函数名代替复杂逻辑
• 便于维护：修改一处，全局生效
• 模块化编程：将大问题分解为小问题

1.2 函数的分类

类型	说明	示例
内置函数	Python 自带的函数	print(), len(), range()
自定义函数	用户自己定义的函数	def my_func(): ...
匿名函数	没有名字的简单函数	lambda x: x + 1
高阶函数	接收或返回函数的函数	map(), filter(), sorted()

1.3 函数的核心要素

一个完整的函数包含：

1. 函数名：标识函数的名称
2. 参数：函数接收的输入数据（可选）
3. 函数体：实现功能的代码块
4. 返回值：函数执行后的输出结果（可选）

# 函数名: greet
# 参数: name
# 函数体: 打印问候语
# 返回值: 无（默认返回 None）
def greet(name):
    print(f"Hello, {name}!")

---

二、定义函数的语法

2.1 基本语法

使用 def 关键字定义函数：

def 函数名(参数1, 参数2, ...):
    """文档字符串（可选）：说明函数的功能"""
    # 函数体
    # 执行语句
    return 返回值  # 可选

2.2 最简单的函数

# 无参数，无返回值
def say_hello():
    print("Hello, World!")

# 调用函数
say_hello()  # 输出: Hello, World!

2.3 带参数的函数

# 一个参数
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # 输出: Hello, Alice!
greet("Bob")    # 输出: Hello, Bob!

2.4 带返回值的函数

def add(a, b):
    """计算两个数的和"""
    result = a + b
    return result

# 调用并接收返回值
sum_result = add(3, 5)
print(sum_result)  # 输出: 8

# 也可以直接打印
print(add(10, 20))  # 输出: 30

2.5 文档字符串（Docstring）

良好的函数应该包含文档说明，使用三引号 ''' 或 """：

def calculate_area(length, width):
    """
    计算矩形的面积。
    
    参数:
        length (float): 矩形的长度
        width (float): 矩形的宽度
    
    返回:
        float: 矩形的面积
    
    示例:
        >>> calculate_area(5, 3)
        15
    """
    return length * width

# 查看文档
help(calculate_area)
print(calculate_area.__doc__)

---

三、函数参数详解

Python 函数的参数非常灵活，支持多种形式。

3.1 位置参数（Positional Arguments）

按照定义的顺序传递参数，是最常见的参数形式。

def introduce(name, age, city):
    print(f"我叫{name}，今年{age}岁，来自{city}")

# 按位置传递
introduce("张三", 25, "北京")
# 输出: 我叫张三，今年25岁，来自北京

注意：位置参数必须按顺序传递，顺序错了结果就错了。

3.2 关键字参数（Keyword Arguments）

通过 参数名=值 的形式传递，可以不按顺序。

def introduce(name, age, city):
    print(f"我叫{name}，今年{age}岁，来自{city}")

# 使用关键字参数，顺序可以任意
introduce(age=25, city="北京", name="张三")
# 输出: 我叫张三，今年25岁，来自北京

# 混合使用：位置参数在前，关键字参数在后
introduce("张三", city="北京", age=25)

规则：位置参数必须在关键字参数之前！

# ❌ 错误：关键字参数不能在位置参数前面
introduce(name="张三", 25, "北京")  # SyntaxError

3.3 默认参数（Default Arguments）

为参数设置默认值，调用时可以不传。

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

# 使用默认值
greet("Alice")           # 输出: Hello, Alice!

# 覆盖默认值
greet("Bob", "Hi")       # 输出: Hi, Bob!
greet("Carol", greeting="Good morning")  # 输出: Good morning, Carol!

重要警告：默认参数不要使用可变对象（列表、字典等）！

# ❌ 错误示例
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]  不是 [2]！

# ✅ 正确做法
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item(1))  # [1]
print(add_item(2))  # [2]

3.4 可变参数 *args

接收任意数量的位置参数，在函数内部以元组形式存在。

def sum_all(*numbers):
    """计算所有参数的和"""
    result = 0
    for num in numbers:
        result += num
    return result

# 调用时可以传任意个数
print(sum_all())           # 0
print(sum_all(1))          # 1
print(sum_all(1, 2, 3))    # 6
print(sum_all(1, 2, 3, 4, 5))  # 15

*args 的本质：

def demo(*args):
    print(type(args))  # <class 'tuple'>
    print(args)        # (1, 2, 3)

demo(1, 2, 3)

命名习惯：叫 args 是约定，可以改。

3.5 可变关键字参数 **kwargs

接收任意数量的关键字参数，在函数内部以字典形式存在。

def print_info(**kwargs):
    """打印所有关键字参数"""
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=25, city="北京")
# 输出:
# name: 张三
# age: 25
# city: 北京

**kwargs 的本质：

def demo(**kwargs):
    print(type(kwargs))  # <class 'dict'>
    print(kwargs)        # {'a': 1, 'b': 2}

demo(a=1, b=2)

3.6 参数组合顺序

定义函数时，参数必须按以下顺序：

def func(位置参数, *args, 默认参数, **kwargs):
    pass

# 或者
def func(位置参数, 默认参数, *args, **kwargs):
    pass

完整示例：

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

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

3.7 解包参数

调用函数时，可以用 * 和 ** 解包序列和字典。

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

# 列表解包
nums = [1, 2, 3]
print(add(*nums))  # 等价于 add(1, 2, 3)，输出: 6

# 字典解包
data = {'a': 1, 'b': 2, 'c': 3}
print(add(**data))  # 等价于 add(a=1, b=2, c=3)，输出: 6

---

四、函数返回值

4.1 单个返回值

使用 return 语句返回一个值。

def square(x):
    return x ** 2

result = square(5)
print(result)  # 25

4.2 多个返回值

Python 函数可以返回多个值，实际上是返回一个元组。

def get_min_max(numbers):
    """返回列表中的最小值和最大值"""
    return min(numbers), max(numbers)

# 接收多个返回值
min_val, max_val = get_min_max([3, 1, 4, 1, 5, 9])
print(min_val, max_val)  # 1 9

# 实际上返回的是元组
result = get_min_max([3, 1, 4])
print(result)        # (1, 4)
print(type(result))  # <class 'tuple'>

4.3 没有返回值

如果函数没有 return 语句，或者只有 return 没有值，默认返回 None。

def say_hello():
    print("Hello!")
    # 没有 return

result = say_hello()
print(result)  # None

def check_positive(num):
    if num > 0:
        return "正数"
    # 负数时没有返回值

print(check_positive(5))   # 正数
print(check_positive(-5))  # None

4.4 提前返回

使用 return 可以提前结束函数执行。

def divide(a, b):
    """安全除法"""
    if b == 0:
        return "错误：除数不能为0"  # 提前返回
    return a / b

print(divide(10, 2))   # 5.0
print(divide(10, 0))   # 错误：除数不能为0

---

五、变量作用域

5.1 局部变量与全局变量

# 全局变量
global_var = "我是全局变量"

def my_func():
    # 局部变量
    local_var = "我是局部变量"
    print(local_var)      # 可以访问局部变量
    print(global_var)     # 可以访问全局变量

my_func()
print(global_var)         # 可以访问
# print(local_var)        # ❌ 错误！局部变量在函数外不可访问

5.2 global 关键字

在函数内部修改全局变量，需要使用 global 声明。

count = 0

def increment():
    global count  # 声明使用全局变量
    count += 1
    print(count)

increment()  # 1
increment()  # 2
print(count)  # 2

不加 global 会报错：

count = 0

def wrong_increment():
    count += 1  # ❌ UnboundLocalError

5.3 nonlocal 关键字

在嵌套函数中，修改外层（非全局）的变量使用 nonlocal。

def outer():
    x = 10  # 外层函数的变量
    
    def inner():
        nonlocal x  # 声明使用外层函数的变量
        x += 1
        print(f"inner: x = {x}")
    
    inner()
    print(f"outer: x = {x}")

outer()
# 输出:
# inner: x = 11
# outer: x = 11

5.4 作用域规则（LEGB）

Python 查找变量的顺序：

层级	说明	范围
Local	局部作用域	函数内部
Enclosing	嵌套作用域	外层函数
Global	全局作用域	模块级别
Built-in	内置作用域	Python 内置

# 示例
x = "global"  # G

def outer():
    x = "enclosing"  # E
    
    def inner():
        x = "local"  # L
        print(x)  # 输出: local
    
    inner()
    print(x)  # 输出: enclosing

outer()
print(x)  # 输出: global

---

六、匿名函数（Lambda）

6.1 什么是 Lambda

Lambda 是一种匿名函数，用于创建简单的、一次性使用的小函数。

语法：

lambda 参数: 表达式

6.2 基本用法

# 普通函数
def add(x, y):
    return x + y

# 等价的 lambda
add_lambda = lambda x, y: x + y

print(add(2, 3))         # 5
print(add_lambda(2, 3))  # 5

6.3 常见使用场景

Lambda 通常作为参数传递给高阶函数。

# 排序时指定 key
students = [
    {'name': '张三', 'score': 85},
    {'name': '李四', 'score': 92},
    {'name': '王五', 'score': 78}
]

# 按分数排序
students.sort(key=lambda x: x['score'], reverse=True)
print(students)
# [{'name': '李四', 'score': 92}, {'name': '张三', 'score': 85}, ...]

6.4 Lambda 的限制

• 只能包含一个表达式
• 不能包含语句（如赋值、循环、条件判断）
• 不能写文档字符串

# ❌ 错误：lambda 不能包含语句
f = lambda x: if x > 0: return x  # SyntaxError

# ✅ 正确：使用条件表达式
f = lambda x: x if x > 0 else 0

---

七、高阶函数

高阶函数是指接收函数作为参数，或返回函数作为结果的函数。

7.1 map() 函数

对可迭代对象的每个元素应用函数，返回迭代器。

# 将列表中的每个数平方
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))  # [1, 4, 9, 16, 25]

# 等价的普通写法
result = []
for x in numbers:
    result.append(x ** 2)

7.2 filter() 函数

根据条件过滤可迭代对象，返回满足条件的元素。

# 筛选偶数
numbers = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # [2, 4, 6]

# 筛选成年人
people = [{'name': '张三', 'age': 17}, {'name': '李四', 'age': 25}]
adults = filter(lambda p: p['age'] >= 18, people)
print(list(adults))  # [{'name': '李四', 'age': 25}]

7.3 reduce() 函数

对序列进行累积计算（需要 from functools import reduce）。

from functools import reduce

# 求积
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 120 (1*2*3*4*5)

# 找最大值
max_val = reduce(lambda x, y: x if x > y else y, numbers)
print(max_val)  # 5

7.4 sorted() 函数

返回排序后的新列表，不改变原列表。

numbers = [3, 1, 4, 1, 5, 9]

# 默认升序
print(sorted(numbers))  # [1, 1, 3, 4, 5, 9]

# 降序
print(sorted(numbers, reverse=True))  # [9, 5, 4, 3, 1, 1]

# 按绝对值排序
print(sorted([-5, 2, -8, 1], key=abs))  # [1, 2, -5, -8]

7.5 自定义高阶函数

def apply_operation(numbers, operation):
    """对列表中的每个数应用指定操作"""
    return [operation(n) for n in numbers]

# 使用
nums = [1, 2, 3, 4]
print(apply_operation(nums, lambda x: x * 2))   # [2, 4, 6, 8]
print(apply_operation(nums, lambda x: x ** 2))  # [1, 4, 9, 16]

---

八、函数装饰器

8.1 什么是装饰器

装饰器是一种用于修改或增强函数功能的特殊语法，本质上是一个接收函数作为参数并返回函数的高阶函数。

8.2 基本语法

@装饰器函数名
def 被装饰函数():
    pass

# 等价于
def 被装饰函数():
    pass
被装饰函数 = 装饰器函数名(被装饰函数)

8.3 简单装饰器示例

import time

def timer(func):
    """计算函数执行时间的装饰器"""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 执行时间: {elapsed:.4f}秒")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "Done"

slow_function()
# 输出: slow_function 执行时间: 1.0012秒

8.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 greet(name):
    print(f"Hello, {name}!")

greet("Alice")
# 输出:
# 第1次执行:
# Hello, Alice!
# 第2次执行:
# Hello, Alice!
# 第3次执行:
# Hello, Alice!

8.5 常用内置装饰器

装饰器	作用	示例
@staticmethod	定义静态方法	不需要 self 参数
@classmethod	定义类方法	第一个参数是 cls
@property	将方法转为属性	像访问属性一样访问方法

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):
        """获取半径"""
        return self._radius
    
    @radius.setter
    def radius(self, value):
        """设置半径"""
        if value < 0:
            raise ValueError("半径不能为负数")
        self._radius = value
    
    @property
    def area(self):
        """计算面积（只读属性）"""
        return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.radius)  # 5
print(c.area)    # 78.53975
c.radius = 10    # 设置新半径
# c.area = 100   # ❌ 错误：不能设置只读属性

---

九、闭包

9.1 什么是闭包

闭包（Closure） 是指一个函数记住了其外部作用域的变量，即使外部函数已经执行完毕。

9.2 闭包示例

def make_multiplier(n):
    """创建一个乘以 n 的函数"""
    def multiplier(x):
        return x * n  # multiplier 记住了外部的 n
    return multiplier

# 创建两个闭包
times3 = make_multiplier(3)
times5 = make_multiplier(5)

print(times3(10))  # 30
print(times5(10))  # 50

9.3 闭包的应用：计数器

def make_counter():
    """创建一个计数器"""
    count = 0
    
    def counter():
        nonlocal count
        count += 1
        return count
    
    return counter

counter1 = make_counter()
counter2 = make_counter()

print(counter1())  # 1
print(counter1())  # 2
print(counter1())  # 3

print(counter2())  # 1（独立的计数器）
print(counter2())  # 2

9.4 闭包 vs 类

闭包可以实现类似类的功能，但更轻量：

# 使用闭包
def make_person(name, age):
    def person():
        return f"{name}, {age}岁"
    return person

# 使用类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __call__(self):
        return f"{self.name}, {self.age}岁"

---

十、递归函数

10.1 什么是递归

递归是指函数调用自身来解决问题。递归需要两个要素：

1. 基准条件（Base Case）：停止递归的条件
2. 递归条件（Recursive Case）：函数调用自身的条件

10.2 经典示例：阶乘

def factorial(n):
    """计算 n 的阶乘：n! = n * (n-1) * ... * 1"""
    # 基准条件
    if n <= 1:
        return 1
    # 递归条件
    return n * factorial(n - 1)

print(factorial(5))  # 120 (5*4*3*2*1)

执行过程：

factorial(5)
= 5 * factorial(4)
= 5 * (4 * factorial(3))
= 5 * (4 * (3 * factorial(2)))
= 5 * (4 * (3 * (2 * factorial(1))))
= 5 * (4 * (3 * (2 * 1)))
= 120

10.3 经典示例：斐波那契数列

def fibonacci(n):
    """计算第 n 个斐波那契数：0, 1, 1, 2, 3, 5, 8..."""
    if n <= 0:
        return 0
    if n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55

10.4 尾递归优化

普通递归有大量重复计算，可以使用记忆化优化：

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci_fast(n):
    """带缓存的斐波那契"""
    if n <= 0:
        return 0
    if n == 1:
        return 1
    return fibonacci_fast(n - 1) + fibonacci_fast(n - 2)

print(fibonacci_fast(100))  # 瞬间算出，不会栈溢出

10.5 递归的注意事项

问题	说明
栈溢出	Python 默认递归深度限制为 1000，超过会报错
效率问题	递归通常比循环慢，有大量重复计算
可读性	递归代码简洁，但理解难度较大

修改递归深度限制（谨慎使用）：

import sys
sys.setrecursionlimit(2000)  # 设置为 2000

---

十一、生成器函数

11.1 什么是生成器

生成器（Generator） 是一种特殊的迭代器，使用 yield 关键字定义。它可以惰性生成数据，节省内存。

11.2 基本语法

def simple_generator():
    yield 1
    yield 2
    yield 3

# 创建生成器对象
gen = simple_generator()

# 逐个获取值
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3
# print(next(gen))  # StopIteration 异常

# 也可以用 for 循环
for value in simple_generator():
    print(value)  # 1, 2, 3

11.3 生成器 vs 列表

# 列表：一次性生成所有数据，占用大量内存
def get_numbers_list(n):
    return [i for i in range(n)]

# 生成器：惰性生成，节省内存
def get_numbers_gen(n):
    for i in range(n):
        yield i

# 使用
numbers = get_numbers_gen(1000000)  # 几乎不占内存
for num in numbers:
    if num > 100:
        break  # 只生成前 101 个数就停止

11.4 生成器表达式

类似列表推导式，但使用圆括号：

# 列表推导式（立即计算）
squares_list = [x**2 for x in range(1000)]  # 占用内存

# 生成器表达式（惰性计算）
squares_gen = (x**2 for x in range(1000))   # 几乎不占内存

# 使用
for square in squares_gen:
    print(square)
    if square > 100:
        break

11.5 实用示例：斐波那契生成器

def fibonacci_gen(n):
    """生成前 n 个斐波那契数"""
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1

# 使用
for num in fibonacci_gen(10):
    print(num, end=' ')  # 0 1 1 2 3 5 8 13 21 34

11.6 生成器的方法

def interactive_gen():
    print("生成器启动")
    while True:
        received = yield "等待输入..."
        print(f"收到: {received}")

# 创建生成器
gen = interactive_gen()

# 启动生成器
print(next(gen))  # 输出: 生成器启动
                  #       等待输入...

# 发送数据
print(gen.send("Hello"))  # 输出: 收到: Hello
                          #       等待输入...

print(gen.send("World"))  # 输出: 收到: World
                          #       等待输入...

---

十二、函数注解与类型提示

12.1 什么是类型提示

Python 3.5+ 支持类型提示（Type Hints），用于标注函数的参数类型和返回类型，提高代码可读性，便于 IDE 检查。

注意：类型提示不会在运行时强制执行，只是给开发者和工具看的。

12.2 基本语法

def greet(name: str) -> str:
    """参数 name 是字符串，返回值也是字符串"""
    return f"Hello, {name}"

def add(a: int, b: int) -> int:
    """参数和返回值都是整数"""
    return a + b

12.3 复杂类型

from typing import List, Dict, Optional, Union, Tuple

# 列表
def sum_list(numbers: List[int]) -> int:
    return sum(numbers)

# 字典
def get_user(users: Dict[str, int], name: str) -> Optional[int]:
    """返回值可能是 int 或 None"""
    return users.get(name)

# 联合类型
def parse_value(value: Union[str, int]) -> str:
    """参数可以是字符串或整数"""
    return str(value)

# 元组
def get_point() -> Tuple[float, float]:
    return (1.0, 2.0)

12.4 实际示例

from typing import List, Dict, Optional
from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int
    email: Optional[str] = None

def filter_adults(users: List[User]) -> List[User]:
    """筛选成年人"""
    return [u for u in users if u.age >= 18]

def get_user_emails(users: List[User]) -> Dict[str, str]:
    """获取用户邮箱字典"""
    return {u.name: u.email for u in users if u.email}

# 使用
users = [
    User("张三", 25, "zhangsan@example.com"),
    User("李四", 17),
    User("王五", 30, "wangwu@example.com")
]

adults = filter_adults(users)
print(adults)  # [User(name='张三', ...), User(name='王五', ...)]

---

十三、函数最佳实践

13.1 函数设计原则

原则	说明	示例
单一职责	一个函数只做一件事	calculate_area() 只计算面积
函数名有意义	见名知意	get_user_by_id() 比 foo() 好
参数不宜过多	超过 3-4 个考虑用对象	create_user(name, age, email)
避免副作用	纯函数更容易测试	不修改全局状态
适当长度	函数不要太长	20-30 行为宜

13.2 命名规范

# 函数名：小写 + 下划线（snake_case）
def calculate_total_price(): pass
def get_user_by_id(): pass

# 私有函数：以下划线开头
def _internal_helper(): pass

# 常量：全大写
MAX_RETRY_COUNT = 3

# 类名：大驼峰（CamelCase）
class UserManager: pass

13.3 文档字符串规范

def process_data(data: list, threshold: float = 0.5) -> dict:
    """
    处理数据并返回统计结果。
    
    该函数接收原始数据列表，根据阈值进行过滤，
    并返回包含各项统计指标的字典。
    
    Args:
        data (list): 原始数据列表，每个元素应为数值类型
        threshold (float, optional): 过滤阈值，默认为 0.5
    
    Returns:
        dict: 包含以下键的字典：
            - count: 数据条数
            - mean: 平均值
            - filtered: 过滤后的数据列表
    
    Raises:
        ValueError: 当 data 为空列表时抛出
        TypeError: 当 data 中包含非数值类型时抛出
    
    Examples:
        >>> data = [1.0, 2.0, 3.0, 0.1]
        >>> result = process_data(data, threshold=0.5)
        >>> result['count']
        3
    """
    if not data:
        raise ValueError("数据不能为空")
    
    filtered = [x for x in data if x >= threshold]
    return {
        'count': len(filtered),
        'mean': sum(filtered) / len(filtered) if filtered else 0,
        'filtered': filtered
    }

13.4 错误处理

def divide_safely(a: float, b: float) -> float:
    """安全除法"""
    try:
        if b == 0:
            raise ValueError("除数不能为零")
        return a / b
    except TypeError:
        raise TypeError("参数必须是数值类型")
    except Exception as e:
        print(f"未知错误: {e}")
        raise

# 使用
try:
    result = divide_safely(10, 0)
except ValueError as e:
    print(f"错误: {e}")  # 错误: 除数不能为零

---

十四、常见错误与调试技巧

14.1 常见错误

错误	原因	解决方法
NameError	变量未定义	检查变量名拼写
TypeError	类型不匹配	检查参数类型
ValueError	值不合适	检查参数值
RecursionError	递归深度超限	添加基准条件或使用循环
UnboundLocalError	局部变量未赋值就使用	使用 global 或 nonlocal

14.2 调试技巧

# 1. 使用 print 调试
def debug_func(x):
    print(f"输入: {x}")
    result = x * 2
    print(f"结果: {result}")
    return result

# 2. 使用 assert 断言
def divide(a, b):
    assert b != 0, "除数不能为零"
    return a / b

# 3. 使用 logging 模块
import logging
logging.basicConfig(level=logging.DEBUG)

def logged_func(x):
    logging.debug(f"处理: {x}")
    return x ** 2

# 4. 使用 IDE 调试器
# PyCharm/VS Code 都支持断点调试

---

十五、总结与速查表

函数定义速查

# 基本函数
def func(): pass

# 带参数
def func(a, b): pass

# 默认参数
def func(a, b=10): pass

# 可变参数
def func(*args): pass          # 位置参数元组
def func(**kwargs): pass       # 关键字参数字典
def func(*args, **kwargs): pass # 两者都有

# 返回值
def func():
    return 1          # 单个返回值
def func():
    return 1, 2, 3    # 多个返回值（元组）

参数传递速查

调用方式	示例
位置参数	func(1, 2)
关键字参数	func(a=1, b=2)
混合调用	func(1, b=2)
解包列表	func(*[1, 2])
解包字典	func(**{'a': 1, 'b': 2})

高级特性速查

特性	语法	用途
Lambda	lambda x: x + 1	简单匿名函数
装饰器	@decorator	增强函数功能
生成器	yield value	惰性生成数据
递归	函数调用自身	解决分治问题
闭包	嵌套函数	记住外部变量