如何限制循环的迭代次数？

假设我有一个项目列表，并且我想对其中的前几个项目进行迭代:

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

所以我们要把多余的代码减半，但是肯定有更好的办法。

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

如果枚举采用另一个可选的 stop参数(例如，它采用一个像这样的 start参数: enumerate(items, start=1)) ，我认为这是理想的，但下面的参数不存在(参见 这里有关枚举的文档) :

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

注意，不需要为 index命名，因为不需要引用它。

有没有一种惯用的写法? 怎么写？

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

110376 次浏览
小开
最佳答案

如何在 Python 中限制循环的迭代？

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

有没有一种更简短、更惯用的写法? 怎么写？

包括索引

zip在其参数的最短迭代上停止。(与 zip_longest的行为不同，zip_longest使用最长的迭代。)

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

因此，我们可以将一个 range对象(及其 stop参数)传递给 zip，并像使用有限枚举一样使用它。

zip(range(limit), items)

使用 Python3、 zip和 range返回迭代器，这些迭代器管道化数据，而不是在中间步骤的列表中具体化数据。

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

要在 Python2中获得相同的行为，只需将 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 指出的，我们也可以使用枚举来构成 islice。

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

为什么 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


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

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

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

这个函数最初是用可选启动提出的 和停止参数。 gvR [吉多·范罗苏姆]指出，函数调用 enumerate(seqn, 4, 6)有一个替代的，似是而非的解释 一个可以返回第四个和第五个元素的片 为了避免歧义，可选参数是 即使这意味着失去作为循环计数器的灵活性，它也会下降。 这种灵活性对于常见的 从一开始计数，如:

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

所以很明显，保留 start是因为它非常有价值，而放弃 stop是因为它的用例较少，并且造成了新功能使用上的混乱。

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

另一个回答是:

为什么不简单地使用

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

这里有一些缺点:

  • 它只适用于接受切片的可迭代程序，因此它受到更多的限制。
  • 如果它们接受切片，它通常会在内存中创建一个新的数据结构，而不是在引用数据结构上迭代，因此会浪费内存(所有内置对象在切片时都会复制，但是，例如，数字数组在切片时会创建一个视图)。
  • 不可切片的迭代将需要其他类型的处理。如果您切换到一个延迟计算模型，那么还必须使用切片来更改代码。

只有在了解限制以及它是复制还是创建视图时，才应该使用带下标符号的切片。

结论

我假设现在 Python 社区已经知道枚举的用法，那么参数的价值将超过混淆成本。

在此之前，你可以使用:

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

或者

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

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

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

并避免使用下标符号进行切片，除非您了解其局限性。

小开

为什么不简单地使用

for item in items[:limit]: # or limit+1, depends
print(item)    # or whatever function of that item.

这将只适用于一些可迭代文件，但是由于您指定了 List，因此它可以工作。

它不工作，如果你使用集或字典等。

小开

你可以使用 itertools.islice。它接受 start、 stop和 step参数，如果只传递一个参数，那么它就被认为是 stop。它可以与任何可迭代的。

itertools.islice(iterable, stop)
itertools.islice(iterable, start, stop[, step])

演示:

>>> from itertools import islice
>>> items = list(range(10))
>>> limit = 5
>>> for item in islice(items, limit):
print item,
...
0 1 2 3 4

来自文档的例子:

islice('ABCDEFG', 2) --> A B
islice('ABCDEFG', 2, 4) --> C D
islice('ABCDEFG', 2, None) --> C D E F G
islice('ABCDEFG', 0, None, 2) --> A C E G
小开

传递具有枚举内部限制的片

a = [2,3,4,2,1,4]


for a, v in enumerate(islice(a, 3)):
print(a, v)

产出:

0 2
1 3
2 4
小开

为什么不循环到列表的极限或结束，以发生在前面的为准，如下所示:

items = range(10)
limit = 5
for i in range(min(limit, len(items))):
print items[i]

产出:

0
1
2
3
4
小开

短期解决方案

items = range(10)
limit = 5


for i in items[:limit]: print(i)

提交答案