Doble iteración en la comprensión de la lista

En Python puedes tener múltiples iteradores en una lista de comprensión, como

[(x,y) for x in a for y in b]

para algunas secuencias adecuadas a y b. Soy consciente de la semántica de bucle anidado de las comprensiones de listas de Python.

Mi pregunta es: ¿puede un iterador en la comprensión referirse al otro? En otras palabras: ¿podría tener algo como esto?

[x for x in a for a in b]

donde el valor actual del bucle externo es el iterador del interno?

Como ejemplo, si tengo una lista anidada:

a=[[1,2],[3,4]]

¿Cuál sería la expresión de comprensión de la lista para lograr este resultado?

[1,2,3,4]

?? (Por favor, solo enumere las respuestas de comprensión, ya que esto es lo que quiero averiguar).

Para responder a su pregunta con su propia sugerencia:

>>> [x for b in a for x in b] # Works fine

Si bien solicitó respuestas de comprensión de la lista, permítame señalar también los excelentes itertools.chain ():

>>> from itertools import chain
>>> list(chain.from_iterable(a))
>>> list(chain(*a)) # If you're using python < 2.6

¡Espero que esto ayude a alguien más ya a,b,x,yque no tiene mucho significado para mí! Supongamos que tiene un texto lleno de oraciones y desea una serie de palabras.

# Without list comprehension
list_of_words = []
for sentence in text:
    for word in sentence:
       list_of_words.append(word)
return list_of_words

Me gusta pensar en la comprensión de la lista como un código de estiramiento horizontal.

Intenta dividirlo en:

# List Comprehension 
[word for sentence in text for word in sentence]

Ejemplo:

>>> text = (("Hi", "Steve!"), ("What's", "up?"))
>>> [word for sentence in text for word in sentence]
['Hi', 'Steve!', "What's", 'up?']

Esto también funciona para generadores

>>> text = (("Hi", "Steve!"), ("What's", "up?"))
>>> gen = (word for sentence in text for word in sentence)
>>> for word in gen: print(word)
Hi
Steve!
What's
up?

Caramba, creo que encontré la respuesta: no me estaba preocupando lo suficiente sobre qué bucle es interno y cuál es externo. La comprensión de la lista debería ser como:

[x for b in a for x in b]

para obtener el resultado deseado, y sí, un valor actual puede ser el iterador para el siguiente ciclo.

El orden de los iteradores puede parecer contrario a la intuición.

Toma por ejemplo: [str(x) for i in range(3) for x in foo(i)]

Vamos a descomponerlo:

def foo(i):
    return i, i + 0.5

[str(x)
    for i in range(3)
        for x in foo(i)
]

# is same as
for i in range(3):
    for x in foo(i):
        yield str(x)

ThomasH ya ha agregado una buena respuesta, pero quiero mostrar lo que sucede:

>>> a = [[1, 2], [3, 4]]
>>> [x for x in b for b in a]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined

>>> [x for b in a for x in b]
[1, 2, 3, 4]
>>> [x for x in b for b in a]
[3, 3, 4, 4]

Supongo que Python analiza la comprensión de la lista de izquierda a derecha. Esto significa que el primer forbucle que ocurra se ejecutará primero.

El segundo "problema" de esto es que bse "filtra" de la comprensión de la lista. Después de la primera lista exitosa comprensión b == [3, 4].

Si desea mantener la matriz multidimensional, debe anidar los corchetes de la matriz. vea el ejemplo a continuación donde se agrega uno a cada elemento.

>>> a = [[1, 2], [3, 4]]

>>> [[col +1 for col in row] for row in a]
[[2, 3], [4, 5]]

>>> [col +1 for row in a for col in row]
[2, 3, 4, 5]

Esta técnica de memoria me ayuda mucho:

[ <RETURNED_VALUE> <OUTER_LOOP1> <INNER_LOOP2> <INNER_LOOP3> ... <OPTIONAL_IF> ]

Y ahora puedes pensar en R eturn + O uter -loop como el único R ight O rden

Sabiendo lo anterior, el orden en la lista completa incluso para 3 bucles parece fácil:

c=[111, 222, 333]
b=[11, 22, 33]
a=[1, 2, 3]

print(
  [
    (i, j, k)                            # <RETURNED_VALUE> 
    for i in a for j in b for k in c     # in order: loop1, loop2, loop3
    if i < 2 and j < 20 and k < 200      # <OPTIONAL_IF>
  ]
)
[(1, 11, 111)]

porque lo anterior es solo un:

for i in a:                         # outer loop1 GOES SECOND
  for j in b:                       # inner loop2 GOES THIRD
    for k in c:                     # inner loop3 GOES FOURTH
      if i < 2 and j < 20 and k < 200:
        print((i, j, k))            # returned value GOES FIRST

para iterar una lista / estructura anidada, la técnica es la misma: por ala pregunta:

a = [[1,2],[3,4]]
[i2    for i1 in a      for i2 in i1]
which return [1, 2, 3, 4]

uno para el otro nivel anidado

a = [[[1, 2], [3, 4]], [[5, 6], [7, 8, 9]], [[10]]]
[i3    for i1 in a      for i2 in i1     for i3 in i2]
which return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

y así

Siento que esto es más fácil de entender.

[row[i] for row in a for i in range(len(a))]

result: [1, 2, 3, 4]

Además, puede usar la misma variable para el miembro de la lista de entrada a la que se accede actualmente y para el elemento dentro de este miembro. Sin embargo, esto incluso podría hacerlo más (lista) incomprensible.

input = [[1, 2], [3, 4]]
[x for x in input for x in x]

Primero for x in inputse evalúa, lo que lleva a una lista de miembros de la entrada, luego, Python recorre la segunda parte for x in xdurante la cual el valor actual es sobrescrito por el elemento actual al que está accediendo, luego el primero xdefine lo que queremos devolver.

Esta función flatten_nlevel llama recursivamente a la lista1 anidada para que se convierta en un nivel. Probar esto

def flatten_nlevel(list1, flat_list):
    for sublist in list1:
        if isinstance(sublist, type(list)):        
            flatten_nlevel(sublist, flat_list)
        else:
            flat_list.append(sublist)

list1 = [1,[1,[2,3,[4,6]],4],5]

items = []
flatten_nlevel(list1,items)
print(items)

salida:

[1, 1, 2, 3, 4, 6, 4, 5]