本篇是 Python 进阶语法的核心:闭包、装饰器、迭代器、生成器、上下文管理器。它们是写出高质量、Pythonic 代码的必备能力,也是面试的高频考点。

一、闭包

1.1 什么是闭包

闭包 = 函数 + 它引用的外部变量。当一个内层函数引用了外层函数的变量,并且外层函数把内层函数返回,这个内层函数(连同它捕获的外部变量)就构成了闭包(摘自练习代码 chapter02/26.闭包和装饰器.py):

1
2
3
4
5
6
7
8
def outer():
x = 10
def inner():
print(x) # 引用了外部变量 x
return inner

f = outer()
f() # 10,即使 outer 已执行完,inner 仍记得 x

关键点:外层函数执行结束后,其局部变量本应被回收,但被内层函数引用后,这些变量会被「记住」,生命周期延续。

1.2 用 nonlocal 修改外层变量

闭包内要修改外层变量,必须用 nonlocal 声明(第 5 篇讲过):

1
2
3
4
5
6
7
8
9
10
11
12
def counter():
count = 0
def add():
nonlocal count # 声明修改外层 count
count += 1
return count
return add

c = counter()
print(c()) # 1
print(c()) # 2
print(c()) # 3,每次调用共享同一个 count,状态被记住

1.3 闭包的价值

  • 保存状态:如上面的计数器,不用全局变量、不用类也能携带状态。
  • 装饰器的底层机制:装饰器本质上就是闭包的应用(见下一节)。

二、装饰器

装饰器是「在不修改原函数代码的前提下,给函数增强功能」的机制,本质是闭包 + 高阶函数。

2.1 基本原理与 @ 语法糖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def decorator(func):
def wrapper():
print("开始")
func()
print("结束")
return wrapper

# @decorator 等价于 test = decorator(test)
@decorator
def test():
print("执行 test")

test()
# 开始
# 执行 test
# 结束

@decorator 只是语法糖:它把下面的函数传给 decorator,再用返回的 wrapper 替换原函数名。

2.2 装饰带参数的函数(*args/**kwargs)

原函数有参数、有返回值时,装饰器要用 *args, **kwargs 透传:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import time

def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs) # 透传参数,并接收返回值
end = time.time()
print(f"耗时: {end - start:.4f}秒")
return result # 返回原函数结果
return wrapper

@timer
def slow(n):
time.sleep(n)
return n * 2

print(slow(1)) # 耗时: 1.0001秒 \n 2

2.3 functools.wraps 保留元信息

装饰器替换了原函数,会丢失原函数的 __name__、__doc__ 等信息。用 @functools.wraps 保留:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from functools import wraps

def decorator(func):
@wraps(func) # 保留 func 的元信息
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper

@decorator
def say():
"""打个招呼"""
pass

print(say.__name__) # 'say',没有 wraps 会是 'wrapper'
print(say.__doc__) # '打个招呼'

经验法则:写装饰器**一律加上 @wraps(func)**,否则调试、日志、文档都会错乱。

2.4 带参数的装饰器

需要给装饰器本身传参数时,外层再套一层函数(三层嵌套):

1
2
3
4
5
6
7
8
9
10
11
12
def repeat(n):                       # 第一层:接收装饰器参数
def decorator(func): # 第二层:接收被装饰函数
@wraps(func)
def wrapper(*args, **kwargs):# 第三层:实际执行
for _ in range(n):
func(*args, **kwargs)
return wrapper
return decorator

@repeat(3) # 执行 3 次
def greet():
print("hello")

理解要点:@repeat(3) 先调用 repeat(3) 返回一个装饰器,再用它装饰 greet。

2.5 多层装饰器叠加顺序

1
2
3
4
5
6
7
8
@d1
@d2
def test():
print("test")

# 等价于 test = d1(d2(test))
# 装饰时:从下往上(先 d2 后 d1)
# 执行时:从上往下(先 d1 的 wrapper 再 d2 的 wrapper)

简单记:装饰从下往上,执行从上往下。

2.6 类装饰器与内置装饰器

装饰器也可以是类(利用 __call__):

1
2
3
4
5
6
7
8
9
10
11
12
13
class Timer:
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs): # 让实例可调用
import time
start = time.time()
result = self.func(*args, **kwargs)
print(f"耗时 {time.time() - start:.4f}s")
return result

@Timer
def f():
pass

内置装饰器:@property、@classmethod、@staticmethod(见第 6 篇)、@lru_cache(见第 5 篇)。

2.7 装饰器常见应用

日志记录、计时统计、权限校验、缓存、重试、参数校验——几乎所有「横切关注点」都能用装饰器优雅实现:

1
2
3
4
5
6
7
8
9
10
11
12
def retry(times=3):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for i in range(times):
try:
return func(*args, **kwargs)
except Exception as e:
print(f"第 {i+1} 次失败: {e}")
raise
return wrapper
return decorator

三、迭代器

3.1 可迭代对象 vs 迭代器

这两个概念容易混,务必分清(摘自练习代码 chapter02/28.迭代器与生成器.py):

  • 可迭代对象(Iterable):能被 for 遍历的对象,如 list、str、dict、tuple、set。它们实现了 __iter__ 方法。
  • 迭代器(Iterator):能不断 next() 取值、且取完抛 StopIteration 的对象。实现了 __iter__(返回自身)和 __next__。

关系:迭代器一定是可迭代对象,可迭代对象不一定是迭代器。

1
2
3
4
5
6
7
8
9
10
nums = [1, 2, 3]
it = iter(nums) # 通过 iter() 拿到迭代器
print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
# print(next(it)) # StopIteration,取完了

# for 循环的底层就是:先 iter() 拿迭代器,再反复 next() 直到 StopIteration
for x in nums:
print(x)

判断:

1
2
3
4
5
from collections.abc import Iterable, Iterator
lst = [1, 2, 3]
print(isinstance(lst, Iterable)) # True,list 可迭代
print(isinstance(lst, Iterator)) # False,list 不是迭代器
print(isinstance(iter(lst), Iterator)) # True

3.2 自定义迭代器

实现 __iter__(返回自身)和 __next__(返回下一个值,取完抛 StopIteration):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class MyIterator:
def __init__(self, start, end):
self.current = start
self.end = end

def __iter__(self):
return self

def __next__(self):
if self.current < self.end:
self.current += 1
return self.current - 1
raise StopIteration

for x in MyIterator(1, 6):
print(x) # 1 2 3 4 5

实际开发中很少手写迭代器类,因为生成器(下一节)能用更简单的语法完成同样的事。


四、生成器

生成器是「按需生成数据的迭代器」,用多少取多少,不一次性生成全部,极大节省内存,是处理大数据流的核心工具。

4.1 两种创建方式

方式一:生成器表达式(把列表推导式的 [] 换成 ()):

1
2
3
4
g = (x for x in range(1, 6))
print(type(g)) # <class 'generator'>
print(next(g)) # 1
print(next(g)) # 2

方式二:含 yield 的函数:

1
2
3
4
5
6
7
8
def my_func():
for x in range(1, 6):
yield x # yield 而不是 return

g = my_func()
print(next(g)) # 1
for x in g:
print(x) # 2 3 4 5

4.2 yield 做了什么

yield 一次做三件事:

  1. 返回一个值;
  2. 暂停函数执行(保留当前进度);
  3. 保存现场(下次 next() 从 yield 下一行继续执行)。

这就是生成器「惰性」的根源。

4.3 内存优势(实测)

1
2
3
4
5
6
import sys
my_list = [x for x in range(10_000_000)] # 一次性占大量内存
my_gen = (x for x in range(10_000_000)) # 几乎不占内存

print(sys.getsizeof(my_list)) # 约 8 千万字节
print(sys.getsizeof(my_gen)) # 约 100 多字节

对比之下,生成器在处理千万级、流式数据时几乎是唯一选择(如逐行读大文件、生成无限序列)。

4.4 无限序列

生成器天然适合「无限序列」,因为它是惰性的:

1
2
3
4
5
6
7
8
9
10
def infinite():
n = 0
while True:
yield n
n += 1

for x in infinite(): # 不会卡死,因为每次只取一个
print(x)
if x > 5:
break

4.5 send / close 与 yield from

生成器还支持更高级的交互(日常用得较少,了解即可):

  • g.send(value):给生成器内部传值,并让 yield 表达式返回该值(需先 next(g) 启动)。
  • g.close():手动关闭生成器。
  • g.throw(exc):向生成器内部抛异常。
  • yield from:在一个生成器里委托另一个生成器,简化嵌套遍历:
1
2
3
4
def gen():
yield from [1, 2, 3] # 等价于逐个 yield
yield from "abc"
print(list(gen())) # [1, 2, 3, 'a', 'b', 'c']

五、上下文管理器

上下文管理器用于管理资源的获取与释放(文件、锁、数据库连接等),保证无论是否异常,资源都能被正确释放。

5.1 with 语句(最常用)

1
2
3
4
5
6
7
8
9
10
# 传统写法:容易忘 close,异常时还可能漏掉
f = open("a.txt", "w", encoding="utf-8")
try:
f.write("hello")
finally:
f.close()

# with 写法:离开 with 块自动关闭(即使异常也关闭)
with open("a.txt", "w", encoding="utf-8") as f:
f.write("hello")

with 是 try...finally 的语法糖,更简洁、更安全。

5.2 原理:enter 与 exit

任何实现了 __enter__ 和 __exit__ 的对象都能用于 with:

  • with obj as x:进入时调用 obj.__enter__(),返回值赋给 x。
  • 退出 with 块时调用 obj.__exit__(...),即使块内抛异常也会调用。

自定义上下文管理器:

1
2
3
4
5
6
7
8
9
10
11
12
class Resource:
def __enter__(self):
print("获取资源")
return self # 返回值赋给 as 后的变量

def __exit__(self, exc_type, exc_val, exc_tb):
print("释放资源")
return False # False 表示异常继续向外抛;True 则吞掉异常

with Resource() as r:
print("使用资源")
# 获取资源 → 使用资源 → 释放资源

5.3 contextlib.contextmanager(更简洁)

用 @contextmanager 装饰器 + 生成器,可以用函数快速写上下文管理器:

1
2
3
4
5
6
7
8
9
10
11
12
from contextlib import contextmanager

@contextmanager
def managed_resource():
print("获取资源")
try:
yield "资源" # yield 前是 __enter__,yield 后是 __exit__
finally:
print("释放资源")

with managed_resource() as r:
print(f"使用{r}")

yield 之前的代码相当于 __enter__,yield 之后的代码相当于 __exit__,finally 保证异常时也释放。

5.4 contextlib.ExitStack

需要同时管理多个资源时,用 ExitStack 统一管理:

1
2
3
4
5
6
from contextlib import ExitStack

with ExitStack() as stack:
f1 = stack.enter_context(open("a.txt", "w"))
f2 = stack.enter_context(open("b.txt", "w"))
# 退出时自动逆序关闭 f2、f1

小结

高级语法是 Python 从「会用」到「精通」的分水岭:

  1. 闭包:函数 + 捕获的外部变量,能保存状态,是装饰器的底层。
  2. 装饰器:@ 语法糖 + *args/**kwargs + @wraps,可实现计时、日志、缓存、重试等横切功能;带参装饰器是三层嵌套。
  3. 迭代器:可迭代对象 ≠ 迭代器;iter()/next() 与 StopIteration 是 for 循环的底层。
  4. 生成器:yield / 生成器表达式,惰性求值、省内存,处理大数据和无限序列的核心。
  5. 上下文管理器:with + __enter__/__exit__,或用 @contextmanager;保证资源正确释放。