Discussion :

[Arsene12]

Bonjour,

j'ai une liste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

maListe = ('FAUX', 'VRAI', 'FAUX', 'FAUX', 'FAUX', 'VRAI', 'FAUX',...)

et je voudrai la dupliquer de la façon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

L1 = maListe, L2 = maListe,..., Ln = maListe.

Pour ça je voudrai faire une boucle. Pourriez-vous me dire comment on procède, svp, car

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Str(L)+Str(x) = maListe

ne fonctionne pas.

Ça répond : can't assign to operator

Merci d'avance,
Cordialement,
Arsène

[wiztricks]

Salut,

Vous voulez créez dynamiquement les variables L1, L2, ..., Ln.
C'est possible mais c'est une mauvaise pratique donc je ne vais pas vous indiquer "comment" le faire mais plutôt vous suggérer (à la place) de créer une liste L avec L[0], L[1],... L[n] - ce qui revient au même sauf qu'on a besoin d'une seule variable L pour accéder aux différents éléments suivant leur index.
Et si ces éléments sont des listes, merci de revoir votre tuto préféré sur les listes de listes (car vous vous êtes déjà fait piégé par les détails de ce que çà peut être).

- W

[racine carrée]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
L=['FAUX', 'VRAI', 'FAUX', 'FAUX', 'FAUX', 'VRAI', 'FAUX']
liste1=L[:]
liste2=L[:]
liste3=L[:]
liste4=L[:]
liste5=L[:]

Impossible d'utiliser une boucle for car on ne peut pas inclure une variable (k ici) dans un nom:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for k in range(n):
  liste_k=L[:]

ne créerait pas des listes liste_1,liste_2,liste_3,...,liste_n, mais une seule liste dont le nom serait liste_k.
Il faut revenir à la solution proposée par wiztricks: une liste dans laquelle chaque élément est égal à la liste L de départ. (liste[k]=L dans une boucle for k in range(n))

Remarques:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
#le fait d'utiliser ce code:
liste=L[:]
#permet de bien créer une liste indépendante de L, que l'on peut ensuite modifier sans modifier L
 
#Si on écrit
liste=L
#on ne fait que créer une nouvelle référence vers L, sans créer une nouvelle liste, ce qui fait que si l'on modifie liste, on modifie L en même temps!

Attention une liste se fait avec des []; avec des () c'est un tuple, ce qui est différent (non modifiable une fois créé, par exemple, contrairement aux listes) !

[Arsene12]

Le problème ici, c'est que maListe contient un ensemble de listes (je ne l'avais pas précisé dans mon 1er message). Donc si je fais :

L[0] = maListe
L[1] = maListe
L[2] = maListe
L[3] = maListe

je crée une liste de listes de listes.

Pour récupérer un élément, il faudrait faire L[x][y][z]. Je ne sais pas si c'est possible.

[wiztricks]

Pour récupérer un élément, il faudrait faire L[x][y][z]. Je ne sais pas si c'est possible.

Et vous avez essayé?

- W

[Arsene12]

j'arrive pas à créer la liste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
E = [('B','C','E','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J')]
liste=[]
 
for k in range(5):
  liste[k]=E
  print (E)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
liste[k]=E
IndexError: list assignment index out of range

[wiztricks]

j'arrive pas à créer la liste :

Ajouter des objets à une liste initialement vide, se fait avec .append.
Revoir les chapitres qui parlent des listes dans votre tuto. préféré avant d'essayer n'importe quoi et venir ici dire "çà marche pas" n'est pas une option.

- W

[Arsene12]

Pardon pour cette faute. J'avais déjà utilisé la méthode append précédemment mais j'avais oublié. Ce coup-ci j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
E = [('B','C','E','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J'),('D','F','G'),('A','F'),('C','H'),('D','G'),('F'),('D','G'),('F'),('D','F','G'),('F'),('D','G'),('D','F','H'),('F'),('C','H'),('D','G'),('A','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J'),('A','G'),('D','F','H'),('A','F','J'),('C','H'),('A','G'),('D','F','H'),('F'),('D','F','H'),('F'),('D'),('B','D','F'),('B'),('J'),('H'),('J'),('G'),('A','D','F'),('A','F'),('D','G'),('F')]
liste=[]
 
for k in range(5):
  liste[k].append(E)

Ça me répond :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
liste[k].append(E)
IndexError: list index out of range

[wiztricks]

Ce coup-ci j'ai fait :

Programmer, c'est comprendre le sens des instructions qu'on écrit. Et pour comprendre, il faut avoir appris et s'être donné le temps d'ouvrir un tuto.

- W

[Arsene12]

Sur mon tuto préféré je suis allé sur cette page :

au paragraphe : Copier Une Liste

Je sais copier une liste :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for k in range(5):
  k=E[:]

Mais si je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
E = [('B','C','E','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J'),('D','F','G'),('A','F'),('C','H'),('D','G'),('F'),('D','G'),('F'),('D','F','G'),('F'),('D','G'),('D','F','H'),('F'),('C','H'),('D','G'),('A','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J'),('A','G'),('D','F','H'),('A','F','J'),('C','H'),('A','G'),('D','F','H'),('F'),('D','F','H'),('F'),('D'),('B','D','F'),('B'),('J'),('H'),('J'),('G'),('A','D','F'),('A','F'),('D','G'),('F')]
liste=[]
for k in range(5):
  liste[k]=E[:]

j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
liste[k]=E[:]
IndexError: list assignment index out of range

Y'a pas possibilité de faire str(F) + str(k) = E[:]

[disedorgue]

Au pire, tu passes par un dictionnaire, ce sera toujours plus propre que de passer par une construction dynamique de variable:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
E = [('B','C','E','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J'),('D','F','G'),('A','F'),('C','H'),('D','G'),('F'),('D','G'),('F'),('D','F','G'),('F'),('D','G'),('D','F','H'),('F'),('C','H'),('D','G'),('A','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J'),('A','G'),('D','F','H'),('A','F','J'),('C','H'),('A','G'),('D','F','H'),('F'),('D','F','H'),('F'),('D'),('B','D','F'),('B'),('J'),('H'),('J'),('G'),('A','D','F'),('A','F'),('D','G'),('F')]
dico={}
for k in range(5):
  dico[k]=E[:]

[wiztricks]

Vous n'êtes pas en train de copier une liste mais construire une nouvelle liste en lui ajoutant les éléments d'une autre liste.
Un tuto. c'est pas un ensemble de recettes de cuisine qu'on recopie au gré du vent.
Prenez un vrai tuto. comme le Swinnen.

- W

[Arsene12]

Merci beaucoup pour toutes ces suggestions. Je crois qu'utiliser un dictionnaire est la méthode qui me convient le mieux. Et je vais me mettre à lire le Swinnen pour approfondir mes connaissances.

[wiztricks]

Je crois qu'utiliser un dictionnaire est la méthode qui me convient le mieux.

C'est surtout parce que çà fonctionne à défaut d'apprendre à le le fonctionner avec des listes...

C'est pas si différent d'écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
liste = []
for k in range(5):
     liste.append(E[:])

ou:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
liste = [None,] * 5
for k in range(5):
     liste[k] = E[:]

Si vous n'avez pas pris le temps d'apprendre à jouer avec ces constructions simples comment espérez vous arriver à imaginer comment coder des programmes plus compliqués qui vont devoir les composer de différentes façons?
Rappelez vous votre apprentissage d'une langue étrangère ou même du français: vous n'avez certainement pas commencé avec des phrases utilisant l'imparfait du subjonctif mais vous vous êtes appliqué à des phrases ou la structure se limitait à sujet/verbe/complément.

- W

[disedorgue]

Sans le défendre dans sa paresse, ici, on est plus sur un problème d'intuition de comportement du langage:

La forme via un dictionnaire, est en mon sens plus intuitive que la première forme (via append) des listes et encore plus que le besoin de pré-créer une liste avec le nombre d'élément avant remplissage.

Après, je ne dis pas qu'il faut systématiquement faire comme ça, surtout que je ne suis pas du tout convaincu qu'il ait compris comment est créé en interne un dictionnaire et puisse mesurer les avantages/inconvénients par rapport à une liste.

[fred1599]

La forme via un dictionnaire, est en mon sens plus intuitive que la première forme (via append) des listes et encore plus que le besoin de pré-créer une liste avec le nombre d'élément avant remplissage.

Absolument pas, les listes fonctionnent par indice, je ne vois pas pourquoi passer par des clés de dictionnaire représentant un indice, c'est contre productif.

Ça peut être un choix qui fonctionne, mais un très mauvais quand on connaît un peu les structures du langage. Vous le dites vous même, "au pire"

Les listes comprehensions sont un autre moyen qui plaira peut-être mieux que append.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> E = [('B','C','E','F'),('B','F'),('B','D','F','J'),('C','H'),('G'),('A','D','F'),('F','J')]
>>> copies = [E[:] for _ in range(5)]
>>> copies
[[('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')], [('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')], [('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')], [('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')], [('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')]]
>>> copies[0]
[('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')]
>>> copies[1]
[('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')]
>>>
>>> copies[0][1] = ('E', 'F')
>>>
>>> copies[0]
[('B', 'C', 'E', 'F'), ('E', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')]
>>> copies[1]
[('B', 'C', 'E', 'F'), ('B', 'F'), ('B', 'D', 'F', 'J'), ('C', 'H'), 'G', ('A', 'D', 'F'), ('F', 'J')]

[disedorgue]

Je suis d'accord, d'ailleurs la phrase suivante va aussi dans le sens que c'est loin d'être le meilleur choix.

Ici, quand je dis que pour un débutant, c'est plus intuitif, je parle uniquement de comment on élabore la construction...