Discussion :

[ju_bicycle]

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

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

Code :

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

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 :

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

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

[N.tox]

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 .

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 :

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

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 ?

[nyko77]

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 :

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

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.

[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.
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!

Julien

[rambc]

De quoi t'aider à mieux cerner le code :

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

[N.tox]

Code :

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

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 , 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 :

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

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

[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