Fonctionnement des listes imbriquées

Version imprimable

29/12/2013, 17h21
Franck31300

Fonctionnement des listes imbriquées

Bonjour,

Je débute en Python et j'ai une petite incompréhension sur le fonctionnement de listes imbriquées. J'utilise du python 2.7.

J'ai essayé le code suivant qui fonctionne correctement:

Citation:

>>> main=[[3,4],[1,2,5],[],[0,3,4]]
>>> for p1,p2 in enumerate(main):
... print "P1/P2: ", p1,p2
... for val in p2:
... print "Value: ",val
...
P1/P2: 0 [3, 4]
Value: 3
Value: 4
P1/P2: 1 [1, 2, 5]
Value: 1
Value: 2
Value: 5
P1/P2: 2 []
P1/P2: 3 [0, 3, 4]
Value: 0
Value: 3
Value: 4

J'accède bien à tous les éléments de mes listes. Mais si j'essaye de vider ces listes, il en oublie en cours de route. Qu'est-ce que j'ai oublié ?

Citation:

>>> main=[[3,4],[1,2,5],[],[0,3,4]]
>>> for p1,p2 in enumerate(main):
... print "P1/P2: ", p1,p2
... for val in p2:
... print "Value: ",val
... main[p1].remove(val)
... print main
...
P1/P2: 0 [3, 4]
Value: 3
[[4], [1, 2, 5], [], [0, 3, 4]]
P1/P2: 1 [1, 2, 5]
Value: 1
[[4], [2, 5], [], [0, 3, 4]]
Value: 5
[[4], [2], [], [0, 3, 4]]
P1/P2: 2 []
P1/P2: 3 [0, 3, 4]
Value: 0
[[4], [2], [], [3, 4]]
Value: 4
[[4], [2], [], [3]]
>>>

Merci d'avance.
29/12/2013, 17h39
Invité

Bonjour,

Le problème ne vient pas de l'imbrication des listes.
Il ne faut jamais supprimer ou insérer un élément dans un tableau en cours de parcours. La boucle de parcours se base sur les indices, or en supprimant des éléments au fur et à mesure que tu parcours le tableau, tu altères les indices.

exemple :
Tu pars de ['a', 'b']. Tu as donc
indice 0 : 'a',
indice 1 : 'b'
Si tu parcours ton tableau en suppriment les éléments au fur et à mesure, les indices vont être faussés. A la première itération (indice 0, valeur 'a'), l'élément est supprimé. Donc 'b' se retrouve à l'indice 0... qui vient d'être traité et ne le sera donc plus.

Dans ton cas, par exemple [1,2,5], à la deuxième itération (qui traite donc l'indice 1), 2 est passée à l'indice 0 et 5 à l'indice 1. Donc c'est 5 qui est traité au lieu de 2 qui à pris l'indice qui venait d'être traité.

J'espère être clair.
29/12/2013, 18h04
Franck31300

Enerian,

Merci, c'est assez clair. Je comprends que les indices soient modifiés.
Mais comme j'utilise la fonction remove() qui utilise la valeur et non l'indice, ça me semble assez curieux qu'il ne s'y retrouve pas.

Merci quand même.

Pourquoi ne pas itérer une copie de la liste et travailler directement sur la liste ?

Exemple :

Code:

1
2
3
4
5
copieIterable = list(main) #On fait une copie de la liste et non de sa simple référence.
 
for p1, p2 in enumerate(copieIterable) :
    for value in p2 :
        main[p1].remove(p2) #On supprime les valeurs de la liste initiale.

Bonjour

Citation:

Envoyé par luluunix

Pourquoi ne pas itérer une copie de la liste et travailler directement sur la liste ?

Parce que, même sur l'exemple fourni par le PO, ça ne fonctionne pas !
Code:

1 2 3 4 5 6 7 8 9 10 >>> main=[[3,4],[1,2,5],[],[0,3,4]] >>> copieIterable = list(main) >>> >>> for p1, p2 in enumerate(copieIterable) : ... for value in p2 : ... main[p1].remove(p2) ... Traceback (most recent call last): File "<stdin>", line 3, in <module> ValueError: list.remove(x): x not in list
C'est plutôt "main[p1].remove(value)" qui aurait eu une petite chance de fonctionner. Mais même pas, et pour les mêmes raisons que le code original ne fonctionne pas :
Code:

1 2 3 4 5 6 7 8 9 >>> main = [[1,2,2]] >>> copieIterable = list(main) >>> for p1, p2 in enumerate(copieIterable) : ... for value in p2 : ... main[p1].remove(value) ... >>> >>> main [[2]]
Citation:

Envoyé par Franck31300

Mais comme j'utilise la fonction remove() qui utilise la valeur et non l'indice, ça me semble assez curieux qu'il ne s'y retrouve pas.

Relis les explications claires de Enerlan et tu verras "qu'attaquer" la liste avec des remove en croyant ne pas mettre la bazar dans les indices est vain !

La seule façon de vider une liste élément par élément, est de s'attaquer au dernier indice (plus grand) et de remonter la liste en sens inverse.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 >>> main=[[3,4],[1,2,5],[],[0,3,4]] >>> for liste in main: ... for i in range(len(liste)-1,-1,-1): ... del liste[i] ... >>> main [[], [], [], []] >>> >>> main=[[3,4],[1,2,5],[],[0,3,4]] >>> for liste in main: ... while liste: ... del liste[-1] ... >>> main [[], [], [], []] >>>
Mais tout ça n'est pas très pythonique. Pour vider (j'ai bien dit vider, et pas (ré-)affecter une nouvelle liste vide), il faut plutôt s'y prendre comme ça
Code:

1 2 3 4 5 6 7 8 >>> main=[[3,4],[1,2,5],[],[0,3,4]] >>> >>> for liste in main: ... del liste[:] ... >>> main [[], [], [], []] >>>

Citation:

Envoyé par luluunix

Pourquoi ne pas itérer une copie de la liste et travailler directement sur la liste ?

Merci pour la suggestion mais le résultat est le même à priori:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> main=[[3,4],[1,2,5],[],[0,3,4]]
>>> copieIterable = list(main)
>>> for p1, p2 in enumerate(copieIterable) :
...   print "P1/P2: ", p1,p2
...   for val in p2:
...     print "Value: ",val
...     main[p1].remove(val)
...     print main
... 
P1/P2:  0 [3, 4]
Value:  3
[[4], [1, 2, 5], [], [0, 3, 4]]
P1/P2:  1 [1, 2, 5]
Value:  1
[[4], [2, 5], [], [0, 3, 4]]
Value:  5
[[4], [2], [], [0, 3, 4]]
P1/P2:  2 []
P1/P2:  3 [0, 3, 4]
Value:  0
[[4], [2], [], [3, 4]]
Value:  4
[[4], [2], [], [3]]
>>>

Ton problème se trouve au niveau de la deuxième boucle, pas de la première. C'est dans la deuxième que tu supprime les éléments d'un tableau que tu parcours.
En faisant copieIterable = list(main), tu copies main mais les tableaux imbriqués dans main sont des références et donc sont conservés dans copieIterable.
Pour garder la solution de la copie, il faudrait plutôt faire
Code:

1 2 3 4 5 6 7 8 main=[[3,4],[1,2,5],[],[0,3,4]] for p1, p2 in enumerate(main) : print "P1/P2: ", p1,p2 copie = list(p2) for val in copie: # l'itération se fait sur la copie dont les indices ne sont pas touchés print "Value: ",val main[p1].remove(val) # la suppression se fait sur le tableau original print main
Mais bon, ce code n'a d'intérêt que pour comprendre l'origine de ton erreur.
Si le but est de vider toutes les listes, la solution de plxpy est bien plus élégantes et efficace.

La solution de plxpy, peut-être légèrement plus efficace à voir
Code:

1 2 3 4 5 6 >>> main=[[3,4],[1,2,5],[],[0,3,4]] >>> for liste in main: ... liste[:] = [] ... >>> main [[], [], [], []]

30/12/2013, 19h24
Franck31300

Merci pour ces explications.
Je comprends le problème des indices même si cela me semble pas très logique.

La fonction "remove" prend la valeur en paramètre en non l'indice. A aucun moment je n'ai voulu utiliser les indices justement à cause de ce problème. Il est dommage que la fonction remove s'en serve.
Ce qui veut dire que quelque part, python garde en mémoire l'indice que cette valeur avait dans la version précédente de la liste? Ca ne me semble pas correct.
Au moment où j’exécute le remove, la liste n'a que les éléments qui m'intéresse. De plus dans le cas où la sous liste à 3 éléments, la boucle est initialisé avec 3 éléments, elle devrait faire 3 itérations. Hors elle n'en fait que 2. Donc la boucle sait que l'élément n'existe plus mais pas la fonction remove ?

L'idée n'est pas de vider simplement la liste sinon effectivement j'aurais utilisé le "del". L'idée est d'avoir cette structure constituée par un programme et une autre partie du code prend un élément, le traite et le supprime de la liste.
Comme je débute, je testais une suppression avec boucle où j'aurais appelé le traitement de chacun des éléments, mais ça ne marche pas à l'évidence.

Citation:

Je comprends le problème des indices même si cela me semble pas très logique.

si tu ne comprends pas les petits schémas en dessous (je mis ça en code pour garder les espacements, mais la coloration syntaxique ...), tu ne peux rien bâtir de solide par la suite

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
départ
 
          +-----+-----+-----+-----+   
L c'est   | 'a' | 'b' | 'c' | 'd' |  
          +-----+-----+-----+-----+   
             0     1     2     3       <---- indices
 
L.remove('b')
 
          +-----+-----+-----+
L c'est   | 'a' | 'c' | 'd' |
          +-----+-----+-----+
             0     1     2       <---- indices
 
del L[1]
 
          +-----+-----+
L c'est   | 'a' | 'd' |
          +-----+-----+
             0     1       <---- indices