¿Infinito para bucles posibles en Python?

¿Es posible obtener un bucle infinito en bucle?

Mi conjetura es que puede haber un bucle infinito para Python. Me gustaría saber esto para futuras referencias.

El ejemplo por excelencia de un bucle infinito en Python es:

 while True: pass 

Para aplicar esto a un bucle for, use un generador (la forma más simple):

 def infinity(): while True: yield 

Esto se puede utilizar de la siguiente manera:

 for _ in infinity(): pass 

Sí, use un generador que siempre produzca otro número: Aquí hay un ejemplo

 def zero_to_infinity(): i = 0 while True: yield i i += 1 for x in zero_to_infinity(): print(x) 

También es posible lograr esto al mutar la lista en la que está iterando, por ejemplo:

 l = [1] for x in l: l.append(x + 1) print(x) 

Para responder a su pregunta utilizando un bucle for tal como se solicitó, esto se repetirá para siempre ya que 1 nunca será igual a 0:

 for _ in iter(int, 1): pass 

Si quisieras un bucle infinito usando números que se incrementaran según la primera respuesta, podrías usar itertools.count :

 from itertools import count for i in count(0): .... 

Usando itertools.count :

 import itertools for i in itertools.count(): pass 

En Python3, el rango () puede ir mucho más alto, aunque no al infinito:

 import sys for i in range(sys.maxsize**10): # you could go even higher if you really want but not infinity pass 

Otra forma puede ser

 def to_infinity(): index=0 while 1: yield index index += 1 for i in to_infinity(): pass 

Si bien ha habido muchas respuestas con buenos ejemplos de cómo se puede hacer un bucle infinito para, ninguno ha respondido por qué (aunque no se preguntó, pero aún así …)

Un bucle for en Python es azúcar sintáctica para manejar el objeto iterador de un iterable y sus métodos. Por ejemplo, este es su típico bucle for:

 for element in iterable: foo(element) 

Y esto es lo que está pasando detrás de las escenas:

 iterator = iterable.__iter__() try: while True: element = iterator.next() foo(element) except StopIteration: pass 

Un objeto iterador debe tener, como se puede ver, un método next que devuelve un elemento y avanza una vez (si puede, o si no genera una excepción StopIteration).

Por lo tanto, cada objeto iterable del cual el next método del iterador nunca genera dicha excepción tiene un bucle infinito para. Por ejemplo:

 class InfLoopIter(object): def __iter__(self): return self # an iterator object must always have this def next(self): return None class InfLoop(object): def __iter__(self): return InfLoopIter() for i in InfLoop(): print "Hello World!" # infinite loop yay! 

Puedes configurarlo para usar una lista. Y agregue un elemento a la lista cada vez que realice una iteración, para que nunca termine.

Ejemplo:

 list=[0] t=1 for i in list: list.append(i) #do your thing. #Example code. if t<=0: break print(t) t=t/10 

Este bucle exacto dado arriba, no llegará al infinito. Pero puedes editar la sentencia if para obtener un bucle infinito.

Sé que esto puede crear algunos problemas de memoria, pero es lo mejor que se me ocurre.