Vergleicht man zwei Wörterbücher in Python

Question

Ich habe zwei Wörterbücher, aber zur Vereinfachung werde ich nehmen diese beiden:

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

Jetzt möchte ich, ob jedes key, value Paar in x vergleichen denselben entsprechenden Wert in y hat. Also schrieb ich diese:

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

Und es funktioniert, da ein tuple zurückgegeben und dann im Vergleich zur Gleichheit.

Meine Fragen:

Ist das korrekt? Gibt es einen besseren Weg, dies zu tun? Besser nicht in Geschwindigkeit, ich spreche von Code Eleganz.

UPDATE: Ich habe vergessen zu erwähnen, dass ich überprüfen muss, wie viele key, value Paare sind gleich.

Answer 1

Wenn Sie, wie viele Werte übereinstimmen wissen wollen, in sowohl die Wörterbücher, sollten Sie gesagt haben, dass :)

Vielleicht so etwas wie folgt aus:

shared_items = set(x.items()) & set(y.items()) 
print len(shared_items) 

Answer 2

Was Sie tun möchten, ist einfach x==y

Was Sie tun, ist keine gute Idee, da die Elemente in einem Wörterbuch sind keine Ordnung haben soll. Sie könnten [('a',1),('b',1)] mit [('b',1), ('a',1)] vergleichen (gleiche Wörterbücher, andere Reihenfolge).

Zum Beispiel sehen:

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

Der Unterschied ist nur ein Element, aber Ihr Algorithmus werden sehen, dass alle Artikel unterschiedlich sind

Answer 3

Ich bin neu in Python, aber ich endete etwas zu tun, ähnlich wie @mouad

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

Der XOR-Operator (^) sollten alle Elemente des dict beseitigen, wenn sie das gleiche in beiden dicts sind.

Answer 4

def dict_compare(d1, d2): 
    d1_keys = set(d1.keys()) 
    d2_keys = set(d2.keys()) 
    intersect_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 intersect_keys if d1[o] != d2[o]} 
    same = set(o for o in intersect_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 5

@mouads Antwort ist nett, wenn Sie davon ausgehen, dass beide Wörterbücher nur einfache Werte enthalten. Wenn Sie jedoch Wörterbücher mit Wörterbüchern haben, erhalten Sie eine Ausnahme, da Wörterbücher nicht hashbar sind.

Aus der Spitze von meinem Kopf, so etwas wie dies funktionieren könnte:

def compare_dictionaries(dict1, dict2): 
    if dict1 == None or dict2 == None: 
     return False 

    if type(dict1) is not dict or type(dict2) is not dict: 
     return False 

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

    if not (len(shared_keys) == len(dict1.keys()) and len(shared_keys) == len(dict2.keys())): 
     return False 


    dicts_are_equal = True 
    for key in dict1.keys(): 
     if type(dict1[key]) is dict: 
      dicts_are_equal = dicts_are_equal and compare_dictionaries(dict1[key],dict2[key]) 
     else: 
      dicts_are_equal = dicts_are_equal and (dict1[key] == dict2[key]) 

    return dicts_are_equal 

Bitte beachte, dass ich über die Linie noch nicht glücklich bin:

dicts_are_equal = dicts_are_equal and (dict1[key] == dict2[key]) 

als die Werte dieser könnte sein Objekte. Es wäre schön zu überprüfen, ob die beiden Objekte eine vergleichbare Schnittstelle implementieren.

Answer 6

>>> 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' 

Hier ist eine andere Option:

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

So wie Sie die beiden IDs sind unterschiedlich sehen. Aber die rich comparison operators scheinen den Trick zu tun:

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

Answer 7

Noch eine weitere Möglichkeit, bis zur letzten Note der OP, die Hashes zu vergleichen ist (SHA oder MD) die dicts als JSON abgeladen. Die Weg-Hashes sind so konstruiert, dass sie, wenn sie gleich sind, gleichwertig sind. Das ist sehr schnell und mathematisch fundiert.

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

Answer 8

Verwenden Sie einfach:

assert cmp(dict1, dict2) == 0 

Answer 9

import json 

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

Answer 10

wenn zwei Wörterbücher den gleichen Inhalt zu überprüfen, verwenden Sie einfach:

dic1 == dic2 

Von python docs:

Zur Veranschaulichung die folgenden Beispiele alle Rück ein Wörterbuch gleich { "one": 1, "zwei": 2, "drei": 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 

Answer 11

-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 

-Test

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

Answer 12

In PyUnit gibt es eine Methode, die Wörterbücher schön vergleicht. Ich habe es mit den folgenden zwei Wörterbüchern getestet und es macht genau das, wonach Sie suchen.

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

Ich empfehle nicht, unittest in Ihren Produktionscode zu importieren. Mein Gedanke ist die Quelle in PyUnit könnte neu programmiert werden, um in der Produktion zu laufen. Es verwendet pprint, die die Wörterbücher "hübsch druckt". Es scheint ziemlich einfach zu sein, diesen Code so anzupassen, dass er "produktionsfertig" ist.

Answer 13

In Python 3.6, kann es als getan werden: -

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

ret Variable wahr ist, wenn alle Elemente von dict_1 in Gegenwart dict_2 in

Answer 14

Wörterbuch Ansicht Objekte sehen: https://docs.python.org/2/library/stdtypes.html#dict

Auf diese Weise können Sie dictView2 von dictView1 subtrahieren und es wird eine Reihe von Schlüssel/Wert-Paaren zurückgegeben, die sich in dictView2 unterscheiden:

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

Sie können diese Wörterbuchansichtsobjekte schneiden, Vereinigung, Unterschied (siehe oben), symmetrische Differenz.
Besser? Schneller?- nicht sicher, aber ein Teil der Standardbibliothek - die es ein großes Plus für die Portabilität

Answer 15

Um zu testen, ob zwei dicts sind gleich in Schlüsseln und Werten macht:

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) 

Wenn Sie die Werte zurückgeben möchten die unterscheiden, schreiben Sie es anders:

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

Sie würden es zweimal

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