Zusammenführen und die Summe der beiden Wörterbücher

Können Sie durchführen +, -, &, und | (intersection und union) auf Sammlungen.Counter().

Also können wir tun, die folgenden (Hinweis: nur positive Werte bleiben im Wörterbuch):

from collections import Counter

x = {'both1':1, 'both2':2, 'only_x': 100 }
y = {'both1':10, 'both2': 20, 'only_y':200 }

z = dict(Counter(x)+Counter(y))

print(z) # {'both2': 22, 'only_x': 100, 'both1': 11, 'only_y': 200}

Adresse hinzufügen von Werten, bei denen das Ergebnis null oder negativ verwenden Counter.update() für neben-und Counter.subtrahieren() für die Subtraktion:

x = {'both1':0, 'both2':2, 'only_x': 100 }
y = {'both1':0, 'both2': -20, 'only_y':200 }
xx = Counter(x)
yy = Counter(y)
xx.update(yy)
dict(xx) # {'both2': -18, 'only_x': 100, 'both1': 0, 'only_y': 200}

InformationsquelleAutor Scott

Zusätzliche Hinweise basiert auf den Antworten von georg, NPE und Scott.

Ich versuche, diese Aktion auszuführen, die auf Sammlungen von 2 oder mehr Wörterbücher und war daran interessiert, dass die Zeit, die es dauerte, für jeden. Weil ich wollte dies auf eine beliebige Anzahl von Wörterbüchern, musste ich einige der Antworten ein wenig. Wenn jemand bessere Vorschläge für Sie, fühlen Sie sich frei zu Bearbeiten.

Hier ist meine test-Methode. Ich habe aktualisiert es vor kurzem sind tests mit größeren Wörterbüchern:

Erstens ich habe folgende Daten:

import random

x = {'xy1': 1, 'xy2': 2, 'xyz': 3, 'only_x': 100}
y = {'xy1': 10, 'xy2': 20, 'xyz': 30, 'only_y': 200}
z = {'xyz': 300, 'only_z': 300}

small_tests = [x, y, z]

# 200,000 random 8 letter keys
keys = [''.join(random.choice("abcdefghijklmnopqrstuvwxyz") for _ in range(8)) for _ in range(200000)]

a, b, c = {}, {}, {}

# 50/50 chance of a value being assigned to each dictionary, some keys will be missed but meh
for key in keys:
    if random.getrandbits(1):
        a[key] = random.randint(0, 1000)
    if random.getrandbits(1):
        b[key] = random.randint(0, 1000)
    if random.getrandbits(1):
        c[key] = random.randint(0, 1000)

large_tests = [a, b, c]

print("a:", len(a), "b:", len(b), "c:", len(c))
#: a: 100069 b: 100385 c: 99989

Nun werden die einzelnen Methoden:

from collections import defaultdict, Counter

def georg_method(tests):
    return {k: sum(t.get(k, 0) for t in tests) for k in set.union(*[set(t) for t in tests])}

def georg_method_nosum(tests):
    # If you know you will have exactly 3 dicts
    return {k: tests[0].get(k, 0) + tests[1].get(k, 0) + tests[2].get(k, 0) for k in set.union(*[set(t) for t in tests])}

def npe_method(tests):
    ret = defaultdict(int)
    for d in tests:
        for k, v in d.items():
            ret[k] += v
    return dict(ret)

# Note: There is a bug with scott's method. See below for details.
def scott_method(tests):
    return dict(sum((Counter(t) for t in tests), Counter()))

def scott_method_nosum(tests):
    # If you know you will have exactly 3 dicts
    return dict(Counter(tests[0]) + Counter(tests[1]) + Counter(tests[2]))

methods = {"georg_method": georg_method, "georg_method_nosum": georg_method_nosum,
           "npe_method": npe_method,
           "scott_method": scott_method, "scott_method_nosum": scott_method_nosum}

Außerdem habe ich eine quick-Funktion zu finden, was Unterschiede gab es zwischen den Listen. Leider, das ist, wenn ich das problem gefunden in Scott ' s Methode, nämlich, wenn Sie Wörterbücher, die insgesamt auf 0, wird das Wörterbuch nicht aufgenommen werden, weil, wie Counter() verhält, wenn Sie hinzufügen.

Schließlich die Ergebnisse:

Ergebnisse: Kleine Tests

for name, method in methods.items():
    print("Method:", name)
    %timeit -n10000 method(small_tests)
#: Method: npe_method
#: 10000 loops, best of 3: 5.16 µs per loop
#: Method: georg_method_nosum
#: 10000 loops, best of 3: 8.11 µs per loop
#: Method: georg_method
#: 10000 loops, best of 3: 11.8 µs per loop
#: Method: scott_method_nosum
#: 10000 loops, best of 3: 42.4 µs per loop
#: Method: scott_method
#: 10000 loops, best of 3: 65.3 µs per loop

Ergebnisse: Große Tests

Natürlich nicht laufen konnte, irgendwo in der Nähe so viele Schleifen

for name, method in methods.items():
    print("Method:", name)
    %timeit -n10 method(large_tests)
#: Method: npe_method
#: 10 loops, best of 3: 227 ms per loop
#: Method: georg_method_nosum
#: 10 loops, best of 3: 327 ms per loop
#: Method: georg_method
#: 10 loops, best of 3: 455 ms per loop
#: Method: scott_method_nosum
#: 10 loops, best of 3: 510 ms per loop
#: Method: scott_method
#: 10 loops, best of 3: 600 ms per loop

Abschluss

╔═══════════════════════════╦═══════╦═════════════════════════════╗
║                           ║       ║   Best of 3 Time Per Loop   ║
║         Algorithm         ║  By   ╠══════════════╦══════════════╣
║                           ║       ║  small_tests ║  large_tests ║
╠═══════════════════════════╬═══════╬══════════════╬══════════════╣
║ defaultdict sum           ║ NPE   ║      5.16 µs ║   227,000 µs ║
║ set unions without sum()  ║ georg ║      8.11 µs ║   327,000 µs ║
║ set unions with sum()     ║       ║      11.8 µs ║   455,000 µs ║
║ Counter() without sum()   ║ Scott ║      42.4 µs ║   510,000 µs ║
║ Counter() with sum()      ║       ║      65.3 µs ║   600,000 µs ║
╚═══════════════════════════╩═══════╩══════════════╩══════════════╝

Wichtig. YMMV.

InformationsquelleAutor SCB

Ich vermute, du suchst dict's update Methode:

>>> d1 = {1:2,3:4}
>>> d2 = {5:6,7:8}
>>> d1.update(d2)
>>> d1
{1: 2, 3: 4, 5: 6, 7: 8}

InformationsquelleAutor zigg

class dict_merge(dict):
def __add__(self, other):
    result = dict_merge({})
    for key in self.keys():
        if key in other.keys():
            result[key] = self[key] + other[key]
        else:
            result[key] = self[key]
    for key in other.keys():
        if key in self.keys():
            pass
        else:
            result[key] = other[key]
    return result


a = dict_merge({"a":2, "b":3, "d":4})
b = dict_merge({"a":1, "b":2})
c = dict_merge({"a":5, "b":6, "c":5})
d = dict_merge({"a":8, "b":6, "e":5})

print((a + b + c +d))


>>> {'a': 16, 'b': 17, 'd': 4, 'c': 5, 'e': 5}

Ist operator zu überladen. Mit __add__ haben wir definiert, wie mit dem operator + für unsere dict_merge was erbt von der eingebauten python dict. Sie können gehen Sie voran und machen Sie es flexibler mit einer ähnlichen Art und Weise zu definieren, anderen Betreibern in der gleichen Klasse z.B. * mit __mul__ für die Multiplikation, oder / mit __div__ für die Teilung, oder auch % mit __mod__ für modulo, und ersetzen die + im self[key] + other[key] mit dem jeweiligen Betreiber und, wenn Sie jemals selbst benötigen solche Verschmelzung.
Ich habe nur getestet, wie es ist, ohne andere Betreiber, aber ich denke, ein problem mit anderen Operatoren. Einfach lernen durch probieren.

InformationsquelleAutor John Mutuma