Можно ли реализовать Python для цикла диапазона без переменной итератора?

Можно ли делать следующие без i?

for i in range(some_number):
    # do something

Если вы просто хотите сделать что-то N раз и вам не нужен итератор.

С макушки головы, нет.

Я думаю, что лучшее, что вы могли бы сделать, это что-то вроде этого:

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

По этой причине я бы не стал использовать это таким образом. Я не знаю ни одной идиомы, упомянутой Райаном. Это может испортить ваш переводчик.

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

И согласно грамматике Python , это допустимое имя переменной:

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

Вы можете искать

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

это самый быстрый способ перебора timesвремен в Python.

Общая идиома назначения присваиваемого значения - присвоить ему имя _.

for _ in range(times):
    do_stuff()

Все, кто предлагает вам использовать _, не говорят, что _ часто используется как ярлык для одной из функций gettext , поэтому, если вы хотите, чтобы ваше программное обеспечение было доступно более чем на одном языке, лучше избегать его использования. для других целей.

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

Вот случайная идея, которая использует (злоупотребляет?) Модель данных ( ссылка 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

Интересно, есть ли что-то подобное в стандартных библиотеках?

Вы можете использовать _11 (или любой номер или другой недопустимый идентификатор), чтобы предотвратить конфликт имен с помощью gettext. Каждый раз, когда вы используете подчеркивание + неверный идентификатор, вы получаете фиктивное имя, которое можно использовать в цикле for.

Может быть, ответ будет зависеть от того, какая у вас проблема с использованием итератора? может быть использование

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)

но, честно говоря, я не вижу смысла в использовании таких подходов

t=0    
for _ in range(10):
    print t
    t = t+1

ВЫВОД:

0
1 
2 
3 
4 
5 
6 
7
8
9

Вместо ненужного счетчика теперь у вас есть ненужный список. Лучшее решение - использовать переменную, начинающуюся с «_», которая сообщает средствам проверки синтаксиса, что вы знаете, что не используете переменную.

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

Я в целом согласен с решениями, приведенными выше. А именно с:

1. Использование подчеркивания в for-loop (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 - количество повторений цикла. Цепочка объединяет два повторяющихся итератора, первый ограничен, а второй бесконечен. Помните, что это настоящие итераторы, поэтому они не требуют бесконечной памяти. Очевидно, что это намного медленнее, чем решение № 1 . Если она не написана как часть функции, она может потребовать очистки переменной times .

Мы повеселились со следующим, интересно поделиться так:

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

Если 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)

Если вы действительно хотите избежать ввода чего-либо с именем (либо итерационной переменной, как в OP, либо нежелательным списком, либо нежелательным генератором, возвращающим true требуемое количество времени), вы можете сделать это, если действительно хотите:

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

Уловка, которая используется, состоит в том, чтобы создать анонимный класс, type('', (), {})который приводит к классу с пустым именем, но обратите внимание, что он не вставлен в локальное или глобальное пространство имен (даже если было предоставлено непустое имя). Затем вы используете член этого класса в качестве переменной итерации, которая недоступна, поскольку класс, членом которого он является, недоступен.

#Return first n items of the iterable as a list
list(itertools.islice(iterable, n))

Взято с http://docs.python.org/2/library/itertools.html

Что о:

while range(some_number):
    #do something