如何制作没有迭代器变量的 for 循环？

问题描述：

没有的话可以进行以下操作吗i？

for i in range(some_number):
    # do something

如果您只想做 N 次某件事而不需要迭代器。

解决方案 1：

我首先想到的答案是，没有。

我认为你能做的最好的事情是这样的：

def loop(f,n):
    for i in xrange(n): f()

loop(lambda: <insert expression here>, 5)

但我认为你可以忍受这个额外的i变量。

这里是使用变量的选项_，实际上，它只是另一个变量。

for _ in range(n):
    do_something()

请注意，_分配了在交互式 Python 会话中返回的最后一个结果：

>>> 1+2
3
>>> _
3

因此，我不会以这种方式使用它。我不知道 Ryan 提到的任何习语。它会弄乱你的解释器。

>>> for _ in xrange(10): pass
...
>>> _
9
>>> 1+2
3
>>> _
9

并且根据Python语法，这是一个可以接受的变量名：

identifier ::= (letter|"_") (letter | digit | "_")*

解决方案 2：

你可能正在寻找

for _ in itertools.repeat(None, times): ...

这是在 Python 中迭代时间的最快方法times。

解决方案 3：

分配给未使用的值的一般用法是命名它_。

for _ in range(times):
    do_stuff()

解决方案 4：

每个人都建议您使用 ，但并没有说 经常被用作gettext函数之一的快捷方式，因此如果您希望您的软件支持多种语言，那么最好避免将其用于其他目的。

import gettext
gettext.bindtextdomain('myapplication', '/path/to/my/language/directory')
gettext.textdomain('myapplication')
_ = gettext.gettext
# ...
print _('This is a translatable string.')

解决方案 5：

这是一个利用（滥用？）数据模型（Py3 链接）的随机想法。

class Counter(object):
    def __init__(self, val):
        self.val = val

    def __nonzero__(self):
        self.val -= 1
        return self.val >= 0
    __bool__ = __nonzero__  # Alias to Py3 name to make code work unchanged on Py2 and Py3

x = Counter(5)
while x:
    # Do something
    pass

我想知道标准库中是否有类似的东西？

解决方案 6：

您可以使用 _11（或任何数字或其他无效标识符）来防止与 gettext 发生名称冲突。任何时候使用下划线 + 无效标识符，您都会得到一个可以在 for 循环中使用的虚拟名称。

解决方案 7：

答案可能取决于使用迭代器时遇到的问题？可能使用

i = 100
while i:
    print i
    i-=1

或者

def loop(N, doSomething):
    if not N:
        return
    print doSomething(N)
    loop(N-1, doSomething)

loop(100, lambda a:a)

但坦白说，我认为使用这种方法毫无意义

解决方案 8：

我大体上同意上述解决方案。即：

1. 在循环中使用下划线for（2 行或更多行）

2. 定义一个普通while计数器（3 行及以上）

3. 声明一个带有__nonzero__实现的自定义类（更多行）

如果要像＃3那样定义一个对象，我建议使用关键字实现协议或应用contextlib。

此外，我建议另一个解决方案。它只有 3 个行，虽然不是极其优雅，但它使用了itertools包，因此可能会引起人们的兴趣。

from itertools import (chain, repeat)

times = chain(repeat(True, 2), repeat(False))
while next(times):
    print 'do stuff!'

在这些示例中，2是迭代循环的次数。chain包装了两个重复迭代器，第一个是有限的，但第二个是无限的。请记住，这些是真正的迭代器对象，因此它们不需要无限的内存。显然，这比解决方案 #1 慢得多。除非作为函数的一部分编写，否则可能需要清理times变量。

解决方案 9：

我们从以下的事情中得到了一些乐趣，值得与大家分享：

class RepeatFunction:
    def __init__(self,n=1): self.n = n
    def __call__(self,Func):
        for i in xrange(self.n):
            Func()
        return Func


#----usage
k = 0

@RepeatFunction(7)                       #decorator for repeating function
def Job():
    global k
    print k
    k += 1

print '---------'
Job()

结果：

0
1
2
3
4
5
6
---------
7

解决方案 10：

如果do_something是一个简单的函数或者可以包装在一个简单的map()函数中do_something range(some_number)：

# Py2 version - map is eager, so it can be used alone
map(do_something, xrange(some_number))

# Py3 version - map is lazy, so it must be consumed to do the work at all;
# wrapping in list() would be equivalent to Py2, but if you don't use the return
# value, it's wastefully creating a temporary, possibly huge, list of junk.
# collections.deque with maxlen 0 can efficiently run a generator to exhaustion without
# storing any of the results; the itertools consume recipe uses it for that purpose.
from collections import deque

deque(map(do_something, range(some_number)), 0)

如果您想将参数传递给do_something，您可能还会发现itertoolsrepeatfunc配方读起来很好：

传递相同的参数：

from collections import deque
from itertools import repeat, starmap

args = (..., my args here, ...)

# Same as Py3 map above, you must consume starmap (it's a lazy generator, even on Py2)
deque(starmap(do_something, repeat(args, some_number)), 0)

传递不同的参数：

argses = [(1, 2), (3, 4), ...]

deque(starmap(do_something, argses), 0)

解决方案 11：

现在您拥有的不再是不需要的计数器，而是不需要的列表。最好的解决方案是使用以“_”开头的变量，这样语法检查器就知道您没有使用该变量。

x = range(5)
while x:
  x.pop()
  print "Work!"

解决方案 12：

我们可以使用while和yield，我们可以像这样创建自己的循环函数。这里你可以参考官方文档。

def my_loop(start,n,step = 1):
    while start < n:
        yield start
        start += step

for x in my_loop(0,15):
    print(x)

解决方案 13：

在相关问题的回答中，@japs 计时了四种方法执行 do_something() N 次：一次性变量（标准）、下划线、itertools.repeat() (loopiter) 和 map(do_something, itertools.repeat()) (loopiter2)。这产生了具有明显差异的比较：

standard:  0.8398549720004667
underscore:  0.8413165839992871
loopiter:  0.7110594899968419
loopiter2:  0.5891903560004721

我决定在 do_something() 内部进行循环，这样它实际上会花费一些时间。这产生了以下比较：

standard: 8.756060799933039
underscore: 8.730245499988087
loopiter: 8.643029399914667
loopiter2: 8.489477000082843

我的结论是，循环的成本与做某事的成本相比微不足道。这个故事的寓意是，最好专注于优化你做的事情，而不是如何循环。

解决方案 14：

我知道的最简单的方法是 del：

for i in range(some_number):
    del i
    # do something

del 只是从内存中删除变量。没有警告等。

解决方案 15：

如果你真的想避免放置带有名称的东西（像 OP 中的迭代变量，或者不需要的列表或不需要的生成器在所需的时间内返回 true），那么如果你真的想要的话，你可以这样做：

for type('', (), {}).x in range(somenumber):
    dosomething()

使用的技巧是创建一个匿名类type('', (), {})，从而得到一个名称为空的类，但请注意，它不会插入到本地或全局命名空间中（即使提供了非空名称）。然后，您将该类的成员用作迭代变量，该变量是无法访问的，因为它所属的类是无法访问的。

解决方案 16：

那么：

while range(some_number):
    #do something