Para bucles (principiante)

Question

Recientemente comencé a aprender Python, y el concepto de for bucles todavía es un poco confuso para mí. Entiendo que generalmente sigue el formato for x in y, donde y es solo una lista.

El para-cada bucle for (int n: someArray) convierte for n in someArray,

Y el bucle for for (i = 0; i < 9; i-=2) puede ser representado por for i in range(0, 9, -2)

Supongamos que en lugar de un incremento constante, quería i*=2, o incluso i*=i. ¿Es esto posible, o tendré que usar un ciclo while en su lugar?

Answer 1

Usted tendrá que usar list comprehensions para este

print [x**2 for x in xrange(10)] # X to the 2nd power. 

y

print [x**x for x in xrange(10)] # X to the Xth power. 

---

La sintaxis comprensión de lista es la siguiente:

[EXPRESSION for VARIABLE in ITERABLE if CONDITION] 

---

Bajo el capó, que actúa de manera similar a la map and filter function:

def f(VARIABLE): return EXPRESSION 
def c(VARIABLE): return CONDITION 

filter(c, map(f, ITERABLE)) 

ejemplo dado:

def square(x): return x**2 

print map(square, xrange(10)) 

y

def hypercube(x): return x**x 

print map(hypercube, xrange(10)) 

que se puede utilizar como método alternativo si no' me gusta la lista de comprensiones. También podría usar un bucle for, pero eso dejaría de ser un idiomático de Python ...

Answer 2

Como dices, un bucle for recorre los elementos de una lista. La lista puede contener lo que quieras, por lo que puedes construir una lista de antemano que contenga cada paso.

Un bucle for también puede iterar sobre "generator", que es una pequeña porción de código en lugar de una lista real. En Python, range() es en realidad un generador (en Python 2.x embargo, range() devolvió una lista, mientras que xrange() fue el generador).

Por ejemplo:

def doubler(x): 
    while True: 
     yield x 
     x *= 2 

for i in doubler(1): 
    print i 

El for bucle de arriba se imprimirá

1 
2 
4 
8 

y así sucesivamente, hasta que se pulsa Ctrl + C.

Answer 3

Puede utilizar un generator expression hacer esto de manera eficiente y con poco código de exceso:

for i in (2**x for x in range(10)): #In Python 2.x, use `xrange()`. 
    ... 

expresiones generadoras de trabajo al igual que define un generador manual (como en Greg Hewgill's answer), con una sintaxis similar a una lista por comprensión. Se evalúan con pereza, lo que significa que no generan una lista al inicio de la operación, lo que puede causar un rendimiento mucho mejor en iterables grandes.

Por lo tanto, este generador funciona esperando hasta que se le solicite un valor, luego solicite range(10) para un valor, duplicando ese valor y devolviéndolo al lazo for. Hace esto repetidamente hasta que el generador range() no da más valores.

Answer 4

Tenga en cuenta que la parte 'lista' de Python puede ser cualquier secuencia iterable.

Ejemplos:

Una cadena:

for c in 'abcdefg': 
    # deal with the string on a character by character basis... 

Un archivo:

with open('somefile','r') as f: 
    for line in f: 
     # deal with the file line by line 

Un diccionario:

d={1:'one',2:'two',3:'three'} 
for key, value in d.items(): 
    # deal with the key:value pairs from a dict 

Una rebanada de una lista:

l=range(100) 
for e in l[10:20:2]: 
    # ever other element between 10 and 20 in l 

, etc, etc, etc, etc

Por lo que realmente es mucho más profundo que 'sólo algunos lista'

Como otros han dicho, acaba de establecer la iterable a ser lo que usted quiere que sea para su preguntas ejemplo:

for e in (i*i for i in range(10)): 
    # the squares of the sequence 0-9... 

l=[1,5,10,15] 
for i in (i*2 for i in l): 
    # the list l as a sequence * 2... 

Answer 5

Sólo por una alternativa, ¿qué hay de la generalización de la operación iterate/Valor mínimo de una función lambda para que pueda hacer algo como esto:

for i in seq(1, 9, lambda x: x*2): 
    print i 
... 
1 
2 
4 
8 

Dónde seq se define a continuación:

#!/bin/python 
from timeit import timeit 

def seq(a, b, f): 
    x = a; 
    while x < b: 
     yield x 
     x = f(x) 

def testSeq(): 
    l = tuple(seq(1, 100000000, lambda x: x*2)) 
    #print l 

def testGen(): 
    l = tuple((2**x for x in range(27))) 
    #print l 

testSeq(); 
testGen(); 

print "seq", timeit('testSeq()', 'from __main__ import testSeq', number = 1000000) 
print "gen", timeit('testGen()', 'from __main__ import testGen', number = 1000000) 

La diferencia en el rendimiento no es mucho:

seq 7.98655080795 
gen 6.19856786728 

[EDIT]

Para apoyar iteración inversa y con un argumento predeterminado ...

def seq(a, b, f = None): 
    x = a; 
    if b > a: 
     if f == None: 
      f = lambda x: x+1 
     while x < b: 
      yield x 
      x = f(x) 
    else: 
     if f == None: 
      f = lambda x: x-1 
     while x > b: 
      yield x 
      x = f(x) 

for i in seq(8, 0, lambda x: x/2): 
    print i 

Nota: Esto comporta de manera diferente a range/xrange en el que la dirección del ensayo </> es elegido por el signo iterador, en lugar de la diferencia entre los valores inicial y final.