python - 如何限制循环的迭代？

Question

假设我有一个项目列表，我想遍历其中的前几个:

items = list(range(10)) # I mean this to represent any kind of iterable.
limit = 5

朴素的实现

来自其他语言的 Python naïf 可能会编写这个完美的可服务性和高性能(如果是单一的)代码:

index = 0
for item in items: # Python's `for` loop is a for-each.
    print(item)    # or whatever function of that item.
    index += 1
    if index == limit:
        break

更惯用的实现

但是 Python 有枚举，它很好地包含了大约一半的代码:

for index, item in enumerate(items):
    print(item)
    if index == limit: # There's gotta be a better way.
        break

所以我们已经将额外的代码减半了。但一定有更好的方法。

我们可以近似下面的伪代码行为吗？

如果 enumerate 采用了另一个可选的 stop 参数(例如，它采用如下的 start 参数:enumerate(items, start=1)) 我认为这很理想，但以下内容不存在(参见 documentation on enumerate here ):

# hypothetical code, not implemented:
for _, item in enumerate(items, start=0, stop=limit): # `stop` not implemented
    print(item)

请注意，没有必要为 index 命名，因为不需要引用它。

是否有一种惯用的方式来编写上述内容？怎么样？

第二个问题:为什么这不是内置在枚举中？

Answer 1

How can I limit iterations of a loop in Python?

for index, item in enumerate(items):
    print(item)
    if index == limit:
        break

Is there a shorter, idiomatic way to write the above? How?

包括索引

zip 在其参数中最短的可迭代对象处停止。 (与 zip_longest 的行为相反，它使用最长的可迭代对象。)

range 可以提供一个有限的迭代器，我们可以将它与我们的主迭代器一起传递给 zip。

所以我们可以将 range 对象(带有它的 stop 参数)传递给 zip 并像有限枚举一样使用它。

zip(range(limit), items)

使用 Python 3，zip 和 range 返回可迭代对象，它们通过管道传输数据，而不是在中间步骤中将数据具体化。

for index, item in zip(range(limit), items):
    print(index, item)

要在 Python 2 中获得相同的行为，只需将 xrange 替换为 range 并将 itertools.izip 替换为 zip.

from itertools import izip
for index, item in izip(xrange(limit), items):
    print(item)

如果不需要索引，itertools.islice

你可以使用itertools.islice:

for item in itertools.islice(items, 0, stop):
    print(item)

不需要分配给索引。

组合enumerate(islice(items, stop))获取索引

正如 Pablo Ruiz Ruiz 指出的那样，我们也可以用 enumerate 组成 islice。

for index, item in enumerate(islice(items, limit)):
    print(index, item)

Why isn't this built into enumerate?

这里是用纯 Python 实现的枚举(可能会进行修改以在注释中获得所需的行为):

def enumerate(collection, start=0):  # could add stop=None
    i = start
    it = iter(collection)
    while 1:                         # could modify to `while i != stop:`
        yield (i, next(it))
        i += 1

对于那些已经使用 enumerate 的人来说，上面的性能会降低，因为它必须检查是否是时候停止每次迭代。如果没有停止参数，我们可以检查并使用旧的枚举:

_enumerate = enumerate

def enumerate(collection, start=0, stop=None):
    if stop is not None:
        return zip(range(start, stop), collection)
    return _enumerate(collection, start)

这个额外的检查对性能的影响可以忽略不计。

至于为什么 enumerate 没有停止参数，这是最初提出的(见PEP 279):

This function was originally proposed with optional start and stop arguments. GvR [Guido van Rossum] pointed out that the function call enumerate(seqn, 4, 6) had an alternate, plausible interpretation as a slice that would return the fourth and fifth elements of the sequence. To avoid the ambiguity, the optional arguments were dropped even though it meant losing flexibility as a loop counter. That flexibility was most important for the common case of counting from one, as in:

for linenum, line in enumerate(source,1):  print linenum, line

显然 start 被保留是因为它非常有值(value)，而 stop 被删除是因为它的用例较少并且导致新功能的使用困惑.

避免使用下标符号进行切片

另一个答案说:

Why not simply use

for item in items[:limit]: # or limit+1, depends

这里有一些缺点:

• 它只适用于接受切片的迭代，因此它受到更多限制。
• 如果他们确实接受切片，它通常会在内存中创建一个新的数据结构，而不是迭代引用数据结构，因此它会浪费内存(所有内置对象在切片时都会复制，但是，例如，numpy 数组会产生切片时查看)。
• 不可切片的可迭代对象需要其他类型的处理。如果您切换到惰性评估模型，则还必须使用切片更改代码。

只有在了解限制以及是否生成副本或 View 时，才应使用带下标表示法的切片。

结论

我假设现在 Python 社区知道 enumerate 的用法，混淆成本会被参数的值(value)所抵消。

在那之前，您可以使用:

for index, element in zip(range(limit), items):
    ...

或

for index, item in enumerate(islice(items, limit)):
    ...

或者，如果您根本不需要索引:

for element in islice(items, 0, limit):
    ...

并避免使用下标符号进行切片，除非您了解这些限制。