Python函数参数传递机制与高级应用解析

1. Python函数基础：从参数传递到返回值本质

1.1 函数参数设计的底层逻辑

在Python中，函数参数传递实际上是通过对象引用实现的。当调用函数时，每个参数都是对原始对象的引用。理解这一点对避免常见的参数传递陷阱至关重要。

参数传递的本质是"共享对象引用"，而不是传统意义上的值传递或引用传递。这意味着：

• 不可变对象（如整数、字符串）在函数内的修改会创建新对象
• 可变对象（如列表、字典）的修改会影响原始对象

1.1.1 位置参数与默认参数的陷阱

python复制def register(name, age=18, hobbies=None):
    hobbies = hobbies or []  # 防御性编程，避免默认可变参数陷阱
    print(f"{name}, {age}岁，爱好：{hobbies}")
    
register("张三")  # 正常使用
register("李四", hobbies=["篮球"])  # 显式传递空列表

关键细节：

1. 默认参数在函数定义时求值，而非调用时
2. 永远不要用可变对象作为默认参数（如def func(items=[])）
3. 类型注解（如age: int）仅用于文档，不强制类型检查

1.1.2 *args和**kwargs的进阶用法

python复制def logger(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}，参数：{args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@logger
def calculate(x, y, operation='add'):
    if operation == 'add':
        return x + y
    elif operation == 'multiply':
        return x * y

calculate(3, 5, operation='multiply')

实际应用场景：

• 装饰器开发必须使用*args, **kwargs保持接口通用性
• 参数转发时保持原始调用签名
• 实现类似print()的可变参数函数

1.2 返回值机制的深度解析

Python函数的返回值处理比表面看起来更复杂。每个函数调用都会在调用栈上创建一个栈帧（stack frame），返回值通过这个机制传递。

字节码层面的真相：

python复制import dis
def example():
    return 42

dis.dis(example)
"""
  2           0 LOAD_CONST               1 (42)
              2 RETURN_VALUE
"""

1.2.1 多返回值背后的元组打包

当函数"返回多个值"时，实际上是隐式创建了元组：

python复制def get_coordinates():
    x = 10
    y = 20
    return x, y  # 等价于 return (x, y)

coords = get_coordinates()
print(type(coords))  # <class 'tuple'>

解包技巧：

python复制x, y = get_coordinates()  # 元组解包
head, *tail = [1, 2, 3, 4]  # 扩展解包（Python 3+）

1.3 函数作为一等公民的实践

Python中函数是对象这一特性，打开了面向函数编程的大门。我们可以实现很多高阶模式。

1.3.1 函数工厂模式

python复制def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(5))  # 25
print(cube(5))    # 125

1.3.2 策略模式实现

python复制def execute_strategy(data, strategy):
    return strategy(data)

def double_all(numbers):
    return [x*2 for x in numbers]

def square_all(numbers):
    return [x**2 for x in numbers]

data = [1, 2, 3]
print(execute_strategy(data, double_all))  # [2, 4, 6]
print(execute_strategy(data, square_all))  # [1, 4, 9]

2. 闭包与作用域的高级应用

2.1 闭包的实现原理

闭包不仅仅是"函数返回函数"，它的核心是保留定义时的词法环境。Python通过__closure__属性实现这一机制。

python复制def outer():
    x = 10
    def inner():
        print(x)
    return inner

f = outer()
print(f.__closure__)  # 包含cell对象的元组
print(f.__closure__[0].cell_contents)  # 10

性能考虑：

• 闭包访问外部变量比访问局部变量慢
• 在循环中频繁调用的闭包，应考虑将外部变量转为参数传递

2.2 作用域链的完整解析

Python采用LEGB规则查找变量：

1. Local（局部作用域）
2. Enclosing（闭包作用域）
3. Global（模块全局）
4. Built-in（内置名称）

python复制x = 'global'

def outer():
    x = 'enclosing'
    def inner():
        x = 'local'
        print(x)  # local
        print(globals()['x'])  # global
    inner()

outer()

2.3 nonlocal的典型应用场景

nonlocal最常见的用途是实现有状态的函数：

python复制def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

c = counter()
print(c(), c(), c())  # 1 2 3

与类的对比：

python复制class Counter:
    def __init__(self):
        self.count = 0
    
    def __call__(self):
        self.count += 1
        return self.count

c = Counter()
print(c(), c(), c())  # 1 2 3

闭包方案更轻量，适合简单状态管理；类方案更灵活，适合复杂场景。

3. 递归编程的艺术与科学

3.1 递归的时空复杂度分析

以斐波那契数列为例，对比不同实现的性能：

python复制# 朴素递归：O(2^n)时间，O(n)空间
def fib(n):
    if n <= 1: return n
    return fib(n-1) + fib(n-2)

# 记忆化递归：O(n)时间，O(n)空间
from functools import lru_cache
@lru_cache(maxsize=None)
def fib_memo(n):
    if n <= 1: return n
    return fib_memo(n-1) + fib_memo(n-2)

# 迭代法：O(n)时间，O(1)空间
def fib_iter(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

性能测试：

python复制import timeit
n = 35
print(timeit.timeit(lambda: fib(n), number=1))       # 约3秒
print(timeit.timeit(lambda: fib_memo(n), number=1))  # 约0.0001秒
print(timeit.timeit(lambda: fib_iter(n), number=1))  # 约0.00001秒

3.2 尾递归优化与Python的限制

虽然Python官方解释器不支持尾递归优化(TCO)，但我们可以手动实现：

python复制def factorial(n, acc=1):
    if n == 0: return acc
    return factorial(n-1, acc*n)

# 手动优化为迭代
def factorial_iter(n):
    acc = 1
    while n > 0:
        n, acc = n-1, acc*n
    return acc

递归深度限制：

python复制import sys
print(sys.getrecursionlimit())  # 通常1000
sys.setrecursionlimit(2000)     # 谨慎修改！

3.3 递归可视化调试技巧

使用缩进打印递归调用过程：

python复制def factorial_debug(n, depth=0):
    indent = '  ' * depth
    print(f"{indent}-> factorial({n})")
    if n == 0:
        result = 1
    else:
        result = n * factorial_debug(n-1, depth+1)
    print(f"{indent}<- {result}")
    return result

factorial_debug(4)

输出示例：

code复制-> factorial(4)
  -> factorial(3)
    -> factorial(2)
      -> factorial(1)
        -> factorial(0)
        <- 1
      <- 1
    <- 2
  <- 6
<- 24

4. Lambda与函数式编程实践

4.1 Lambda的合理使用场景

Lambda最适合短小的回调函数，过度使用会降低可读性：

python复制# 好的用法
points = [(1, 2), (3, 1), (5, 4)]
points.sort(key=lambda p: p[1])  # 按y坐标排序

# 不好的用法（应定义命名函数）
process = lambda x: (x**2 if x%2==0 else x**3)  # 过于复杂

4.2 函数式三剑客：map/filter/reduce

python复制from functools import reduce

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

# map: 对每个元素应用函数
squares = list(map(lambda x: x**2, numbers))

# filter: 过滤元素
evens = list(filter(lambda x: x%2==0, numbers))

# reduce: 累积计算
product = reduce(lambda x, y: x*y, numbers, 1)

print(squares, evens, product)  # [1,4,9,16,25] [2,4] 120

现代替代方案：

• 列表推导式通常比map/filter更易读
• sum(), all(), any()等内置函数覆盖常见reduce场景

4.3 偏函数（Partial）的应用

python复制from functools import partial

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

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(5))    # 125

实际应用：

• 固定回调函数参数
• 创建特定配置的函数版本
• 与GUI事件处理结合

5. 函数最佳实践与性能优化

5.1 函数设计原则

1. 单一职责原则：一个函数只做一件事
2. 明确接口：参数不超过5个，复杂配置使用字典或对象
3. 无副作用：避免修改输入参数，返回新对象而非就地修改
4. 防御性编程：验证输入，处理边界条件

5.2 性能优化技巧

缓存装饰器实现：

python复制from functools import wraps

def cache(func):
    memo = {}
    @wraps(func)
    def wrapper(*args):
        if args not in memo:
            memo[args] = func(*args)
        return memo[args]
    return wrapper

@cache
def expensive_calculation(x):
    print(f"计算 {x}...")
    return x * x

print(expensive_calculation(4))  # 计算...
print(expensive_calculation(4))  # 直接返回缓存

循环优化：

python复制# 慢：每次循环都查找len()
for i in range(len(items)):
    ...

# 快：先缓存长度
n = len(items)
for i in range(n):
    ...

5.3 调试与测试建议

1. 类型提示：Python 3.5+支持类型注解，提高可维护性

   python复制from typing import List, Tuple
   
   def process(items: List[str]) -> Tuple[int, float]:
       ...
   

2. 文档字符串标准：

   python复制def calculate(a, b):
       """计算两个数的和与积
       
       参数:
           a (int): 第一个操作数
           b (int): 第二个操作数
           
       返回:
           tuple: (和, 积)
       """
       return a+b, a*b
   

3. 单元测试模式：

   python复制import unittest
   
   class TestFunctions(unittest.TestCase):
       def test_add(self):
           self.assertEqual(add(2,3), 5)
           self.assertEqual(add(-1,1), 0)
       
       def test_divide(self):
           with self.assertRaises(ZeroDivisionError):
               divide(1, 0)
   

6. 函数在Python生态中的实际应用

6.1 回调机制实现事件驱动

python复制class Button:
    def __init__(self):
        self._click_handlers = []
    
    def on_click(self, handler):
        self._click_handlers.append(handler)
    
    def click(self):
        print("按钮被点击")
        for handler in self._click_handlers:
            handler(self)

def log_click(button):
    print(f"日志记录：{button}被点击")

btn = Button()
btn.on_click(lambda b: print("匿名函数处理点击"))
btn.on_click(log_click)
btn.click()

6.2 生成器函数的强大能力

python复制def fibonacci_sequence():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci_sequence()
print(next(fib), next(fib), next(fib))  # 0 1 1

# 生成器表达式
squares = (x**2 for x in range(10))
print(sum(squares))  # 285

6.3 上下文管理器与with语句

python复制from contextlib import contextmanager

@contextmanager
def timer(name):
    start = time.time()
    try:
        yield
    finally:
        print(f"{name}耗时：{time.time()-start:.2f}秒")

with timer("计算过程"):
    result = sum(x**2 for x in range(1000000))

7. 函数式设计模式深度解析

7.1 装饰器模式的进阶应用

python复制def retry(max_attempts=3, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    if attempts == max_attempts:
                        raise
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=5, delay=2)
def unreliable_api_call():
    if random.random() < 0.7:
        raise ValueError("API调用失败")
    return "成功"

print(unreliable_api_call())

7.2 策略模式的函数式实现

python复制def calculate_tax(income, strategy):
    return strategy(income)

def progressive_tax(income):
    if income < 10000:
        return income * 0.1
    elif income < 50000:
        return income * 0.2
    else:
        return income * 0.3

def flat_tax(income):
    return income * 0.15

income = 60000
print(calculate_tax(income, progressive_tax))  # 18000
print(calculate_tax(income, flat_tax))         # 9000

7.3 观察者模式的事件系统

python复制class Event:
    def __init__(self):
        self._handlers = []
    
    def subscribe(self, handler):
        self._handlers.append(handler)
    
    def unsubscribe(self, handler):
        self._handlers.remove(handler)
    
    def fire(self, *args, **kwargs):
        for handler in self._handlers:
            handler(*args, **kwargs)

on_message = Event()

def log_message(msg):
    print(f"日志：{msg}")

on_message.subscribe(lambda m: print(f"收到：{m}"))
on_message.subscribe(log_message)

on_message.fire("Hello World")

8. 元编程中的函数魔法

8.1 动态函数创建

python复制def create_operator(op):
    if op == '+':
        return lambda x, y: x + y
    elif op == '*':
        return lambda x, y: x * y
    else:
        raise ValueError("未知运算符")

adder = create_operator('+')
print(adder(3, 5))  # 8

8.2 函数属性的妙用

python复制def counter():
    counter.count = getattr(counter, 'count', 0) + 1
    return counter.count

print(counter(), counter(), counter())  # 1 2 3

8.3 函数签名自省

python复制from inspect import signature

def typed_func(name: str, age: int = 18) -> str:
    return f"{name}: {age}"

sig = signature(typed_func)
print(sig.parameters)  # OrderedDict([('name', <Parameter "name: str">), ...])
print(sig.return_annotation)  # <class 'str'>

9. 异步函数与协程

9.1 从生成器到async/await

python复制import asyncio

async def fetch_data():
    print("开始获取数据")
    await asyncio.sleep(1)
    print("数据获取完成")
    return {"data": 42}

async def main():
    task = asyncio.create_task(fetch_data())
    print("其他工作...")
    result = await task
    print(f"结果：{result}")

asyncio.run(main())

9.2 异步上下文管理器

python复制class AsyncConnection:
    async def __aenter__(self):
        print("建立连接...")
        await asyncio.sleep(0.5)
        return self
    
    async def __aexit__(self, exc_type, exc, tb):
        print("关闭连接...")
        await asyncio.sleep(0.5)

async def use_connection():
    async with AsyncConnection() as conn:
        print("使用连接...")

asyncio.run(use_connection())

10. 函数性能分析与优化

10.1 使用cProfile分析

python复制import cProfile

def slow_function():
    return sum(x**2 for x in range(10**6))

cProfile.run('slow_function()', sort='cumulative')

10.2 使用functools.lru_cache

python复制from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(100))  # 快速计算

10.3 Cython加速关键函数

python复制# fib.pyx
def fib_cython(int n):
    cdef int a = 0, b = 1, i
    for i in range(n):
        a, b = b, a + b
    return a

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(ext_modules=cythonize("fib.pyx"))

11. 函数安全与防御性编程

11.1 参数验证装饰器

python复制def validate_input(*validators):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for val, arg in zip(validators, args):
                if not val(arg):
                    raise ValueError(f"无效参数：{arg}")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_input(lambda x: x > 0, lambda y: isinstance(y, str))
def process(num, text):
    return text * num

print(process(3, "Hi"))  # HiHiHi

11.2 速率限制实现

python复制from datetime import datetime, timedelta

def rate_limit(calls_per_minute):
    times = []
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = datetime.now()
            times[:] = [t for t in times if now - t < timedelta(minutes=1)]
            if len(times) >= calls_per_minute:
                raise RuntimeError("超过速率限制")
            times.append(now)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@rate_limit(5)
def api_call():
    print("API调用成功")

for _ in range(6):  # 第6次会报错
    api_call()

12. 函数设计模式的反模式

12.1 过度使用全局变量

python复制# 不好：隐式依赖全局状态
config = {}

def init_settings():
    global config
    config["timeout"] = 10

def make_request():
    timeout = config.get("timeout", 1)  # 依赖全局config
    print(f"使用超时：{timeout}")

# 好：显式传递依赖
def make_request_better(config):
    timeout = config.get("timeout", 1)
    print(f"使用超时：{timeout}")

12.2 过于复杂的lambda

python复制# 不好：难以理解的lambda
process = lambda x: (x**2 if x%2==0 else (x**3 if x>10 else x))

# 好：使用命名函数
def process_number(x):
    if x % 2 == 0:
        return x ** 2
    elif x > 10:
        return x ** 3
    return x

12.3 滥用递归

python复制# 不好：线性过程的递归
def print_numbers(n):
    if n < 0: return
    print(n)
    print_numbers(n-1)

# 好：使用迭代
def print_numbers_iter(n):
    for i in range(n, -1, -1):
        print(i)

13. 函数式思维在实际项目中的应用

13.1 数据处理管道

python复制def pipeline(data, *funcs):
    for func in funcs:
        data = func(data)
    return data

data = [1, 2, 3, 4, 5]
result = pipeline(
    data,
    lambda x: [i**2 for i in x],
    lambda x: [i for i in x if i%2 ==0],
    sum
)
print(result)  # 20 (4 + 16)

13.2 配置驱动的业务逻辑

python复制def create_operation(op_config):
    def operation(data):
        result = data
        for step in op_config["steps"]:
            result = step["func"](result, **step.get("params", {}))
        return result
    return operation

config = {
    "steps": [
        {"func": lambda x, k: x * k, "params": {"k": 3}},
        {"func": lambda x, m: x + m, "params": {"m": 10}}
    ]
}

op = create_operation(config)
print(op(5))  # (5*3)+10 = 25

14. 现代Python函数特性

14.1 位置参数与关键字参数分离

Python 3.8+引入了/和*来明确参数传递方式：

python复制def precise_func(pos1, pos2, /, pos_or_kw, *, kw1, kw2):
    print(pos1, pos2, pos_or_kw, kw1, kw2)

precise_func(1, 2, 3, kw1=4, kw2=5)  # 正确
precise_func(1, 2, pos_or_kw=3, kw1=4, kw2=5)  # 正确
# precise_func(1, pos2=2, 3, kw1=4, kw2=5)  # 错误：pos2不能关键字传递

14.2 类型提示的进阶用法

python复制from typing import Callable, TypeVar, Optional

T = TypeVar('T')

def apply_func(value: T, func: Callable[[T], T]) -> T:
    return func(value)

def nullable_str(s: Optional[str]) -> int:
    return len(s) if s is not None else 0

14.3 数据类与函数的结合

python复制from dataclasses import dataclass
from typing import List

@dataclass
class Point:
    x: float
    y: float
    
def move_points(points: List[Point], dx: float, dy: float):
    for p in points:
        p.x += dx
        p.y += dy

points = [Point(1, 2), Point(3, 4)]
move_points(points, 1, -1)
print(points)  # [Point(x=2, y=1), Point(x=4, y=3)]

15. 函数调试与性能分析实战

15.1 使用pdb进行调试

python复制import pdb

def complex_calculation(a, b):
    result = 0
    for i in range(a):
        pdb.set_trace()  # 设置断点
        result += b ** i
    return result

# 在pdb提示符下可以：
# n(ext), s(tep), c(ontinue), l(ist), p(rint)等
print(complex_calculation(3, 2))

15.2 使用timeit进行微基准测试

python复制from timeit import timeit

def test_list_comp():
    return [x**2 for x in range(1000)]

def test_map_lambda():
    return list(map(lambda x: x**2, range(1000)))

print("列表推导式:", timeit(test_list_comp, number=1000))
print("map+lambda:", timeit(test_map_lambda, number=1000))

15.3 使用memory_profiler分析内存

python复制from memory_profiler import profile

@profile
def process_data():
    data = [x for x in range(100000)]
    result = [x**2 for x in data]
    del data  # 显式释放内存
    return result

process_data()

16. 函数式编程与OOP的结合

16.1 方法链的流畅接口

python复制class Calculator:
    def __init__(self, value=0):
        self.value = value
    
    def add(self, n):
        self.value += n
        return self
    
    def mul(self, n):
        self.value *= n
        return self
    
    def result(self):
        return self.value

result = Calculator().add(5).mul(3).add(10).result()
print(result)  # 25

16.2 使用闭包实现私有状态

python复制def create_counter():
    count = 0
    class Counter:
        def increment(self):
            nonlocal count
            count += 1
            return count
    return Counter()

counter = create_counter()
print(counter.increment())  # 1
print(counter.increment())  # 2

16.3 策略模式的多范式实现

python复制from abc import ABC, abstractmethod
from typing import Callable

# OOP方式
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

class QuickSort(SortStrategy):
    def sort(self, data):
        return sorted(data)

# 函数式方式
def bubble_sort(data):
    n = len(data)
    for i in range(n):
        for j in range(0, n-i-1):
            if data[j] > data[j+1]:
                data[j], data[j+1] = data[j+1], data[j]
    return data

# 多范式处理器
class DataProcessor:
    def __init__(self, strategy: Callable = sorted):
        self.strategy = strategy
    
    def process(self, data):
        return self.strategy(data)

# 使用
processor = DataProcessor(strategy=bubble_sort)
print(processor.process([3,1,4,2]))

17. 函数式反应式编程(FRP)初探

17.1 简单的响应式单元

python复制class Cell:
    def __init__(self, value):
        self._value = value
        self._dependents = []
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, new_value):
        if self._value != new_value:
            self._value = new_value
            for dep in self._dependents:
                dep.update()
    
    def bind(self, dependent):
        self._dependents.append(dependent)
        return self

class Formula:
    def __init__(self, formula_func, *cells):
        self._formula_func = formula_func
        self._cells = cells
        self._value = None
        for cell in cells:
            cell.bind(self)
        self.update()
    
    def update(self):
        new_value = self._formula_func(*(cell.value for cell in self._cells))
        if self._value != new_value:
            self._value = new_value
            print(f"公式更新为：{self._value}")
    
    @property
    def value(self):
        return self._value

a = Cell(10)
b = Cell(20)
sum_ab = Formula(lambda x,y: x+y, a, b)
a.value = 15  # 输出：公式更新为：35

18. 函数性能优化的边界

18.1 何时应该使用内置函数

python复制# 慢：自定义实现
def sum_squares(n):
    total = 0
    for i in range(n):
        total += i**2
    return total

# 快：使用内置函数和生成器表达式
def sum_squares_fast(n):
    return sum(i**2 for i in range(n))

# 更快：数学公式
def sum_squares_math(n):
    return n*(n-1)*(2*n-1)//6

18.2 函数内联的权衡

python复制# 小函数适合内联
def calculate(a, b):
    return add(mul(a, b), sub(a, b))  # 多次函数调用开销

# 优化后
def calculate_optimized(a, b):
    return a*b + (a-b)

18.3 避免不必要的函数调用

python复制# 不好：在循环中重复调用len()
for i in range(len(items)):
    process(items[i])

# 好：缓存长度
n = len(items)
for i in range(n):
    process(items[i])

# 更好：直接迭代
for item in items:
    process(item)

19. 函数在并发编程中的应用

19.1 多线程中的函数执行

python复制import threading

def worker(num):
    print(f"Worker {num} 开始")
    time.sleep(1)
    print(f"Worker {num} 结束")

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

19.2 多进程中的函数隔离

python复制from multiprocessing import Process

def cpu_bound_task(n):
    return sum(i*i for i in range(n))

if __name__ == '__main__':
    p = Process(target=cpu_bound_task, args=(10**7,))
    p.start()
    p.join()

19.3 线程池的高效使用

python复制from concurrent.futures import ThreadPoolExecutor

def process_item(item):
    # 模拟I/O密集型任务
    time.sleep(0.1)
    return item.upper()

items = ['a', 'b', 'c', 'd', 'e']
with ThreadPoolExecutor(max_workers=3) as executor:
    results = list(executor.map(process_item, items))
print(results)

20. 函数设计的前沿趋势

20.1 模式匹配（Python 3.10+）

python复制def handle_response(response):
    match response:
        case {'status': 200, 'data': data}:
            process_data(data)
        case {'status': 404}:
            print("未找到资源")
        case {'status': 500, 'error': msg}:
            print(f"服务器错误：{msg}")
        case _:
            print("未知响应格式")

20.2 结构化并发（Python 3.11+）

python复制async def perform_tasks():
    async with asyncio.TaskGroup() as tg:
        task1 = tg.create_task(fetch_data(1))
        task2 = tg.create_task(fetch_data(2))
    print(f"结果：{task1.result()}, {task2.result()}")

20.3 类型系统的增强

python复制from typing import TypeVar, Generic

T = TypeVar('T')

class Result(Generic[T]):
    def __init__(self, value: T | None, error: Exception | None = None):
        self.value = value
        self.error = error
    
    def unwrap(self) -> T:
        if self.error:
            raise self.error
        return self.value

def safe_divide(a: float, b: float) -> Result[float]:
    try:
        return Result(a / b)
    except Exception as e:
        return Result(None, e)