1. 迭代器：Python中的遍历利器
迭代器是Python中用于遍历数据集合的核心机制。它不仅仅是一个简单的循环工具，更是一种高效管理内存的设计模式。想象你正在阅读一本厚重的书，迭代器就像是一个书签，它记得你当前读到哪一页，并且知道如何翻到下一页。
1.1 迭代器协议与实现原理
Python中的迭代器遵循特定的协议，这个协议要求实现两个魔法方法：
__iter__()：返回迭代器对象本身__next__()：返回容器中的下一个元素
让我们看一个简单的自定义迭代器实现：
python复制class CountDown:
def __init__(self, start):
self.current = start
def __iter__(self):
return self
def __next__(self):
if self.current <= 0:
raise StopIteration
else:
self.current -= 1
return self.current + 1
# 使用示例
for num in CountDown(5):
print(num) # 输出5,4,3,2,1
注意：在实际开发中，我们很少直接实现迭代器类。Python提供了更简洁的方式——生成器，这将在第2章详细讨论。
1.2 迭代器的优势与应用场景
迭代器的核心优势在于它的惰性计算特性——只在需要时才产生数据，这在处理大型数据集时特别有用：
- 内存效率：不需要一次性加载所有数据
- 无限序列：可以表示无限的数据流（如斐波那契数列）
- 管道处理：可以将多个迭代器串联形成处理管道
python复制# 文件逐行读取的迭代器示例
with open('large_file.txt') as f:
for line in f: # 文件对象本身就是迭代器
process_line(line)
1.3 常见迭代器工具
Python标准库提供了丰富的迭代器工具：
itertools模块：提供各种迭代器操作函数map/filter：返回迭代器而非列表（Python3改进）enumerate：为可迭代对象添加索引zip：并行迭代多个可迭代对象
python复制from itertools import islice, cycle
# 创建一个无限循环的迭代器
colors = cycle(['red', 'green', 'blue'])
limited = islice(colors, 0, 5) # 只取前5个
print(list(limited)) # ['red', 'green', 'blue', 'red', 'green']
2. 生成器：优雅的迭代器工厂
生成器是创建迭代器的快捷方式，它通过yield语句暂停函数执行并返回中间结果。想象你在自助餐厅取餐——生成器就像是一个按需供应的餐台，你需要时才给你食物，而不是一次性把所有菜品堆在你面前。
2.1 生成器函数与yield机制
生成器函数与普通函数的区别在于它使用yield而非return：
python复制def fibonacci(limit):
a, b = 0, 1
while a < limit:
yield a
a, b = b, a + b
# 使用示例
for num in fibonacci(100):
print(num) # 0,1,1,2,3,5,8,13,21,34,55,89
yield的工作机制：
- 函数执行到
yield时暂停 - 返回
yield后面的值 - 下次调用时从暂停处继续执行
2.2 生成器表达式
类似于列表推导式，但使用圆括号且返回生成器：
python复制# 列表推导式（立即计算）
squares_list = [x**2 for x in range(10)]
# 生成器表达式（惰性计算）
squares_gen = (x**2 for x in range(10))
print(sum(squares_gen)) # 285
提示：当只需要迭代一次且数据量大时，优先使用生成器表达式节省内存。
2.3 生成器的进阶用法
2.3.1 双向通信
生成器可以通过send()方法接收外部数据：
python复制def accumulator():
total = 0
while True:
value = yield total
if value is None: break
total += value
gen = accumulator()
next(gen) # 启动生成器
print(gen.send(10)) # 10
print(gen.send(20)) # 30
2.3.2 协程与异步编程
生成器是Python协程的基础，虽然现在多使用async/await语法，但理解生成器有助于掌握协程本质：
python复制def async_worker():
print("Start work")
yield # 暂停执行
print("Continue work")
worker = async_worker()
next(worker) # 输出"Start work"
next(worker) # 输出"Continue work"
3. property装饰器：智能属性管理
@property装饰器是Python中实现属性访问控制的优雅方式。它就像是你家的智能门锁——外部看起来是简单的属性访问，内部却可以包含复杂的访问控制逻辑。
3.1 基本用法：从Java式getter/setter到Pythonic属性
传统Java风格的属性访问控制：
python复制class OldStyle:
def __init__(self):
self._value = None
def get_value(self):
return self._value
def set_value(self, new_value):
if new_value < 0:
raise ValueError("Value cannot be negative")
self._value = new_value
使用@property改进后的Pythonic风格：
python复制class NewStyle:
def __init__(self):
self._value = None
@property
def value(self):
return self._value
@value.setter
def value(self, new_value):
if new_value < 0:
raise ValueError("Value cannot be negative")
self._value = new_value
3.2 只读属性与延迟计算
@property非常适合实现只读属性和延迟计算：
python复制class Circle:
def __init__(self, radius):
self.radius = radius
@property
def area(self):
print("Calculating area...")
return 3.14 * self.radius ** 2
c = Circle(5)
print(c.area) # 第一次访问时计算
print(c.area) # 第二次访问直接使用缓存结果
3.3 属性删除与文档字符串
完整的property实现可以包含删除操作和文档说明：
python复制class Temperature:
def __init__(self, celsius):
self._celsius = celsius
@property
def celsius(self):
"""Get the temperature in Celsius"""
return self._celsius
@celsius.setter
def celsius(self, value):
self._celsius = value
@celsius.deleter
def celsius(self):
print("Deleting temperature")
del self._celsius
4. 三者的协同应用与实战技巧
在实际项目中，迭代器、生成器和property装饰器常常协同工作。让我们通过一个实战案例来看看它们的完美配合。
4.1 数据库查询结果的流式处理
假设我们需要处理大量数据库记录，同时要对某些敏感字段进行访问控制：
python复制class DatabaseStream:
def __init__(self, query):
self.query = query
self._batch_size = 100 # 默认批次大小
@property
def batch_size(self):
return self._batch_size
@batch_size.setter
def batch_size(self, value):
if not 10 <= value <= 1000:
raise ValueError("Batch size must be between 10 and 1000")
self._batch_size = value
def __iter__(self):
offset = 0
while True:
# 模拟数据库分页查询
records = get_records(self.query, offset, self.batch_size)
if not records:
break
for record in records:
yield process_record(record) # 使用生成器逐条产出处理后的记录
offset += self.batch_size
def process_record(record):
# 模拟记录处理
return {k: v for k, v in record.items() if not k.startswith('_')}
# 使用示例
stream = DatabaseStream("SELECT * FROM large_table")
stream.batch_size = 200 # 通过property设置批次大小
for record in stream: # 使用迭代器协议遍历
print(record)
4.2 性能优化技巧
- 生成器链式处理：将多个生成器串联形成处理管道，减少中间列表创建
python复制def filter_invalid(data):
for item in data:
if is_valid(item):
yield item
def transform(data):
for item in data:
yield process_item(item)
# 链式调用
processed = transform(filter_invalid(raw_data()))
- 属性缓存：使用property实现惰性计算和缓存
python复制class ExpensiveObject:
def __init__(self):
self._result = None
@property
def result(self):
if self._result is None:
print("Performing expensive calculation...")
self._result = self._calculate()
return self._result
def _calculate(self):
# 模拟耗时计算
return sum(i*i for i in range(10**6))
4.3 常见陷阱与解决方案
- 迭代器耗尽问题：迭代器只能遍历一次
python复制numbers = (x for x in range(5)) # 生成器表达式
print(sum(numbers)) # 10
print(sum(numbers)) # 0 (生成器已耗尽)
解决方案：如果需要多次遍历，可以转换为列表或重新创建生成器
- property滥用：过度使用property会使简单属性访问变得复杂
反例：
python复制class OverEngineered:
@property
def name(self):
return self._name
@name.setter
def name(self, value):
self._name = value
@name.deleter
def name(self):
del self._name
正解：只有需要额外逻辑时才使用property，否则直接使用公共属性
- 生成器内存泄漏：在循环中意外保留生成器引用
python复制def create_leak():
data = []
for i in (x for x in range(100)): # 生成器表达式
data.append(i*2)
return data
解决方案：确保生成器及时释放，大数据处理时考虑分块
在实际开发中，我发现合理组合这三种特性可以写出既高效又易维护的Python代码。特别是在处理数据管道和资源管理时，生成器与property的组合能优雅地解决许多复杂问题。比如最近在一个ETL项目中，我们使用生成器处理GB级的CSV文件，同时用property控制内存缓冲区大小，实现了内存占用稳定在50MB以下，而传统方法需要消耗2GB以上内存。