如何限制 Python 中循环的迭代次数？
How can I limit iterations of a loop in Python?
假设我有一个项目列表，我想遍历其中的前几个：
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 因为不需要引用它。
有没有一种惯用的方式来写上面的内容？怎么样？
第二个问题：为什么不将其内置到枚举中？
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 return 可迭代对象，它们通过管道传输数据而不是在中间步骤的列表中具体化数据。
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 指出的那样，我们也可以用枚举组合 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 没有stop参数，这是最初提出的（见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 被保留是因为它非常有价值，而 stop 被删除是因为它的用例较少并且导致新功能的使用混乱。
避免使用下标符号进行切片
另一个回答说：
Why not simply use
for item in items[:limit]: # or limit+1, depends
这里有一些缺点：
- 它只适用于接受切片的迭代器，因此它更受限制。
- 如果他们确实接受切片，它通常会在内存中创建一个新的数据结构，而不是迭代引用数据结构，因此会浪费内存（所有内置对象在切片时都会复制，但是，例如 numpy 数组切片时制作视图）。
- Unsliceable iterables 需要另一种处理方式。如果切换到惰性评估模型，则还必须更改带有切片的代码。
当您了解限制以及它是制作副本还是视图时，您应该只使用带下标符号的切片。
结论
我假设现在 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.
这仅适用于某些可迭代对象，但由于您指定了列表，因此它有效。
如果你使用 Sets 或 dicts 等，它不起作用
您可以为此使用 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
通过 islice 枚举内的限制
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)
假设我有一个项目列表，我想遍历其中的前几个：
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 因为不需要引用它。
有没有一种惯用的方式来写上面的内容？怎么样？
第二个问题：为什么不将其内置到枚举中？
How can I limit iterations of a loop in Python?
for index, item in enumerate(items): print(item) if index == limit: breakIs 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 return 可迭代对象，它们通过管道传输数据而不是在中间步骤的列表中具体化数据。
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 指出的那样，我们也可以用枚举组合 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 没有stop参数，这是最初提出的（见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 被保留是因为它非常有价值，而 stop 被删除是因为它的用例较少并且导致新功能的使用混乱。
避免使用下标符号进行切片
另一个回答说：
Why not simply use
for item in items[:limit]: # or limit+1, depends
这里有一些缺点：
- 它只适用于接受切片的迭代器，因此它更受限制。
- 如果他们确实接受切片，它通常会在内存中创建一个新的数据结构，而不是迭代引用数据结构，因此会浪费内存（所有内置对象在切片时都会复制，但是，例如 numpy 数组切片时制作视图）。
- Unsliceable iterables 需要另一种处理方式。如果切换到惰性评估模型，则还必须更改带有切片的代码。
当您了解限制以及它是制作副本还是视图时，您应该只使用带下标符号的切片。
结论
我假设现在 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.
这仅适用于某些可迭代对象，但由于您指定了列表，因此它有效。
如果你使用 Sets 或 dicts 等，它不起作用
您可以为此使用 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
通过 islice 枚举内的限制
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)