Dupliquer x fois une liste

Version imprimable

06/07/2018, 06h56
Arsene12

Dupliquer x fois une liste

Bonjour,

j'ai une liste :

Code:

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

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

Code:

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

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

Code:

Str(L)+Str(x) = maListe

ne fonctionne pas.

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

Merci d'avance,
Cordialement,
Arsène
06/07/2018, 08h11
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

Code:

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:

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:

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

08/07/2018, 13h38
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.
08/07/2018, 13h53
wiztricks

Citation:

Envoyé par Arsene12

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

j'arrive pas à créer la liste :

Code:

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:

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

08/07/2018, 15h27
wiztricks

Citation:

Envoyé par Arsene12

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

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:

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:

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

08/07/2018, 17h36
wiztricks

Citation:

Envoyé par Arsene12

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

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

au paragraphe : Copier Une Liste

Je sais copier une liste :

Code:

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

Mais si je fais :

Code:

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:

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

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

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

Code:

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

08/07/2018, 19h43
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
10/07/2018, 07h16
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.
10/07/2018, 10h03
wiztricks
Citation:

Envoyé par Arsene12

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:

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

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
10/07/2018, 16h45
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.

Citation:

Envoyé par disedorgue

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:

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

11/07/2018, 12h27
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...