Double itération dans la compréhension de liste

En Python, vous pouvez avoir plusieurs itérateurs dans une liste de compréhension, comme

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

pour certaines séquences appropriées a et b. Je connais la sémantique des boucles imbriquées des compréhensions de liste de Python.

Ma question est: un itérateur dans la compréhension peut-il se référer à l'autre? En d'autres termes: pourrais-je avoir quelque chose comme ceci:

[x for x in a for a in b]

où la valeur actuelle de la boucle extérieure est l'itérateur de l'intérieur?

Par exemple, si j'ai une liste imbriquée:

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

quelle serait l'expression de compréhension de liste pour atteindre ce résultat:

[1,2,3,4]

?? (Veuillez énumérer uniquement les réponses de compréhension, car c'est ce que je veux savoir).

Pour répondre à votre question avec votre propre suggestion:

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

Alors que vous avez demandé des réponses de compréhension de liste, permettez-moi également de souligner l'excellent itertools.chain ():

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

J'espère que cela aide quelqu'un d'autre car a,b,x,ycela n'a pas beaucoup de sens pour moi! Supposons que vous ayez un texte plein de phrases et que vous vouliez un tableau de mots.

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

J'aime penser à la compréhension de liste comme étirant du code horizontalement.

Essayez de le décomposer en:

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

Exemple:

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

Cela fonctionne également pour les générateurs

>>> 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?

Gee, je suppose que j'ai trouvé la réponse: je ne faisais pas assez attention à quelle boucle est intérieure et laquelle est extérieure. La compréhension de la liste doit être comme:

[x for b in a for x in b]

pour obtenir le résultat souhaité, et oui, une valeur actuelle peut être l'itérateur de la boucle suivante.

L'ordre des itérateurs peut sembler contre-intuitif.

Prends pour exemple: [str(x) for i in range(3) for x in foo(i)]

Décomposons-le:

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 a déjà ajouté une bonne réponse, mais je veux montrer ce qui se passe:

>>> 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]

Je suppose que Python analyse la compréhension de la liste de gauche à droite. Cela signifie que la première forboucle qui se produit sera exécutée en premier.

Le deuxième "problème" de ceci est que b"la fuite" de la compréhension de la liste. Après la première compréhension réussie de la liste b == [3, 4].

Si vous souhaitez conserver le tableau multidimensionnel, il faut imbriquer les supports du tableau. voir l'exemple ci-dessous où un est ajouté à chaque élément.

>>> 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]

Cette technique de mémoire m'aide beaucoup:

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

Et maintenant, vous pouvez penser à R eturn + O uter-loop comme le seul R ight O rder

Sachant ci-dessus, l'ordre dans la liste complet même pour 3 boucles semble simple:

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

car ce qui précède n'est qu'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

pour itérer une liste / structure imbriquée, la technique est la même: pour ala question:

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

pour un autre niveau imbriqué

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]

etc

Je pense que c'est plus facile à comprendre

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

result: [1, 2, 3, 4]

De plus, vous pouvez utiliser exactement la même variable pour le membre de la liste d'entrée actuellement accessible et pour l'élément à l'intérieur de ce membre. Cependant, cela pourrait même le rendre plus (liste) incompréhensible.

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

La première for x in inputest évaluée, conduisant à une liste de membres de l'entrée, puis, Python parcourt la deuxième partie for x in xpendant laquelle la valeur x est écrasée par l'élément actuel auquel il accède, puis la première xdéfinit ce que nous voulons retourner.

Cette fonction flatten_nlevel appelle récursivement la liste imbriquée1 pour la convertir à un niveau. Essayez ceci

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)

production:

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