Dictionnaire de liste -> liste de dictionnaire

Version imprimable

Bonjour a tous,
votre le rapidité et l'efficacité avec laquelle vous avez répondu à ma derniere question me donne forcément envie de retenter l'experience :mouarf:

alors voila, je possède au départ un dictionnaire composé de liste:
Code:

1 2 3 4 5 6 7 dico={ "a":['nourriture','habits','voiture'], "b":[0,1,2,3,4], "c":['a'], "d":['&','$'], }
et je voudrai pouvoir récupérer une liste de tous les dictionnaires possible
Code:

1 2 3 4 5 6 7 8 [ {'a':nourriture,'b':0,'c':'a','d':'&'}, #élément 1 {'a':nourriture,'b':0,'c':'a','d':'$'}, #élément 2 {'a':nourriture,'b':1,'c':'a','d':'&'}, #élément 3 ... {'a':voiture,'b':4,'c':'a','d':$} #élément n ]
Evidemment, mon dictionnaire de départ n'est pas fixe, il peut avoir des élément ajouté,supprimé ou modifié

Existe-t-il une fonction qui me permette d'effectuer cela simplement?

Ou alors avez vous des pistes pour progammer ca de maniere élégante.
Pour l'instant j'imagine pouvoir m'en sortir avec une grand imbrication de boucle "for", mais je bloque un peut, nottemment a cause du nombre d'élément du dictionnaire que je ne connais pas à l'avance.

voila j'espere avoir été clair, à trés bientot!

Julien

salut,

Si j'ai bien compris tu voudrais ajouté un nombre quelquonque de dictionnaires à une liste, dictionnaires dont tu ne connais le nombre d'éléments au départ...

Python procure l'avantage que techniquement l'on a pas à se soucier de connaitre la taille d'une liste, d'un tuple, d'un dictionnaire, d'une chaine ou d'une classe. L'espace mémoire est auttomatiquement alloué, je ne saurais en dire plus sur le fonctionnement de cette allocation, et après tout tant qu'on reste dans python, on s'en moque :D.

par exemple admettons que l'on mette dans un dossier x fichiers, où chacun de ces fichiers possède par ligne deux mots (ou valeurs, ou expressions ou autre chose) séparé par un espace.

Admettons également que l'on veuille créer pour chacun de ces fichier un dictionnaires, et chacuns de ces dictionnaires soient dans une liste.

On peut procéder cette manière :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 import os dossier='./MyFolder' lst=[] for filename in os.listdir('./MyFolder'): dic={} f_in=open(dossier+'/'+filename,'r'): for line in f_in: key,val=line.strip().split() dic[key]=val lst.append(dic) f_in.close() #après si tu veux modifié ton premier dico lst[0]['blabla']=56
Mais cela t'oblige à connaitre l'emplacement du dico dans la liste
donc tu pourrais faire un dico de dico à la place d'une liste de dico, le concept de procédé serait le même

Ai-je bien compris ?

Bonjour,
Je ne suis pas sûr qu'il existe une méthode simple pour résoudre ton problème.
L'idée qu'il me vient en premier est de procéder en 2 étapes:
D'abord récupérer la liste de toutes les solutions possibles (sans s'occuper des clés)
Puis transformer toutes les listes en dictionnaires en réaffectant les clés.

Il y a certainement moyen de faire tout ça d'un coup mais je ne vois encore comment.
Voici une solution qui semble fonctionner:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #!/usr/bin/python # -*- coding: cp1252 -*- dico={ "a":['nourriture','habits','voiture'], "b":[0,1,2,3,4], "c":['a'], "d":['&','$'], } #récupère toutes les listes possibles listPossible = [[]] for value in dico.values(): listPossible = [x+[y] for x in listPossible for y in value] #change toutes les listes en dictionnaire keys = dico.keys() listDico = [dict(zip(keys, liste)) for liste in listPossible] print listDico
ça semble très lourd en temps de calcul si ton dictionnaire de départ prend de l'importance. Il y a moyen d'optimiser en utilisant des tuples à la place des listes, ou bien tout simplement en utilisant une liste dès le départ à la place de ton dictionnaire. Il existe alors la méthode itertools.product (depuis la version 2.6) qui te permetera de faire tout ça en 1 ligne.

01/07/2009, 10h15
ju_bicycle

Bonjour à tous.

@ N.Tox: Mon probleme n'était pas tout a fais ca. Ou alors je n'arrive pas a saisir toute les subtilités du code. :calim2:
En fait à partir de mon dictionnaire de liste (c'est a dire, que chaque élément a plusieurs valeur possible), je voudrai créer une liste de dictionnaire ou chaque élément a une seule valeur, mais avec toute les combinaison possible.

Enfin, il semblerai que la solution de Nyko77 fonctionne trés bien, alors je classe le probleme comme résolu. Par contre j'ai pas encore percé l'ensemble des mystere de son code. (Y'as que deux lignes, mais pour l'instant mon cervaux fume dessus!).

En tout cas, encore merci pour votre rapidité votre disponibilité et votre gentillesse!:D:ccool:

Julien

De quoi t'aider à mieux cerner le code :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#!/usr/bin/python
# -*- coding: cp1252 -*-
 
dico={
        "a":['nourriture','habits','voiture'],
        "b":[0,1,2,3,4],
        "c":['pour c'],
        "d":['&','$', '#'],
        }
 
#récupère toutes les listes possibles
listPossible = [[]]
for value in dico.values():
    listPossible = [x+[y] for x in listPossible for y in value]
 
# Regardons à quoi ressemble listPossible.
print '-'*8 + ' listPossible '
for i in range(len(listPossible)):
    print str(i) + ' : ' + str(listPossible[i])
# listPossible porte bien son nom : 
# il propose toutes le combinaisons possibles
# de valeurs sans les clés.
 
#change toutes les listes en dictionnaire
keys = dico.keys()
 
listDico = [dict(zip(keys, liste)) for liste in listPossible]
# A quoi sert zip  ?
print '-'*8 + ' zip(keys, liste)'
keys = ['a', 'c', 'b', 'd']
liste = ['nourriture', 'pour c', 0, '&']
print zip(keys, liste)
# A quoi sert dict(zip(keys, liste)) ?
print '-'*8 + ' dict(zip(keys, liste))'
print dict(zip(keys, liste))
# Pour finir qu'est-ce que ce [dict(zip(keys, liste)) for liste in listPossible] ?
print '-'*8 + ' List comprehension : [i**2 for i in [1,2,3,4,5]]'
print [i**2 for i in [1,2,3,4,5]]
 
print '-'*8 + ' listDico '
for i in range(len(listDico)):
    print str(i) + ' : ' + str(listDico[i])

Citation:
Envoyé par nyko77
Code:

1 2 3 4 #récupère toutes les listes possibles listPossible = [[]] for value in dico.values(): listPossible = [x+[y] for x in listPossible for y in value]
Alors là, moi je dis chapeau Nyko77 :hola:, il m'a fallu pas mal de temps avant de comprendre...
D'ailleurs il à fallu que je traduise en "format classique" pour y parvenir. Ju_bicycle, ceci devrait t'aider à comprendre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 >>> def test(d): listPossible=[[]] for value in d.values(): l=[] for y in value: for x in listPossible: print value, y, x l.append(x+[y]) print listPossible=l[:] print return listPossible >>> test(dico)
@Nyko77 : peut-être devrais-tu poster cette soluce sur ce thread

EDIT : grilled:lol:

01/07/2009, 12h25
ju_bicycle

Ouais merci N.Tox.
J'ai passé une petite demi heure dessus, mais j'ai finis par comprendre
C'est vraiment trés élégant (du moins au niveau de l'écriture). C'est impressionnant
01/07/2009, 12h29
rambc

En plus d'être élégante, l'utilisation des list comprehension est, il me semble, plus rapide en terme d'exécution.
01/07/2009, 12h43
N.tox

D'une manière générale, mais pas tout le temps non plus, il vaut mieux procéder à des tests, pour de longues opérations.

EDIT : Après quelque tests de comparaison, la première partie est extrêmement rapide, la deuxième (convertir la liste de possibilité en liste de dicos) par contre est bien plus lourde que la première. Le tout offre pourtant de très bonne performances.

Effectivement, en utilisant itertools.product on obtient quelque chose de plus performant, de pas énorme mais plus performant quand même, et aussi de plus lisible.