Comparer deux dictionnaires et vérifier combien de paires (clé, valeur) sont égales.

Question

J'ai deux dictionnaires, mais pour simplifier, je vais prendre ces deux-là :

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

Maintenant, je veux comparer si chaque key, value paire dans x a la même valeur correspondante dans y . Alors j'ai é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 depuis un tuple est retourné et ensuite comparé pour l'égalité.

Mes questions :

Est-ce correct ? Y a-t-il un meilleur manière de faire ça ? Mieux vaut ne pas parler de vitesse, je parle de l'élégance du code.

UPDATE : J'ai oublié de mentionner que je dois vérifier combien de key, value sont égales.

Answer 1

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)

Answer 2

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 un ordre quelconque. Vous pourriez être en train de 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 que d'un seul élément, mais votre algorithme verra que tous les articles sont différents

Answer 3

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)

Answer 4

Je suis novice en 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 ( ^ ) devrait éliminer tous les éléments du dict lorsqu'ils sont les mêmes dans les deux dicts.

Answer 5

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

En haut de ma tête, quelque chose comme ça pourrait marcher :

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