【问题标题】:How can I limit iterations of a loop in Python?如何限制 Python 中循环的迭代?
【发布时间】:2016-07-06 12:37:19
【问题描述】:

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

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)),我认为这是理想的,但下面不存在(参见 @ 987654321@):

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

请注意,无需命名index,因为无需引用它。

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

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

【问题讨论】:

    标签: python enumerate


    【解决方案1】:

    如何在 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,ziprange 返回 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 指出的那样,我们也可以用 enumerate 组成 islice。

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

    为什么enumerate 没有内置这个功能?

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

    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):

    这个函数最初是用可选的 start 提出的 并停止争论。 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):
        ...
    

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

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

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

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

    【讨论】:

    • 如果你根本不需要索引并且想从头开始你不需要添加 Start 参数,所以只需:for element in islice(items, limit):
    【解决方案2】:

    您可以为此使用itertools.islice。它接受startstopstep 参数,如果你只传递一个参数,那么它被认为是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(generator, None) 来获取所有迭代 - 如果您想根据某些条件限制迭代,这很有用
    • 感谢您在上面的回答。这正是我需要帮助我调试一个运行了很长时间的进程,这样我就可以深入研究输出列表并解决我的代码中的错误。这应该是公认的答案。
    【解决方案3】:

    为什么不简单地使用

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

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

    如果你使用 Sets 或 dicts 等,它不起作用。

    【讨论】:

    • 是的,列表、元组和范围对象都采用切片,但它遗漏了很多,比如迭代器、集合和生成器。另一个缺点是它创建了一个新的数据结构,如列表或元组,而不是懒惰地评估数据。
    【解决方案4】:

    使用枚举中的限制传递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
    

    【讨论】:

      【解决方案5】:

      为什么不循环到限制或列表末尾,以较早发生者为准,如下所示:

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

      输出:

      0
      1
      2
      3
      4
      

      【讨论】:

        【解决方案6】:

        简短的解决方案

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

        【讨论】:

          猜你喜欢
          • 2020-03-21
          • 1970-01-01
          • 1970-01-01
          • 2011-01-02
          • 1970-01-01
          • 1970-01-01
          • 2023-03-20
          • 2021-05-01
          • 2018-01-21
          相关资源
          最近更新 更多