Problème de boucle for (indentation)

Version imprimable

Bonjour,
Je voudrais créer une liste de dictionnaire de la forme:
compositeurs = [ f'comp' :'Mozart', 'a naiss' :1756, 'a mort' :1791g,f'comp' :'Beethoven', "a naiss' :1770, ...g, f'Haendel' : ... g, ... ]
Je pense que j'ai un problème de boucle for au niveau de la méthode append (ça traite seulement le dernier enregistrement fait par l'utilisateur).
Je vous remercie d'avance pour votre aide.

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
print("Bienvenu!!")
try:
    nc = int(input("Combien de compositeurs voulez vous saisir?: "))
    compositeurs = {}
    dic_nom_comp = {}
    dic_a_naiss = {}
    dic_a_mort = {}
    liste_comp = []
    for i in range(nc):
        lib_c = 'comp'
        nom_comp = input("Donner le nom du compositeur: ")
        dic_nom_comp[lib_c] = nom_comp
        lib_an = 'a_naiss'
        a_naiss = int(input("Donner l'année de naissance du compositeur: "))
        dic_a_naiss[lib_an] = a_naiss
        lib_am = 'a_mort'
        a_mort = int(input("Donner l'année de décès du compositeur: "))
        dic_a_mort[lib_am] = a_mort
        for j in (dic_nom_comp, dic_a_naiss, dic_a_mort):
            compositeurs.update(j)
        liste_comp.append(compositeurs)
    print(liste_comp)
except ValueError:
    print("Veuillez vérifier votre saisie!")

19/05/2021, 08h30
MPython Alaplancha

Bonjour,
Il te faut travailler sur la copie de ton dictionnaire pour éviter les effets de bords rencontrés.
Tu peux pour cela utiliser le module copy.

Code:

liste_comp.append(copy.deepcopy(compositeurs))
19/05/2021, 19h29
Sve@r
Bonjour

Citation:

Envoyé par Hominidé

Tu peux pour cela utiliser le module copy

Un peu lourd peut-être... => liste_comp.append(dict(compositeurs)) 8-)

Citation:

Envoyé par spoiledog

Je pense que j'ai un problème de boucle for au niveau de la méthode append (ça traite seulement le dernier enregistrement fait par l'utilisateur).

C'est un souci lié à la façon qu'à Python de copier un objet. Pour aller plus vite, il ne copie que la référence (si on était en C on parlerait d'adresse). Et donc quand tu ajoutes le dictionnaire "compositeur" tu n'ajoutes que sa référence à la liste (tu le verras mieux si tu rajoutes cette instruction print(tuple(id(x) for x in liste_comp)))

C'est un souci équivalent à ceci
Code:

1 2 3 4 5 6 7 >>> a=[1, 2, 3] >>> b=a >>> a.append("toto") >>> print(a) [1, 2, 3, 'toto'] >>> print(b) [1, 2, 3, 'toto']
Généralement cette façon de copier les objets suffit à la majorité des cas. Mais dans les rares moments où cela pose souci, alors pour l'éviter, comme dit Hominidé il te faut copier non pas le dictionnaire d'origine mais un double d'où le dict(compositeur) qui crée à la volée un second dictionnaire basé sur le premier.

Si on reprend l'exemple précédent, cela donnerait
Code:

1 2 3 4 5 6 7 >>> a=[1, 2, 3] >>> b=list(a) >>> a.append("toto") >>> print(a) [1, 2, 3, 'toto'] >>> print(b) [1, 2, 3]
Après cette façon de faire ne fonctionne que pour la copie simple (si tu as un dictionnaire qui contient lui-même des objets, cela ne dupliquera pas les objets internes mais seulement leurs références). Et donc pour les super rares cas (perso cela ne m'est arrivé qu'une seule fois) où tu dois copier un objet "en profondeur" tu as le module "copy" et sa fonction deepcopy() montrée par Hominidé qui fait le job.

Sinon concernant ton code, avec la position de ton try...except, une seule erreur de saisie annule tout et oblige à tout faire re-saisir. Ok pourquoi pas mais ça va vite gonfler les utilisateurs...
19/05/2021, 20h45
wiztricks
Salut,

Une autre façon de voir la chose est que si à chaque itération on ajoute l'objet compositeurs à la liste, cela suppose de créer aussi un nouvel objet à chaque itération:
Code:

1 2 3 4 5 ... for i in range(nc): compositeurs = {} lib_c = 'comp' ...
Et la question qui pourrait être posée est côté intérêt des dictionnaires intermédiaires dans cette opération: si à la fin de la saisie on recopie tout dans compositeurs, autant mettre à jour ce dictionnaire là dès le départ.

- W

Salut !

@spoiledog
Pourquoi ne pas faire un truc dans ce genre ?

Code:

1
2
3
4
5
6
7
8
9
10
11
print("Bienvenu!!")
try:
    liste_comp = []
    for i in range(int(input("Combien de compositeurs voulez vous saisir?: "))):
        nom_comp = input("Donner le nom du compositeur: ")
        a_naiss = int(input("Donner l'année de naissance du compositeur: "))
        a_mort = int(input("Donner l'année de décès du compositeur: "))
        liste_comp.append({'comp': nom_comp, 'a_naiss': a_naiss, 'a_mort': a_mort})
    print(liste_comp)
except ValueError:
    print("Veuillez vérifier votre saisie!")

@Sve@r
Plus besoin du module copy, si ?

Code:

1
2
3
4
5
6
7
>>> a= [1,2,3]
>>> b=a.copy()
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3]

27/05/2021, 21h40
Sve@r

Citation:

Envoyé par LeNarvalo

@Sve@r
Plus besoin du module copy, si ?

Ben sais pas. Comme moi j'avais dit dès le départ que ici ce n'était pas utile je ne vois pas trop pourquoi tu me le redemandes...

Citation:

Envoyé par Sve@r

Ben sais pas. Comme moi j'avais dit dès le départ que ici ce n'était pas utile je ne vois pas trop pourquoi tu me le redemandes...

Ma question était de savoir si le module copy était encore utile puisque les listes ont déjà une fonction copy, tu disais :

Citation:

Et donc pour les super rares cas (perso cela ne m'est arrivé qu'une seule fois) où tu dois copier un objet "en profondeur" tu as le module "copy" et sa fonction deepcopy() montrée par Hominidé qui fait le job.

Avant la fonction n'existait pas : Cours obsolète sur developpez.net
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 >>> for x in dir(list()): if not '_' in x: print('list.'+str(x)) list.append list.clear list.copy <= Nouveau depuis ? list.count list.extend list.index list.insert list.pop list.remove list.reverse list.sort
Bon ok j'ai tapé sur google, list.copy() n'est que superficiel... :pastaper:

Citation:

Envoyé par LeNarvalo

Bon ok j'ai tapé sur google, list.copy() n'est que superficiel... :pastaper:

Hé oui. Seule la fonction deepcopy() du module copy permet de copier une liste qui contiendrait elle-même d'autres objets complexes.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 >>> import copy >>> base=[[1, 2, 3], [4, 5, 6]] >>> cp1=list(base) >>> cp2=base.copy() >>> cp3=copy.copy(base) >>> cp4=copy.deepcopy(base) >>> base[0].append("toto") >>> print(base) [[1, 2, 3, 'toto'], [4, 5, 6]] >>> print(cp1) [[1, 2, 3, 'toto'], [4, 5, 6]] >>> print(cp2) [[1, 2, 3, 'toto'], [4, 5, 6]] >>> print(cp3) [[1, 2, 3, 'toto'], [4, 5, 6]] >>> print(cp4) [[1, 2, 3], [4, 5, 6]]
Effectivement depuis P3 les listes possèdent une méthode copy() (ainsi qu'une méthode clear() qui elle-non plus n'existait pas avant). Mais cela ne change rien, la méthode ne reste correcte que pour une dimension.

Accessoirement j'ai programmé un petit benchmark des différentes méthodes
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 25 #!/usr/bin/env python3 # coding: utf-8 import random import timeit from functools import partial # Les fonctions à tester fct={ "slice" : lambda l: l[:], "method" : lambda l: l.copy(), "list" : lambda l: list(l), } # La liste témoin temoin=list(range(10_000)) # Initialisation random random.seed() # Appel des fonctions dans un ordre aléatoire et affichage du chrono for (k, v) in random.sample(fct.items(), len(fct)): t=timeit.Timer(partial(v, temoin)).repeat(repeat=10) print("%s: min=%f, max=%f, avg=%f" % (k, min(t), max(t), sum(t)/len(t))) # for
Et le résultat
Code:

1 2 3 method: min=24.172999, max=24.594099, avg=24.412962 list: min=22.121441, max=22.620560, avg=22.374680 slice: min=24.029825, max=24.597135, avg=24.259765
Il semble donc que, pour une liste, passer par le créateur list() soit le plus rapide.