loop - range from 1 to 10 python

¿Es posible implementar Python para bucle de rango sin una variable de iterador?

Question

¿Es posible seguir sin el i ?

for i in range(some_number):
    # do something

Si solo quiere hacer algo N cantidad de veces y no necesita el iterador.

Answer 1

¿Puede ser que la respuesta dependa de qué problema tienes con el uso del iterador? puede ser uso

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

o

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

loop(100, lambda a:a)

pero francamente no veo sentido en el uso de tales enfoques

Answer 2

Aquí hay una idea aleatoria que utiliza (¿abusos?) El modelo de datos ( enlace 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

Me pregunto si hay algo así en las bibliotecas estándar.

Answer 3

El modismo general para asignar un valor que no se usa es nombrarlo _ .

for _ in range(times):
    do_stuff()

Answer 4

En general, estoy de acuerdo con las soluciones dadas anteriormente. A saber con:

1. Usar guion bajo en -loop (2 y más líneas)
2. Definir un contador normal while (3 y más líneas)
3. Declarar una clase personalizada con implementación __nonzero__ (muchas más líneas)

Si se quiere definir un objeto como en el n . ° 3 , recomendaría implementar el protocolo para con palabra clave o aplicar contextlib .

Además propongo otra solución. Es un liner 3 y no es de suprema elegancia, pero usa el paquete itertools y, por lo tanto, podría ser de su interés.

from itertools import (chain, repeat)

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

En estos ejemplos 2 es el número de veces para iterar el ciclo. la cadena está envolviendo dos repetidores iterativos, el primero es limitado pero el segundo es infinito. Recuerde que estos son verdaderos objetos iteradores, por lo tanto, no requieren memoria infinita. Obviamente, esto es mucho más lento que la solución n . ° 1 . A menos que esté escrito como parte de una función, puede requerir una limpieza para la variable de tiempos .

Answer 5

En lugar de un contador innecesario, ahora tiene una lista innecesaria. La mejor solución es usar una variable que comience con "_", que le dice a los inspectores de sintaxis que usted sabe que no está usando la variable.

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

Answer 6

Fuera de mi cabeza, no.

Creo que lo mejor que puedes hacer es algo como esto:

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

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

Pero creo que puedes vivir con la variable extra i .

Aquí está la opción de usar la variable _ , que en realidad es solo otra variable.

for _ in range(n):
    do_something()

Tenga en cuenta que _ se le asigna el último resultado que se devolvió en una sesión de python interactiva:

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

Por esta razón, no lo usaría de esta manera. No estoy enterado de ningún modismo como lo menciona Ryan. Puede arruinar tu intérprete.

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

Y según la gramática de Python , es un nombre de variable aceptable:

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

Answer 7

Lo que todo el mundo sugiere que utilices _ no es que _ se use con frecuencia como acceso directo a una de las funciones gettext , por lo que si quieres que tu software esté disponible en más de un idioma, es mejor que evites usarlo. para otros fines

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

Answer 8

Nos hemos divertido un poco con lo siguiente, interesante para compartir:

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

Resultados:

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

Answer 9

Puede usar _11 (o cualquier número u otro identificador no válido) para evitar la colisión del nombre con gettext. Cada vez que use un subrayado + identificador no válido obtendrá un nombre ficticio que puede usarse en for loop.

Answer 10

Qué pasa:

while range(some_number):
    #do something

Answer 11

Si do_something es una función simple o puede envolverse en una, un simple map() puede do_something range(some_number) veces:

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

Si desea pasar argumentos a do_something , también puede encontrar las itertools repeatfunc recipe lee bien:

Para pasar los mismos argumentos:

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)

Para pasar diferentes argumentos:

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

deque(starmap(do_something, argses), 0)

Answer 12

Si realmente quieres evitar poner algo con un nombre (ya sea una variable de iteración como en el OP, o una lista no deseada o un generador no deseado que devuelve la cantidad de tiempo deseada), puedes hacerlo si realmente quieres:

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

El truco que se utiliza es crear un type('''', (), {}) clase anónimo type('''', (), {}) que da como resultado una clase con el nombre vacío, pero NB que no se inserta en el espacio de nombres local o global (incluso si un nombre no vacío fue suministrado). Luego usa un miembro de esa clase como variable de iteración que no se puede alcanzar porque la clase de la que es miembro es inalcanzable.

Answer 13

Usted puede estar buscando

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

esta es LA forma más rápida de iterar times veces en Python.

Answer 14

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

Tomado de http://docs.python.org/2/library/itertools.html

Answer 15

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

SALIDA:

0
1 
2 
3 
4 
5 
6 
7
8
9