J'ai deux dictionnaires, mais pour simplifier, je prendrai ces deux:

>>> x = dict(a=1, b=2)
>>> y = dict(a=2, b=2)

Maintenant, je veux comparer si chaque key, valuepaire xa la même valeur correspondante y. J'ai donc écrit ceci:

>>> for x_values, y_values in zip(x.iteritems(), y.iteritems()):
        if x_values == y_values:
            print 'Ok', x_values, y_values
        else:
            print 'Not', x_values, y_values

Et cela fonctionne car a tupleest retourné puis comparé pour l'égalité.

Mes questions:

Est-ce correct? Existe-t-il une meilleure façon de procéder? Mieux vaut pas en vitesse, je parle d'élégance du code.

MISE À JOUR: J'ai oublié de mentionner que je dois vérifier combien de key, valuepaires sont égales.

Si vous voulez savoir combien de valeurs correspondent dans les deux dictionnaires, vous auriez dû le dire :)

Peut-être quelque chose comme ça:

shared_items = {k: x[k] for k in x if k in y and x[k] == y[k]}
print len(shared_items)

Ce que vous voulez faire, c'est simplement x==y

Ce que vous faites n'est pas une bonne idée, car les éléments d'un dictionnaire ne sont pas censés avoir d'ordre. Vous pourriez comparer [('a',1),('b',1)]avec [('b',1), ('a',1)](mêmes dictionnaires, ordre différent).

Par exemple, voyez ceci:

>>> x = dict(a=2, b=2,c=3, d=4)
>>> x
{'a': 2, 'c': 3, 'b': 2, 'd': 4}
>>> y = dict(b=2,c=3, d=4)
>>> y
{'c': 3, 'b': 2, 'd': 4}
>>> zip(x.iteritems(), y.iteritems())
[(('a', 2), ('c', 3)), (('c', 3), ('b', 2)), (('b', 2), ('d', 4))]

La différence n'est qu'un élément, mais votre algorithme verra que tous les éléments sont différents

def dict_compare(d1, d2):
    d1_keys = set(d1.keys())
    d2_keys = set(d2.keys())
    shared_keys = d1_keys.intersection(d2_keys)
    added = d1_keys - d2_keys
    removed = d2_keys - d1_keys
    modified = {o : (d1[o], d2[o]) for o in shared_keys if d1[o] != d2[o]}
    same = set(o for o in shared_keys if d1[o] == d2[o])
    return added, removed, modified, same

x = dict(a=1, b=2)
y = dict(a=2, b=2)
added, removed, modified, same = dict_compare(x, y)

dic1 == dic2

Depuis les documents python :

Pour illustrer, les exemples suivants renvoient tous un dictionnaire égal à {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

La fourniture d'arguments de mots clés comme dans le premier exemple ne fonctionne que pour les clés qui sont des identificateurs Python valides. Sinon, toutes les clés valides peuvent être utilisées.

Valable pour py2et py3.

Je suis nouveau sur python mais j'ai fini par faire quelque chose de similaire à @mouad

unmatched_item = set(dict_1.items()) ^ set(dict_2.items())
len(unmatched_item) # should be 0

L'opérateur XOR ( ^) doit éliminer tous les éléments du dict lorsqu'ils sont identiques dans les deux dict.

Puisqu'il semble que personne n'a mentionné deepdiff , je vais l'ajouter ici pour être complet. Je trouve cela très pratique pour obtenir des objets différents (imbriqués) en général:

Installation

pip install deepdiff

Exemple de code

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    }
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff(dict_1, dict_2)
print(json.dumps(diff, indent=4))

Production

{
    "values_changed": {
        "root['a']": {
            "new_value": 2,
            "old_value": 1
        },
        "root['nested']['b']": {
            "new_value": 2,
            "old_value": 1
        }
    }
}

Remarque sur l'impression du résultat pour inspection: le code ci-dessus fonctionne si les deux dict ont les mêmes clés d'attribut (avec éventuellement des valeurs d'attribut différentes comme dans l'exemple). Cependant, si un "extra"attribut est présent est l'un des dict, json.dumps()échoue avec

TypeError: Object of type PrettyOrderedSet is not JSON serializable

Solution: utilisez diff.to_json()et json.loads()/ json.dumps()pour joliment imprimer:

import deepdiff
import json

dict_1 = {
    "a": 1,
    "nested": {
        "b": 1,
    },
    "extra": 3
}

dict_2 = {
    "a": 2,
    "nested": {
        "b": 2,
    }
}

diff = deepdiff.DeepDiff(dict_1, dict_2)
print(json.dumps(json.loads(diff.to_json()), indent=4))  

Production:

{
    "dictionary_item_removed": [
        "root['extra']"
    ],
    "values_changed": {
        "root['a']": {
            "new_value": 2,
            "old_value": 1
        },
        "root['nested']['b']": {
            "new_value": 2,
            "old_value": 1
        }
    }
}

Alternative: utilisation pprint, entraîne une mise en forme différente:

import pprint

# same code as above

pprint.pprint(diff, indent=4)

Production:

{   'dictionary_item_removed': [root['extra']],
    'values_changed': {   "root['a']": {   'new_value': 2,
                                           'old_value': 1},
                          "root['nested']['b']": {   'new_value': 2,
                                                     'old_value': 1}}}

Utilisez simplement:

assert cmp(dict1, dict2) == 0

La réponse de @mouad est intéressante si vous supposez que les deux dictionnaires contiennent uniquement des valeurs simples. Cependant, si vous avez des dictionnaires qui contiennent des dictionnaires, vous obtiendrez une exception car les dictionnaires ne sont pas hachables.

Du haut de ma tête, quelque chose comme ça pourrait fonctionner:

def compare_dictionaries(dict1, dict2):
     if dict1 is None or dict2 is None:
        print('Nones')
        return False

     if (not isinstance(dict1, dict)) or (not isinstance(dict2, dict)):
        print('Not dict')
        return False

     shared_keys = set(dict1.keys()) & set(dict2.keys())

     if not ( len(shared_keys) == len(dict1.keys()) and len(shared_keys) == len(dict2.keys())):
        print('Not all keys are shared')
        return False


     dicts_are_equal = True
     for key in dict1.keys():
         if isinstance(dict1[key], dict) or isinstance(dict2[key], dict):
             dicts_are_equal = dicts_are_equal and compare_dictionaries(dict1[key], dict2[key])
         else:
             dicts_are_equal = dicts_are_equal and all(atleast_1d(dict1[key] == dict2[key]))

     return dicts_are_equal

Encore une autre possibilité, jusqu'à la dernière note de l'OP, est de comparer les hachages ( SHAou MD) des dicts sous JSON. La façon dont les hachages sont construits garantit que s'ils sont égaux, les chaînes source sont également égales. C'est très rapide et mathématiquement valable.

import json
import hashlib

def hash_dict(d):
    return hashlib.sha1(json.dumps(d, sort_keys=True)).hexdigest()

x = dict(a=1, b=2)
y = dict(a=2, b=2)
z = dict(a=1, b=2)

print(hash_dict(x) == hash_dict(y))
print(hash_dict(x) == hash_dict(z))

La fonction est fine IMO, claire et intuitive. Mais juste pour vous donner une (autre) réponse, voici mon tour:

def compare_dict(dict1, dict2):
    for x1 in dict1.keys():
        z = dict1.get(x1) == dict2.get(x1)
        if not z:
            print('key', x1)
            print('value A', dict1.get(x1), '\nvalue B', dict2.get(x1))
            print('-----\n')

Peut être utile pour vous ou pour quelqu'un d'autre ..

ÉDITER:

J'ai créé une version récursive de celle ci-dessus .. Je n'ai pas vu cela dans les autres réponses

def compare_dict(a, b):
    # Compared two dictionaries..
    # Posts things that are not equal..
    res_compare = []
    for k in set(list(a.keys()) + list(b.keys())):
        if isinstance(a[k], dict):
            z0 = compare_dict(a[k], b[k])
        else:
            z0 = a[k] == b[k]

        z0_bool = np.all(z0)
        res_compare.append(z0_bool)
        if not z0_bool:
            print(k, a[k], b[k])
    return np.all(res_compare)

Pour tester si deux dict sont égaux en clés et en valeurs:

def dicts_equal(d1,d2):
    """ return True if all keys and values are the same """
    return all(k in d2 and d1[k] == d2[k]
               for k in d1) \
        and all(k in d1 and d1[k] == d2[k]
               for k in d2)

Si vous souhaitez renvoyer les valeurs qui diffèrent, écrivez-le différemment:

def dict1_minus_d2(d1, d2):
    """ return the subset of d1 where the keys don't exist in d2 or
        the values in d2 are different, as a dict """
    return {k,v for k,v in d1.items() if k in d2 and v == d2[k]}

Il faudrait l'appeler deux fois, c'est-à-dire

dict1_minus_d2(d1,d2).extend(dict1_minus_d2(d2,d1))

Code

def equal(a, b):
    type_a = type(a)
    type_b = type(b)
    
    if type_a != type_b:
        return False
    
    if isinstance(a, dict):
        if len(a) != len(b):
            return False
        for key in a:
            if key not in b:
                return False
            if not equal(a[key], b[key]):
                return False
        return True

    elif isinstance(a, list):
        if len(a) != len(b):
            return False
        while len(a):
            x = a.pop()
            index = indexof(x, b)
            if index == -1:
                return False
            del b[index]
        return True
        
    else:
        return a == b

def indexof(x, a):
    for i in range(len(a)):
        if equal(x, a[i]):
            return i
    return -1

Tester

>>> a = {
    'number': 1,
    'list': ['one', 'two']
}
>>> b = {
    'list': ['two', 'one'],
    'number': 1
}
>>> equal(a, b)
True

Une simple comparaison avec == devrait suffire de nos jours (python 3.8). Même lorsque vous comparez les mêmes dictés dans un ordre différent (dernier exemple). La meilleure chose est que vous n'avez pas besoin d'un package tiers pour accomplir cela.

a = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
b = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}

c = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}
d = {'one': 'dog', 'two': 'cat', 'three': 'mouse', 'four': 'fish'}

e = {'one': 'cat', 'two': 'dog', 'three': 'mouse'}
f = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}

g = {'two': 'cat', 'one': 'dog', 'three': 'mouse'}
h = {'one': 'dog', 'two': 'cat', 'three': 'mouse'}


print(a == b) # True
print(c == d) # False
print(e == f) # False
print(g == h) # True

Être en retard dans ma réponse est mieux que jamais!

Comparer Not_Equal est plus efficace que comparer Equal. En tant que tels, deux dicts ne sont pas égaux si aucune valeur clé dans un dict n'est trouvée dans l'autre dict. Le code ci-dessous prend en compte que vous comparez peut-être dict par défaut et utilise donc get au lieu de getitem [].

Utiliser une sorte de valeur aléatoire par défaut dans l'appel get égale à la clé récupérée - juste au cas où les dicts ont une valeur None comme valeur dans un dict et que cette clé n'existe pas dans l'autre. De plus, la condition get! = Est vérifiée avant la condition non en état d'efficacité, car vous effectuez la vérification des clés et des valeurs des deux côtés en même temps.

def Dicts_Not_Equal(first,second):
    """ return True if both do not have same length or if any keys and values are not the same """
    if len(first) == len(second): 
        for k in first:
            if first.get(k) != second.get(k,k) or k not in second: return (True)
        for k in second:         
            if first.get(k,k) != second.get(k) or k not in first: return (True)
        return (False)   
    return (True)

J'utilise cette solution qui fonctionne parfaitement pour moi en Python 3

import logging
log = logging.getLogger(__name__)

...

    def deep_compare(self,left, right, level=0):
        if type(left) != type(right):
            log.info("Exit 1 - Different types")
            return False

        elif type(left) is dict:
            # Dict comparison
            for key in left:
                if key not in right:
                    log.info("Exit 2 - missing {} in right".format(key))
                    return False
                else:
                    if not deep_compare(left[str(key)], right[str(key)], level +1 ):
                        log.info("Exit 3 - different children")
                        return False
            return True
        elif type(left) is list:
            # List comparison
            for key in left:
                if key not in right:
                    log.info("Exit 4 - missing {} in right".format(key))
                    return False
                else:
                    if not deep_compare(left[left.index(key)], right[right.index(key)], level +1 ):
                        log.info("Exit 5 - different children")
                        return False
            return True
        else:
            # Other comparison
            return left == right

        return False

Il compare dict, list et tout autre type qui implémente l'opérateur "==" par lui-même. Si vous avez besoin de comparer autre chose, vous devez ajouter une nouvelle branche dans l'arborescence "if".

J'espère que cela pourra aider.

pour python3:

data_set_a = dict_a.items()
data_set_b = dict_b.items()

difference_set = data_set_a ^ data_set_b

>>> hash_1
{'a': 'foo', 'b': 'bar'}
>>> hash_2
{'a': 'foo', 'b': 'bar'}
>>> set_1 = set (hash_1.iteritems())
>>> set_1
set([('a', 'foo'), ('b', 'bar')])
>>> set_2 = set (hash_2.iteritems())
>>> set_2
set([('a', 'foo'), ('b', 'bar')])
>>> len (set_1.difference(set_2))
0
>>> if (len(set_1.difference(set_2)) | len(set_2.difference(set_1))) == False:
...    print "The two hashes match."
...
The two hashes match.
>>> hash_2['c'] = 'baz'
>>> hash_2
{'a': 'foo', 'c': 'baz', 'b': 'bar'}
>>> if (len(set_1.difference(set_2)) | len(set_2.difference(set_1))) == False:
...     print "The two hashes match."
...
>>>
>>> hash_2.pop('c')
'baz'

Voici une autre option:

>>> id(hash_1)
140640738806240
>>> id(hash_2)
140640738994848

Donc, comme vous le voyez, les deux identifiants sont différents. Mais les opérateurs de comparaison riches semblent faire l'affaire:

>>> hash_1 == hash_2
True
>>>
>>> hash_2
{'a': 'foo', 'b': 'bar'}
>>> set_2 = set (hash_2.iteritems())
>>> if (len(set_1.difference(set_2)) | len(set_2.difference(set_1))) == False:
...     print "The two hashes match."
...
The two hashes match.
>>>

Dans PyUnit, il existe une méthode qui compare magnifiquement les dictionnaires. Je l'ai testé en utilisant les deux dictionnaires suivants, et il fait exactement ce que vous recherchez.

d1 = {1: "value1",
      2: [{"subKey1":"subValue1",
           "subKey2":"subValue2"}]}
d2 = {1: "value1",
      2: [{"subKey2":"subValue2",
           "subKey1": "subValue1"}]
      }


def assertDictEqual(self, d1, d2, msg=None):
        self.assertIsInstance(d1, dict, 'First argument is not a dictionary')
        self.assertIsInstance(d2, dict, 'Second argument is not a dictionary')

        if d1 != d2:
            standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True))
            diff = ('\n' + '\n'.join(difflib.ndiff(
                           pprint.pformat(d1).splitlines(),
                           pprint.pformat(d2).splitlines())))
            standardMsg = self._truncateMessage(standardMsg, diff)
            self.fail(self._formatMessage(msg, standardMsg))

Je ne recommande pas d'importer unittestdans votre code de production. Ma pensée est que la source dans PyUnit pourrait être ré-outillée pour fonctionner en production. Il utilise pprintqui "joliment imprime" les dictionnaires. Il semble assez facile d'adapter ce code pour qu'il soit "prêt pour la production".

voir les objets de vue du dictionnaire: https://docs.python.org/2/library/stdtypes.html#dict

De cette façon, vous pouvez soustraire dictView2 de dictView1 et il retournera un ensemble de paires clé / valeur qui sont différentes dans dictView2:

original = {'one':1,'two':2,'ACTION':'ADD'}
originalView=original.viewitems()
updatedDict = {'one':1,'two':2,'ACTION':'REPLACE'}
updatedDictView=updatedDict.viewitems()
delta=original | updatedDict
print delta
>>set([('ACTION', 'REPLACE')])

Vous pouvez intersecter, réunir, différencier (voir ci-dessus), différence symétrique ces objets de vue de dictionnaire.
Mieux? Plus rapide? - pas sûr, mais faisant partie de la bibliothèque standard - ce qui en fait un gros plus pour la portabilité

Le code ci-dessous vous aidera à comparer la liste des dict en python

def compate_generic_types(object1, object2):
    if isinstance(object1, str) and isinstance(object2, str):
        return object1 == object2
    elif isinstance(object1, unicode) and isinstance(object2, unicode):
        return object1 == object2
    elif isinstance(object1, bool) and isinstance(object2, bool):
        return object1 == object2
    elif isinstance(object1, int) and isinstance(object2, int):
        return object1 == object2
    elif isinstance(object1, float) and isinstance(object2, float):
        return object1 == object2
    elif isinstance(object1, float) and isinstance(object2, int):
        return object1 == float(object2)
    elif isinstance(object1, int) and isinstance(object2, float):
        return float(object1) == object2

    return True

def deep_list_compare(object1, object2):
    retval = True
    count = len(object1)
    object1 = sorted(object1)
    object2 = sorted(object2)
    for x in range(count):
        if isinstance(object1[x], dict) and isinstance(object2[x], dict):
            retval = deep_dict_compare(object1[x], object2[x])
            if retval is False:
                print "Unable to match [{0}] element in list".format(x)
                return False
        elif isinstance(object1[x], list) and isinstance(object2[x], list):
            retval = deep_list_compare(object1[x], object2[x])
            if retval is False:
                print "Unable to match [{0}] element in list".format(x)
                return False
        else:
            retval = compate_generic_types(object1[x], object2[x])
            if retval is False:
                print "Unable to match [{0}] element in list".format(x)
                return False

    return retval

def deep_dict_compare(object1, object2):
    retval = True

    if len(object1) != len(object2):
        return False

    for k in object1.iterkeys():
        obj1 = object1[k]
        obj2 = object2[k]
        if isinstance(obj1, list) and isinstance(obj2, list):
            retval = deep_list_compare(obj1, obj2)
            if retval is False:
                print "Unable to match [{0}]".format(k)
                return False

        elif isinstance(obj1, dict) and isinstance(obj2, dict):
            retval = deep_dict_compare(obj1, obj2)
            if retval is False:
                print "Unable to match [{0}]".format(k)
                return False
        else:
            retval = compate_generic_types(obj1, obj2)
            if retval is False:
                print "Unable to match [{0}]".format(k)
                return False

    return retval

>>> x = {'a':1,'b':2,'c':3}
>>> x
{'a': 1, 'b': 2, 'c': 3}

>>> y = {'a':2,'b':4,'c':3}
>>> y
{'a': 2, 'b': 4, 'c': 3}

METHOD 1:

>>> common_item = x.items()&y.items() #using union,x.item() 
>>> common_item
{('c', 3)}

METHOD 2:

 >>> for i in x.items():
        if i in y.items():
           print('true')
        else:
           print('false')


false
false
true

En Python 3.6, cela peut être fait comme: -

if (len(dict_1)==len(dict_2): 
  for i in dict_1.items():
        ret=bool(i in dict_2.items())

La variable ret sera vraie si tous les éléments de dict_1 sont présents dans dict_2

Voici ma réponse, utilisez une méthode récursive:

def dict_equals(da, db):
    if not isinstance(da, dict) or not isinstance(db, dict):
        return False
    if len(da) != len(db):
        return False
    for da_key in da:
        if da_key not in db:
            return False
        if not isinstance(db[da_key], type(da[da_key])):
            return False
        if isinstance(da[da_key], dict):
            res = dict_equals(da[da_key], db[da_key])
            if res is False:
                return False
        elif da[da_key] != db[da_key]:
            return False
    return True

a = {1:{2:3, 'name': 'cc', "dd": {3:4, 21:"nm"}}}
b = {1:{2:3, 'name': 'cc', "dd": {3:4, 21:"nm"}}}
print dict_equals(a, b)

J'espère que cela pourra aider!

Pourquoi ne pas simplement parcourir un dictionnaire et vérifier l'autre dans le processus (en supposant que les deux dictionnaires ont les mêmes clés)?

x = dict(a=1, b=2)
y = dict(a=2, b=2)

for key, val in x.items():
    if val == y[key]:
        print ('Ok', val, y[key])
    else:
        print ('Not', val, y[key])

Production:

Not 1 2
Ok 2 2

La façon la plus simple (et l'une des plus robustes) de comparer en profondeur deux dictionnaires consiste à les sérialiser au format JSON, à trier les clés et à comparer les résultats de la chaîne:

import json
if json.dumps(x, sort_keys=True) == json.dumps(y, sort_keys=True):
   ... Do something ...

import json

if json.dumps(dict1) == json.dumps(dict2):
    print("Equal")