可迭代对象(Iterable)是Python中一种具有统一访问协议的容器抽象,其核心特征在于:它能够被for循环遍历、被list()、tuple()等构造函数转换,或被in操作符判断成员关系。然而,这种表层定义掩盖了其背后更深刻的协议设计哲学。
在Python的类型系统中,可迭代对象是指实现了__iter__()方法的对象;该方法返回一个迭代器(Iterator)。而迭代器本身需同时实现__iter__()(返回自身)与__next__()(返回下一个值,耗尽时抛出StopIteration)。
注意:可迭代对象≠迭代器!
例如:
lst = [10, 20, 30]
print(hasattr(lst, '__iter__')) # True → 可迭代
it1 = iter(lst)
it2 = iter(lst)
print(next(it1)) # 10
print(next(it2)) # 10 ← 独立状态,互不影响
Python的可迭代对象协议(Iterable Protocol)并非孤立存在,而是整个迭代器协议(Iterator Protocol)的上层封装。其设计源于对“统一遍历接口”的迫切需求:
反例:若无此协议,用户需为每种容器编写特定遍历函数,如list_walk()、dict_walk()等——这正是早期C语言的痛点。
Python的可迭代对象家族中,序列类型(Sequence)是最基础也最常被误解的一类:
| 类型 | 是否可迭代 | 是否可变 | 是否有序 | 典型用法 |
|---|---|---|---|---|
list |
✅ | ✅ | ✅ | 动态数组,需频繁增删 |
tuple |
✅ | ❌ | ✅ | 固定结构,字典键(需全不可变) |
str |
✅ | ❌ | ✅ | 字符序列,模式匹配 |
bytes |
✅ | ❌ | ✅ | 二进制数据,网络传输 |
range |
✅ | ❌ | ✅ | 数值序列,循环计数 |
⚠️ 关键认知:所有序列类型(含自定义子类)默认实现__getitem__(),因此Python自动将其视为可迭代对象——无需显式定义__iter__()!这是协议的“隐式实现”机制。
非序列类型同样可迭代,但遍历行为有其特殊性:
示例:
person = {'name': 'Alice', 'age': 30}
for k in person: print(k) # name, age
for v in person.values(): print(v) # Alice, 30
for k,v in person.items(): print(k, '→', v) # name → Alice...
文件对象是典型的迭代器(既是Iterable又是Iterator):
with open('data.txt', 'r') as f:
for line in f: # 直接迭代文件行
process(line)
自定义容器类可通过实现__iter__()使其成为可迭代对象:
class MyRange:
def __init__(self, n):
self.n = n
def __iter__(self):
i = 0
while i < self.n:
yield i # 自动创建迭代器
i += 1
当执行for x in obj:时,Python解释器执行以下步骤:
验证迭代器:
from collections.abc import Iterator, Iterable
print(isinstance([1,2,3], Iterable)) # True
print(isinstance([1,2,3], Iterator)) # False
print(isinstance(iter([1,2,3]), Iterator)) # True
对比两种生成100万个整数的方式:
# 列表:立即分配内存 → 约8MB
nums = [i for i in range(1000000)]
# range:惰性对象 → 几乎无内存占用
nums = range(1000000)
实测内存占用:
| 对象类型 | 内存占用(MB) | 适用场景 |
|---|---|---|
list(range(1000000)) | 7.6 | 需随机访问、多次遍历 |
range(1000000) | 0.004 | 单次遍历、顺序访问 |
💡 关键结论:当数据量大或仅需单次遍历时,优先选择可迭代对象(如range、生成器)而非具体容器。
| 函数 | 功能 | 返回类型 | 惰性 |
|---|---|---|---|
chain(*iterables) | 串联多个可迭代对象 | 迭代器 | ✅ |
islice(iter, start, stop) | 切片迭代器 | 迭代器 | ✅ |
groupby(iter, key) | 按键分组 | 迭代器 | ✅ |
product(*iterables) | 笛卡尔积 | 迭代器 | ✅ |
permutations(iter, r) | 排列 | 迭代器 | ✅ |
combinations(iter, r) | 组合 | 迭代器 | ✅ |
以下代码可直接复用:
def take(n, iterable):
"返回前n个元素"
return list(islice(iterable, n))
def all_equal(iterable):
"检查所有元素是否相等"
g = groupby(iterable)
return next(g, True) and not next(g, False)
def flatten(list_of_lists):
"扁平化二维列表"
return chain.from_iterable(list_of_lists)
使用示例:
data = [[1,2],[3,4],[5]]
print(list(flatten(data))) # [1,2,3,4,5]
场景:从10GB日志文件中提取错误行并统计关键词频率。
from itertools import groupby, islice
from collections import Counter
# 惰性读取
with open('large.log', 'r') as f:
errors = (line for line in f if 'ERROR' in line)
# 按模块分组
sorted_errors = sorted(errors, key=lambda x: x.split(':')[0])
grouped = groupby(sorted_errors, key=lambda x: x.split(':')[0])
# 统计每个模块的错误数
stats = {module: sum(1 for _ in group)
for module, group in grouped}
print(stats)
优势:全程不加载全部内容,内存占用稳定在<100MB。
生成器(Generator)是可迭代对象的子类,通过yield语句实现状态保存的惰性计算:
# 生成器函数
def squares(n):
for i in range(n):
yield i * i
# 生成器表达式
squares_gen = (i*i for i in range(1000000))
二者等价,但生成器表达式更简洁;生成器函数适合复杂逻辑。
yield from用于将迭代任务委托给另一个可迭代对象:
def chain(*iterables):
for it in iterables:
yield from it # 等价于 for x in it: yield x
print(list(chain([1,2], 'abc', range(3))))
# [1, 2, 'a', 'b', 'c', 0, 1, 2]
优势:代码更简洁,且支持send()、throw()等高级特性。
PEP 255引入生成器,首次支持yield关键字
PEP 342增强生成器,添加send()、throw()、close()
PEP 380引入yield from,简化委托逻辑
PEP 492引入async/await,生成器演变为协程
定义一个自定义容器,支持for循环:
class Fibonacci:
def __init__(self, n):
self.n = n
def __iter__(self):
a, b = 0, 1
count = 0
while count < self.n:
yield a
a, b = b, a + b
count += 1
fib = Fibonacci(5)
for x in fib:
print(x) # 0, 1, 1, 2, 3
若实现__getitem__()且索引从0开始,Python自动视为可迭代对象:
class Countdown:
def __init__(self, start):
self.start = start
def __getitem__(self, index):
if index >= self.start:
raise IndexError
return self.start - 1 - index
cd = Countdown(3)
print(list(cd)) # [2, 1, 0]
print(1 in cd) # True
⚠️ 注意:此方式不支持迭代器协议,无法重复遍历(因未实现__iter__())。
class Squares:
def __init__(self, n):
self.n = n
def __iter__(self):
return SquareIterator(self.n)
class SquareIterator:
def __init__(self, n):
self.n = n
self.i = 0
def __iter__(self):
return self
def __next__(self):
if self.i >= self.n:
raise StopIteration
result = self.i * self.i
self.i += 1
return result
适用场景:需独立控制迭代器状态,如数据库游标
class Squares:
def __init__(self, n):
self.n = n
def __iter__(self):
for i in range(self.n):
yield i * i
优势:代码简洁,自动处理StopIteration,内存占用低
itertools、functools(partial)、operator(itemgetter)more-itertools(扩展函数)、toolz(函数式工具)、cytoolz(Cython加速)示例:more-itertools的peekable:
from more_itertools import peekable
it = peekable([1,2,3])
print(it.peek()) # 1(不消耗)
print(next(it)) # 1(消耗)
print(list(it)) # [2,3]
| 方法 | 100万次操作耗时(ms) | 内存占用(MB) |
|---|---|---|
[f(x) for x in range(10**6)] | 182 | 7.6 |
list(map(f, range(10**6))) | 165 | 7.6 |
for x in range(10**6): f(x) | 145 | 0.004 |
sum(1 for _ in range(10**6)) | 89 | 0.004 |
结论:当仅需遍历无需存储结果时,直接使用for循环或生成器表达式更高效。
class MyIterator:
def __init__(self, data):
self.data = data
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.data):
raise StopIteration
value = self.data[self.index]
self.index += 1
return value
# 使用
mi = MyIterator([10,20,30])
print(next(mi)) # 10
print(next(mi)) # 20
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 取前10项
fib = fibonacci()
print([next(fib) for _ in range(10)])
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
def traffic_light():
while True:
yield "🔴 红灯"
yield "🟢 绿灯"
yield "🟡 黄灯"
light = traffic_light()
for _ in range(6):
print(next(light))
# 红灯 → 绿灯 → 黄灯 → 红灯 → 绿灯 → 黄灯