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

Question

假设我有一个项目列表,我想迭代它的前几个:

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

所以我们要把额外的代码减少一半.但是必须有一个更好的方法.

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

如果enumerate采用另一个可选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因为不需要引用它.

是否有一种习惯的方式来写上面的内容？怎么样？

第二个问题:为什么这不是枚举的？

Answer 1

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

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

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

包括指数

zip停止在其参数的最短迭代次数上.(与zip_longest使用最长迭代的行为相反.)

range 可以提供一个有限的迭代,我们可以传递与我们的主迭代压缩.

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

zip(range(limit), items)

使用Python 3,zip并range返回iterables,它们管理数据,而不是在列表中实现中间步骤的数据.

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)

为什么这不是内置的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):

此函数最初是使用可选的start和stop参数提出的.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社区知道枚举的用法,混淆成本将超过参数的值.

在此之前,您可以使用:

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

要么

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

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

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

除非您了解限制,否则请避免使用下标符号进行切片.

Answer 2

你可以用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

来自docs的示例:

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

Answer 3

为什么不简单地使用

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

这仅适用于某些迭代,但由于您指定了列表,因此它可以工作.

如果使用Sets或dicts等它不起作用.