Discussion :

[Buck92]

Bonjour,

Je rencontre un problème assez embêtant depuis quelques jours :

J'ai deux dictionnaires sur lesquels j'aimerais effectuer des mises à jour périodiques de valeurs pour des clefs identiques l 'un par rapport l'autre.

Exemple : si j'ai un dico1 = {'haha' : {'hihi' : 'hoho'}} et un dico2 = {'haha' : {'huhu' : 'hehe'}}, j'aimerai pouvoir réaliser une "update" qui permettrait d'avoir un dico1 updaté à : dico1 = {'haha' : {{'hihi' : 'hoho'}, {'huhu' : 'hehe'}}}

Le problème de la fonction update est qu'elle écrase systématiquement la valeur pour une même clef, alors que je voudrais au contraire que les deux valeurs s'imbriquent.

Pour l'instant j'essaie de me débrouiller avec des boucles mais bon.

Quelqu'un connaitrait-il une bonne méthode/bibliothèque qui permet de faire ça plus simplement ? Merci par avance.

[kango]

bonjour,

c'est le bon moment pour sous-classer la méthode update des dictionnaires afin de pouvoir faire ce que tu veux

Code :

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

1
2
3
4
5
6
7
8
 
class MonDict(dic):
    def __init__(self,*args,**kwargs):
        dict.__init__(self,*args,**kwargs)
    def update(self,other):
        for key,item in other.iteritems():
            if key in self:
                dict.update(self[key],item)

c'est très certainement incomplet, mais c'est pour donner l'idée.

[airod]

utiliser des dico comme valeur alors qu'un tuple suffirait!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
a={'a':[('b','c'),('d','e')]}
 
b={'a':[('f','g')],'x':[('u','v')]}
 
for k in a:
    item=b.setdefault(k,[])
    a[k]=a[k]+item
    b.pop(k)
 
a.update(b)
print a

je ferais un truc de ce type.... maintenant si ta structure doit impérativement etre une imbrication de dico, dans des liste, alors il faut adapter.

[wiztricks]

Salut,

Précisez le sens que vous donnez à "s'imbrique"!

Le problème de la fonction update est qu'elle écrase systématiquement la valeur pour une même clef, alors que je voudrais au contraire que les deux valeurs s'imbriquent.

Sur le fond, n'oubliez pas que la "valeur" associée à la clé d'un dictionnaire peut être une référence vers un type 'complexe'.
Un tuple vous a déjà été suggéré!

Mais pensez aussi un autre dictionnaire, un objet, n'importe quoi...

Enfin pas n'importe quoi, juste "Type 'Complexe'"
Complexe dit que ce n'est pas un int, mais sa structure est suffisamment régulière pour être rangée dans une hiérarchie finie d'objets composés d'objets ou de types simples
En conception, "composite est son nom --- une arborescence de répertoires ca le fait aussi...

Plus compliqué que complexe sont les structures qui n'ont pas suffisamment de régularité pour être racontées, ce qui n'est pas si grave tant qu'on se réduit à transférer une représentation d'état sérialisée - i.e<; une chaine de caractères.

Ma réflexion essaie juste de faire des liens entre votre question (*): comment faire qu'un dictionnaire soit plus qu'un machin plat où le type des attributs sont des valeurs monovaluées et atomiques?

- W
(*) Je sais que ce n'est pas ce que vous avez dit
Mais n'est ce pas la question que vous avez posé (à l'insu de votre plein grè)??? Non! je ne développerais pas car, çà aboutit inexorablement dans des questions de transformations de schéma de "représentations", qui nous amène à une discussion sur le rôle de la monnaie... Le forum Python n'est pas fait pour çà!!!

[Buck92]

lol wiztricks, mes dictionnaires sont précisément ceux-là aux "valeurs plus compliquées que les structures 'complexes' " dont tu parles, en fait ce sont des dizaines de dictionnaires imbriqués les uns dans les autres, ce qui offre justement aucune régularité (en fait c'est totalement chaotique) et rend leur parcours très difficile.

Merci pour vos réponses, je vais sans doute suivre le conseil de kango et recréer ma propre méthode update.

[dividee]

Cela va dépendre de la sémantique associée, mais le parcours de dictionnaires imbriqués n'est pas particulièrement complexe avec une fonction récursive, sur ce modèle:

Code :

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

1
2
3
4
5
6
7
8
9
 
def parcours(d):
    for k, v in d.items();
        if isinstance(v, dict):
            r = parcours(v)
            # traitement r
        else:
            # traitement v et/ou k
    # return qqch

[miawaw]

Grâce au type 'set', j'ai une solution toute simple :

Code :

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

1
2
3
def update(a, b):
    for key in set(a.keys()) & set(b.keys()):# equivalent: set(a.keys()).intersection(set(b.keys()))
        a[key].extend(b[key])

Il faut, pour que ça fonctionne, que chaque 'item' du dictionnaire soit une liste, fût-ce d'un seul élément.
Exemple:

Code :

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

1
2
3
4
5
6
7
8
9
c={'a':[{'b':'c'},{'d':'e'}], 'x':[{'coucou':'beu'}]}
d={'a':[{'f':'g'}],'x':[{'u':'v'}]}
print 'avant:', c
update(c,d)
print 'apres:', c
 
# resultat:
avant: {'a': [{'b': 'c'}, {'d': 'e'}], 'x': [{'coucou': 'beu'}]}
apres: {'a': [{'b': 'c'}, {'d': 'e'}, {'f': 'g'}], 'x': [{'coucou': 'beu'}, {'u': 'v'}]}

[tyrtamos]

Bonjour,

Avant d'essayer d'y répondre, j'aimerais une clarification de la question, et surtout du but à atteindre.

En effet, ça, ça marche:

Code :

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

1
2
3
4
5
6
7
dico1 = {'haha' : {'hihi' : 'hoho'}}
 
print dico1['haha']
{'hihi': 'hoho'}
 
print dico1['haha']['hihi']
'hoho'

Mais ça, ça ne marche pas:

Code :

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

1
2
3
dico1 = {'haha' : {{'hihi' : 'hoho'}, {'huhu' : 'hehe'}}}
 
SyntaxError: invalid syntax

Le but est-il de placer les sous-dicos dans un tuple comme suit?

Code :

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

1
2
3
4
5
6
7
dico1 = {'haha' : ({'hihi' : 'hoho'}, {'huhu' : 'hehe'})}
 
print dico1['haha']
({'hihi': 'hoho'}, {'huhu': 'hehe'})
 
print dico1['haha'][1]['huhu']
'hehe'

???

Tyrtamos

[wiztricks]

salut,
J'ai du boulot en ce moment et je ne peux pas trop gratter sur cette question intéressante, mais:

Il faut, pour que ça fonctionne, que chaque 'item' du dictionnaire soit une liste, fût-ce d'un seul élément.

Si on veut généraliser la chose, il faut une classe X héritée d'un dict dont les valeurs sont une collection(*) de X ou un simple X.

(*)Une liste, un uplet, un dict sont des collections, mais si on veut une structure régulière, il faut que X soit une feuille ou un dict de X.

Dans les patrons de conception cela s'appelle un composite.

Après on veut faire des choses tordues comme, soient:
a = X
b = X
c = intersection (a, b)
ou
c = réunion de (a, b)

Ce qui pose une question d'adressage et de comparaisons. X est un "arbre", on a la représentation du composite mais comment identifier un élément?
Si c'est une hiérarchie de dict, on pense folders d'un système de fichiers et l'identité d'un élément pourrait être /a/b/c/.... ou a.b.c.

Code Python :

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

1
2
3
4
5
6
7
class Folder(dict):
    def __init__(self, **kwds):
        super(Folder, self).__init__(self, kwds)
        self.__dict__ = self
    def union(self, folder): pass
    def intersection (self, folder): pass
    ...

Partons de X=Folder, c'est un composite!
a = Folder(dict(b=Folder(), c=Folder)))
qui permet d'avoir accès aux éléments de 'a' sous la forme
a['b'] ou a.b
Les feuilles de la chose sont des types autres que Folder.
Exemple: a.b.c = 123 crée l'attribut 'c' dans le Folder 'a.b' et lui assigne l'entier 123

Bon faut que je retourne gratter

- W

[Buck92]

Tyrtamos effectivement erreur de ma part : les valeurs seraient forcément soit des dict soit des list.

Miawaw ta fonction ne marche qu'au premier niveau du dictionnaire mais l'idée initiale de l'utilisation des listes m'a finalement bien aidé. Dividee merci d'avoir mentionner la récursivité comme solution.

Mon code est le suivant (l'idée est que les deux dict vont être updatés mutuellement, j'ai pas trouvé mieux pour le moment) :

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
def parcours(d1, d2):
	for key in d2.keys() :#on met a jour d1 par rapport aux keys de d2 pour le bon parcours en zip() plus tard
		if key not in d1.keys() :
			d1[key] = d2.get(key)
	for key in d1.keys() :#on met a jour d2 par rapport aux keys de d1 pour le bon parcours en zip() plus tard
		if key not in d2.keys() :
			d2[key] = d1.get(key)
	for (k1, v1),(k2, v2) in zip(d1.items(), d2.items()) :#on parcourt d1 et d2 en parallele
		if v1 is not v2 :#difference de value : traitement
			if isinstance(v1, dict) & isinstance(v2, dict) :#si v1 et v2 sont differents en tant que dict, une recursivite modifiera ces valeurs en tant que clef (2eme ligne du code)
				parcours(v1, v2)
			else :# on a affaire a au moins une valeur de type different que dict (on ira pas plus loin du coup) : une liste va imbriquer les deux valeurs
				listDic = []
				listDic.append(v1)
				listDic.append(v2)
				d1[k1] = listDic
		else :# on parcourt le reste de l'arborescence.
			if isinstance(v1, dict) & isinstance(v2, dict) :
				parcours(v1, v2)			
	return d1
 
c={'a':{'b':{'hihi':'huhu'}}, 'x':{'coucou':'beu'}, 'y':{'coucou':'beu'}}
d={'a':{'b':{'hihi':['haha','hyhy']}},'c':{'u':'v'}}
par = parcours(c, d)
print '\nOn a maintenant c update:\n\n', par

Le résultat :

Code :

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

1
2
3
4
On a maintenant c update:
 
{'a': {'b': {'hihi': ['huhu', ['haha', 'hyhy']]}}, 'x': {'coucou': 'beu'}, 'c':
{'u': 'v'}, 'y': {'coucou': 'beu'}}

J'espère que j'ai pas oublié de "cas particulier" à traiter...

Si vous avez une remarque à faire n'hésitez pas, les débutants sont toujours heureux d'apprendre :p

[miawaw]

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
stop = True
def update(a ,b):
    #     Au premier appel de la fonction, les deux elements sont
    # des dictionnaires.
    # Si les dictionnaires n'ont plus de clés communes, ce sont des elements 
    # 'disjoints' des deux dicos parents. Il faut ajouter le dico b  
    # au dico parent du dico a.
    #     Aux appels suivants, on peut ne pas avoir deux dictionnaires. 
    # Soit un dic. avec un element 'normal', soit deux elements 'normaux'.
    # Dans ce cas on entre dans la partie 'except' à cause de l'exception
    # generee par l'instruction "set(a.keys()) & set(b.keys())" parce que
    # 'keys()' ne sera pas possible pour l'un des deux elements.
    try:
        intersec = set(a.keys()) & set(b.keys())
        ##for key in set(b.keys()) - set(a.keys()):
        ##    a[key] = b[key]
        if intersec: # les dicos on des cles identiques.
            for key in intersec:
                if update(a[key], b[key]):
                    a[key] = [a[key]]
                    a[key].extend([b[key]])
        else: # pas d'elements communs
            return stop
    except: # il a au moins un element qui n'est pas un dictionnaire:
        return stop

C'est donc une fonction recursive, et tout à l'air de bien fonctionner. Par contre les elements de d qui ne sont pas dans c ne sont pas ajoutés à c. Si on veut qu'ils se rajoutent à c, il suffit d'enlever les lignes precedees des double #. (deux lignes en tout)
Test de la fonction:

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
c={'a':{'b':{'hihi':'huhu'}}, 'x':{'coucou':'beu'}, 'y':{'coucou':'beu'}}
d={'a':{'b':{'hihi':['haha','hyhy']}},'c':{'u':'v'}}
print c
print d
print "-" * 80
update(c,d)
print c
 
## affichage dans la console :
{'a': {'b': {'hihi': 'huhu'}}, 'x': {'coucou': 'beu'}, 'y': {'coucou': 'beu'}}
{'a': {'b': {'hihi': ['haha', 'hyhy']}}, 'c': {'u': 'v'}}
--------------------------------------------------------------------------------
{'a': {'b': {'hihi': ['huhu', ['haha', 'hyhy']]}}, 'x': {'coucou': 'beu'}, 'y': {'coucou': 'beu'}}
 
## en supprimant les ##, on aurait:
{'a': {'b': {'hihi': ['huhu', ['haha', 'hyhy']]}}, 'x': {'coucou': 'beu'}, 'c': {'u': 'v'}, 'y': {'coucou': 'beu'}}

J'ai modifié un peu la fonction en

Code :

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

def update(a ,b, ajout=False):

pour avoir le choix. Version finale, sans commentaires:

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
stop = True
def update(a ,b, ajout=False):
    try:
        if ajout:
            for k in set(b.keys()) - set(a.keys()):
                a[k] = b[k]
        intersec = set(a.keys()) & set(b.keys())
        if intersec:
            for key in intersec:
                if update(a[key], b[key], ajout):
                    a[key] = [a[key]]
                    a[key].extend([b[key]])
        else:
            return stop
    except:
        return stop

[miawaw]

uhm que se passe-t-il si on ecrit

Code :

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

1
2
update(a,b)
update(a,b)

le dico a ne devrait pas être modifié lors du deuxieme appel, il faudrait, dans ma fonction, modifier la clause "except" en y faisant des tests du genre "if not b in a : a .append(b) # si a une liste" (un truc du genre).