一句话结论:zip 返回的不是列表,是一个一次性迭代器;它按最短的那个可迭代对象截断,多出来的元素被静默丢掉;Python 3.10 起可以用 strict=True 把"长度不等"从静默变成报错。这三件事是同一条设计逻辑的不同侧面——zip 从不缓存,只做逐轮转发。
本文全部代码在 CPython 3.13.14 本机实测通过,strict 行为另在 CPython 3.10.0 交叉验证。
一、zip 返回的是什么
a = [1, 2, 3, 4]
b = ['a', 'b']
z = zip(a, b)
print(type(z)) # <class 'zip'>
print(iter(z) is z) # True
print(hasattr(z, '__next__')) # True
实测输出:
A1 zip 类型 -> zip | 是迭代器? = True | 有 __next__? = True
A1b 解包结果 -> [(1, 'a'), (2, 'b')] (最短截断,4 和 3 被丢掉)
iter(z) is z 为真,说明 zip 对象自己就是自己的迭代器——它实现的是迭代器协议,不是可迭代对象协议外面再包一层。这一点直接决定了第二节的现象。
顺带看两个边界:
list(zip([1, 2, 3])) # [(1,), (2,), (3,)] 单路 zip 生成一元组
list(zip()) # [] 零路直接空
二、为什么第二次遍历是空的
z2 = zip([1, 2], [3, 4])
print(list(z2)) # [(1, 3), (2, 4)]
print(list(z2)) # []
实测:
A2 第一次 list -> [(1, 3), (2, 4)] | 第二次 list -> [] (空)
不是 bug,是迭代器协议的必然结果:zip 对象内部只有一组指向底层迭代器的引用和一个"是否已耗尽"的状态,没有把结果存下来。第一次 list() 把它推到头,状态就永久停在耗尽位置。
这是最常见的线上坑:把 zip(...) 赋给一个变量,先拿它算了个 sum,后面再想 for 一遍,循环体一次都不进,而且不报任何错。要复用就显式 list(zip(...)),或者每次重新构造一个 zip。
需要多次遍历又要省内存时,正确做法是 itertools.tee(),或者干脆把数据源做成可重入的容器而不是迭代器。
三、最短截断,以及那个"多消耗一个元素"的细节
print(list(zip([1, 2, 3, 4], ['a', 'b']))) # [(1, 'a'), (2, 'b')]
4 和 3 没有报错,也没有补齐,直接消失。这在数据对齐场景里很危险:两个来源的行数对不上,zip 会把多出来的行悄悄吃掉,最后得到一份"看起来正常"的短结果。
更细的一层是消耗顺序。看这个实验:
consumed = []
def watch(n):
for i in range(n):
consumed.append(i)
yield i
z5 = zip(watch(5), [10, 11])
print(list(z5), consumed)
实测:
A5 list -> [(0, 10), (1, 11)] | watch 被消耗 -> [0, 1, 2] (短的一侧先耗尽,长的多取了 1 个)
watch 被推到了 2,但 2 并没有出现在结果里。原因是 zip 每一轮按从左到右的顺序依次 next() 各个迭代器:第一轮取 watch 的 0、列表的 10;第二轮取 1、11;第三轮先取 watch 的 2,再取列表时发现已耗尽,于是整个 zip 结束,刚取到的 2 被丢弃。
所以如果左侧是个有副作用的生成器(写日志、读网络流、扣库存),短输入会让长输入的那个生成器被多推进一次。这不是理论问题,是排查"为什么日志多了一行"时要想到的地方。
四、strict=True 把静默变成报错
Python 3.10 给 zip 加了 strict 关键字参数:
try:
list(zip([1, 2, 3], ['a', 'b'], strict=True))
except ValueError as e:
print(e)
# zip() argument 2 is shorter than argument 1
实测(3.13.14):
A3 strict 不等 -> ValueError: zip() argument 2 is shorter than argument 1
A3b strict 相等 -> [(1, 'a'), (2, 'b')]
我用 CPython 3.10.0 跑了同一行,报错完全一致,确认这是 3.10 引入而非更高版本才有的行为。
报错信息是 argument 2 is shorter than argument 1 或 argument 2 is longer than argument 1,编号从 1 起算、对应传入位置。凡是"两边本该一样长"的场合,都建议默认带上 strict=True:列名与值、特征与标签、并行下发的多份结果。多打 9 个字符,换一个不会静默错数据的保证。
注意 strict=True 只能发现长度不等,不能发现内容错配;而且它是在遍历到末尾时才抛错,若中途已经消费了副作用,副作用不会回滚。
五、惰性到底惰在哪
def gen(tag, n):
for i in range(n):
print(' [yield]', tag, i)
yield i
z4 = zip(gen('X', 3), gen('Y', 3))
print(next(z4))
实测:
A4 惰性取 1 次 next:
[yield] X 0
[yield] Y 0
next -> (0, 0)
A4b 只 next 一次就停,未继续 yield,说明不预取全部
只推进了每个生成器各一次。哪怕传进去的是无限迭代器 itertools.count(),zip 也能配合另一个有限序列正常结束。它不预先读全、不物化中间表,内存占用是 O(1)(与输入长度无关,只与参数个数有关)。
对照一下 zip_longest:
list(itertools.zip_longest([1, 2, 3, 4], ['a', 'b'], fillvalue='-'))
# [(1, 'a'), (2, 'b'), (3, '-'), (4, '-')]
它同样惰性,但按最长的来,缺位用 fillvalue 补。选哪个取决于业务语义:要"一一对应、缺一不可"用 zip(..., strict=True);要"逐行对齐、允许尾部缺失"用 zip_longest。
六、性能:zip 比按索引快多少
30 万对整数求和,三种写法本机实测:
| 写法 | 耗时 | 说明 |
|---|---|---|
for u, v in zip(x, y) |
0.0250s | 最快,C 层直接取两个 next() |
for i in range(len(x)): x[i]+y[i] |
0.0297s | 每轮两次下标索引 + 一次 range 推进 |
for i, u in enumerate(x): u+y[i] |
0.0363s | 元组解包 + 一次列表下标 |
A8 zip -> 0.0250s result=89999700000
A8 range索引 -> 0.0297s result=89999700000
A8 enumerate -> 0.0363s result=89999700000
zip 省掉了 Python 层的下标计算,还顺带让代码更短。差距在 20%~45% 量级,不算决定性,但方向稳定:并行遍历多个序列,zip 本身就是最优解,不需要为了"性能"改回索引写法。
七、手写一遍,把机制钉死
def my_zip(*iters, strict=False):
its = [iter(x) for x in iters]
while True:
row = []
for i, it in enumerate(its):
try:
row.append(next(it))
except StopIteration:
if strict and i > 0:
raise ValueError('zip() argument %d is longer ...' % (i + 1))
# strict=True 时还要检查其余迭代器是否仍有剩余
...
return
yield tuple(row)
实测 list(my_zip([1,2,3,4], ['a','b'])) 得到 [(1, 'a'), (2, 'b')],与内置一致。手写版的价值在于把三件事暴露得很清楚:逐轮 next、从左到右、遇到第一个耗尽就 return。内置版只是把这段逻辑放进 C,加上 strict 的收尾检查。
八、排错清单
for循环一次没进,也不报错 → 检查zip对象是不是已经被list()/sum()/any()消费过;要复用就先list()落盘。- 结果比预期短,尾部数据凭空消失 → 最短截断;对齐场景加
strict=True,让长度不等立刻暴露。 - 生成器里的副作用多执行了一次 → 长度不等时,靠左的生成器会被多
next()一次;把有副作用的迭代器放右侧,或先统一长度。 - 想补齐而不是截断 → 用
itertools.zip_longest(..., fillvalue=...)。 - 需要下标 → 用
enumerate(zip(a, b)),别退回range(len(a))。 - 字典构造键值错配 →
dict(zip(keys, values))前先assert len(keys) == len(values);更稳的是dict(zip(keys, values, strict=True))(3.10+)。 - 传了生成器又想二次遍历 → 生成器本身也是一次性的,
zip救不了;要么转list,要么重新生成。
一句话收尾:zip 的三个"怪脾气"其实是同一个选择——只转发、不存储。理解了这点,截断、耗尽、惰性就都不用背了。