假设我有一个项目列表，我想迭代其中的前几个：

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

简单的实现

来自其他语言的 Python 新手可能会编写这样完美可用且高性能（如果不符合语法）的代码：

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)）我认为这是理想的，但下面的内容不存在（请参阅关于枚举的文档在这里 https://docs.python.org/3/library/functions.html#enumerate):

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

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

有没有一种惯用的方式来写上面的内容？如何？

第二个问题：为什么这没有内置到枚举中？

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

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

有没有更短、更惯用的方式来写上面的内容？如何？

包括索引

zip停止在其参数的最短迭代上。 （与行为相反zip_longest，它使用最长的可迭代对象。）

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

所以我们可以通过一个range对象（及其stop论证）到zip并像有限枚举一样使用它。

zip(range(limit), items)

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

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

要在 Python 2 中获得相同的行为，只需替换xrange for range and itertools.izip for 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)

为什么这个没有内置到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)

这项额外的检查会对性能产生轻微的影响，可以忽略不计。

As to whyenumerate 没有 stop 参数，这最初是提议的（参见PEP 279 https://www.python.org/dev/peps/pep-0279/):

该功能最初提出时带有可选启动 并停止争论。 GvR [Guido van Rossum] 指出函数调用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

这里有一些缺点：

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

当您了解限制以及它是否生成副本或视图时，您应该仅使用带下标表示法的切片。

结论

我认为现在 Python 社区知道了 enumerate 的用法，争论的价值将超过混乱成本。

在那之前，您可以使用：

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

or

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

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

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

并避免使用下标表示法进行切片，除非您了解限制。