Python 3.10 的首个 PEP 诞生，内置类型 zip() 迎来新特性

译者前言：相信凡是用过 zip() 内置函数的人，都会赞同它颇有用，可是，它的最大问题是可能会产生出非预期的结果。PEP-618 提出给它增长一个参数，能够有效地解决你们的痛点。

这是 Python 3.10 版本正式采纳的第一个 PEP，「Python猫」一直有跟进社区最新动态的习惯，因此翻译了出来给你们尝鲜，强烈推荐一读。（PS：严格来讲，zip() 是一个内置类（built-in type），而不是一个内置函数（built-in function），但咱们通常都称它为一个内置函数。）

PEP原文 ： https://www.python.org/dev/peps/pep-0618/

PEP标题： Add Optional Length-Checking To zip

PEP做者： Brandt Bucher

建立日期： 2020-05-01

合入版本： 3.10

译者 ：豌豆花下猫 @Python猫公众号

PEP翻译计划 ：https://github.com/chinesehua...

摘要

本 PEP 建议给内置的 zip 添加一个可选的 strict 布尔关键字参数。当启用时，若是其中一个参数先被用尽了，则会引起 ValueError 。

动机

从做者的我的经验和一份对标准库的调查 来看，明显有不少（若是不是绝大多数）zip 用例要求可迭代对象必须是等长的。有时候，周围代码的上下文能够保证这点，可是要 zip 处理的数据一般是由调用者传入的、单独提供的或者以某种方式生成的。在这些状况下，zip 的默认行为意味着错误的重构或逻辑错误，很容易悄悄地致使数据丢失。这些 bug 不只难以定位，甚至难以被觉察到。

很容易想到形成这种问题的简单案例。例如，如下代码在 items 为一个序列（sequence）时能够良好地运行，可是若是调用者将 item 重构为一个可消耗的迭代器，则代码会悄悄地产生缩短的、不匹配的结果：

def apply_calculations(items):
    transformed = transform(items)
    for i, t in zip(items, transformed):
        yield calculate(i, t)

zip 还有几种常见用法。惯用的技巧性用法特别容易出问题，由于它们常常被不彻底了解代码工做方式的用户使用。下面是一个示例，解包到 zip 中以转化成嵌套的可迭代对象：

>>> x = [[1, 2, 3], ["one" "two" "three"]]
>>> xt = list(zip(*x))

另外一个例子是将数据“分块”成大小相等的组：

>>> n = 3
>>> x = range(n ** 2),
>>> xn = list(zip(*[iter(x)] * n))

在第一个例子中，非矩形数据一般会致使逻辑错误。在第二个例子中，长度不是 n 的倍数的数据一般也是错误。由于这两个习惯用法都会悄悄地忽略不匹配的尾部元素。

最有说服力的例子来自使用了 zip 的标准库ast ，它在 literal_eval 里产生过一个 bug，会直接丢弃不匹配的节点：

>>> from ast import Constant, Dict, literal_eval
>>> nasty_dict = Dict(keys=[Constant(None)], values=[])
>>> literal_eval(nasty_dict)  # Like eval("{None: }")
{}

实际上，笔者已经在 Python 的标准库和工具中找出了许多调用点， 当即在这些位置启用此新特性是恰当的。

基本原理

一些评论者声称：布尔开关常量是一种“代码坏气味（code-smell）”，或者与 Python 的设计哲学背道而驰。

可是，Python 当前在内置函数上有几个布尔关键字参数的用法，它们一般使用编译期常量来调用：

• compile(..., dont_inherit=True)
• open(..., closefd=False)
• print(..., flush=True)
• sorted(..., reverse=True)

标准库中还有许多相似用法。

这个新参数的想法和名称最初是由 Ram Rachum 提出的。该议题收到了 100 多个回复，而候选的“equal”也得到了相近的支持数。

笔者对它们没有很强烈的偏好，尽管“equal equals” 读起来有点尴尬。它还可能（错误地）暗示了 zip 的对象是相等的：

>>> z = zip([2.0, 4.0, 6.0], [2, 4, 8], equal=True)

规范

当用关键字参数 strict=True 调用内置类 zip 时，若是参数的长度不一样，则生成的迭代器会引起 ValueError。这个异常就发生在迭代器正常中止迭代的地方。

向上兼容

此项更改是彻底向上兼容的。当前的 zip 不接受关键字参数，默认省略 strict 的“非严格”用法会保持不变。

参考实现

笔者设计了一个 C 实现。

用 Python 大体翻译以下：

def zip(*iterables, strict=False):
    if not iterables:
        return
    iterators = tuple(iter(iterable) for iterable in iterables)
    try:
        while True:
            items = []
            for iterator in iterators:
                items.append(next(iterator))
            yield tuple(items)
    except StopIteration:
        if not strict:
            return
    if items:
        i = len(items)
        plural = " " if i == 1 else "s 1-"
        msg = f"zip() argument {i+1} is shorter than argument{plural}{i}"
        raise ValueError(msg)
    sentinel = object()
    for i, iterator in enumerate(iterators[1:], 1):
        if next(iterator, sentinel) is not sentinel:
            plural = " " if i == 1 else "s 1-"
            msg = f"zip() argument {i+1} is longer than argument{plural}{i}"
            raise ValueError(msg)

被拒绝的意见

（1）添加 itertools.zip_strict

这是 Python-Ideas 邮件列表上得到最多支持的替代方案，所以值得在此处加以讨论。它没有任何严重的缺陷，若是本 PEP 被否绝，它是一个很好的替代。

虽然考虑到这一点，可是在 zip 中添加可选参数能够用较小的更改而更好地解决诱发此 PEP 的问题。

（2）依照先例

itertools 中有一个 zip_longest，这彷佛让人颇有动机再添加一个 zip_strict。可是，zip_longest 在许多方面是一个更加复杂且特定的程序：它负责填写缺失的值，但其它函数都不须要操心这种事。

若是 zip 和 zip_longest 同时放在 itertools 中，或者都做为内置函数，那么在相同的地方添加 zip_strict 就确实是一个更有效的论点。然而，新的“strict”用法在接口和行为方面，相比起 zip_longest，更接近于 zip 的概念，但又不足以成为内置对象。考虑到这个缘由，令 zip 就地扩展出一个新的选项，彷佛是最天然的选择。

（3）易用性

若是 zip 可以防止此类 bug，那么用户在调用的地方启动检查，就会变得很是简单。与其编写一套繁重的逻辑来处理，不如用这个新特性来直接检查。

有人还认为，在标准库中放一个新的函数，相比在一个内置函数上加关键字参数，更“容易发现（discoverable）”。笔者不一样意这一论断。

（4）维护成本

尽管在提高易用性时，具体的实现是个次要问题，但重要的是要认识到，添加新的程序比修改原有程序复杂得多。与此 PEP 一块儿提供的 CPython 实现很是简单，而且对 zip 的默认行为没有显著的性能影响，而在 itertools 中添加一个全新的程序将须要：

• 复制 zip 的许多现有逻辑，zip_longest 就是这么干的。
• 大刀阔斧地重构 zip 或 zip_longest 或这二者，以便共享一个公共的或者继承性的实现（这可能会影响性能）。

（5）添加多个“模式”以供切换

若是预期有三个或更多模式（mode），这个建议才会比二元标志更有意义。最显而易见的三种模式是：“最短的”（当前 zip 的行为），“严格的”（本 PEP 提议的行为）和“最长的”（itertools.zip_longest 的行为）。

可是，除了当前的默认值以及本提案的“strict”模式，彷佛不须要再添加其它模式。最可能的是添加一个“最长的”模式，但这须要一个新的 fillvalue 参数（它对于前两种模式都没有意义），另外，itertools.zip_longest 已经完美地处理了这种模式，若在 zip 中添加该模式，将会形成重复。目前尚不清楚哪个是“显而易见的”选择：内置 zip 上的 mode 参数，仍是已经长期存在于 itertools 中的 zip_longest。

（6）给 zip 添加方法或者构造函数

考虑如下两个被提出来的作法：

>>> zm = zip(*iters).strict()
>>> zd = zip.strict(*iters)

尚不清楚哪一个更好，或者哪一个更差。若是 zip.strict 做为一个方法来实现，则 zm 没问题，可是 zd 会出现几种使人困惑的状况：

• 返回不包装在元组中的结果（若是 iters 仅包含一个元素，一个 zip 迭代器）。
• 参数类型错误时抛出 TypeError（若是 iters 只包含一个元素，不是一个 zip 迭代器）。
• 不然，参数数量不对时抛出 TypeError。

若是 zip.strict 是做为 classmethod 或 staticmethod 实现，则 zd 将成功执行，而 zm 将不产生任何结果（这正是咱们最初要避免的问题）。

本提案还面临着更为复杂的问题，由于 CPython 中 zip 内置类的实现细节是未文档化的。这意味着若选择以上的某种行为，当前的实现就会被“锁定”（或至少要求对其进行仿真）。

（7）变动 zip 的默认行为

zip 的默认行为没有什么“错” ，由于在许多状况下，这确实是正确处理大小不等的输入的方法。例如，在处理无限迭代器时，它很是有用。

itertools.zip_longest 已经用在仍然须要“额外”尾端数据的状况。

（8）使用回调来处理剩余对象

尽管基本上能够执行用户须要的任何操做，但此解决方案在处理常见问题时（例如舍弃不匹配的长度），变得没必要要的复杂且不直观。

（9）引起一个 AssertionError

没有内置函数或内置类的 API 会引起 AssertionError。此外，官方文档 这么写的（它的所有）：

Raised when an assert statement fails.

因为此功能与 Python 的 assert 语句无关，所以不该该引起 AssertionError。用户若但愿在优化模式下禁用检查（像一个 assert 语句），能够改用 strict = __debug__。

（10）在 map 上添加相似的特性

本 PEP 不建议对 map 做任何更改，由于不多使用带有多个可迭代参数的map。可是，本 PEP 的裁定可做为未来讨论相似特性的先例（应该出现）。

若是本 PEP 被拒绝，则 map 的那种特性实际上也不值得追求。若是经过了，则对 map 的更改不须要新的 PEP（尽管像全部提案同样，都应仔细考虑其有用性）。为了保持一致性，它应遵循此处讨论的跟 zip 相同的 API 和语义。

（11）什么也不作

此建议可能最没有吸引力。

悄悄地将数据截断是一种特别使人讨厌的 bug，而手写一个健壮的解决方案却并不是易事。Python 本身的标准库（前文提到的 ast）是有现实意义的反例，很容易就陷入本 PEP 试图避免的那种陷阱。

推荐阅读：

一、PEP中文翻译计划 (https://github.com/chinesehua...

二、学习 Python，怎能不懂点PEP呢？ (https://mp.weixin.qq.com/s/oR...