Wie füge ich Wörterbücher in Python zusammen?

d3 = dict(d1, **d2)

Ich verstehe, dass dies das Wörterbuch zusammenführt. Aber ist es einzigartig? Was ist, wenn d1 den gleichen Schlüssel wie d2 hat, aber einen anderen Wert? Ich möchte, dass d1 und d2 zusammengeführt werden, aber d1 hat Priorität, wenn es einen doppelten Schlüssel gibt.

Sie können die .update()Methode verwenden, wenn Sie das Original d2nicht mehr benötigen :

Aktualisieren Sie das Wörterbuch mit den Schlüssel / Wert-Paaren anderer, wobei vorhandene Schlüssel überschrieben werden . Zurück None.

Z.B:

>>> d1 = {'a': 1, 'b': 2} 
>>> d2 = {'b': 1, 'c': 3}
>>> d2.update(d1)
>>> d2
{'a': 1, 'c': 3, 'b': 2}

Aktualisieren:

Natürlich können Sie das Wörterbuch zuerst kopieren, um ein neues zusammengeführtes zu erstellen. Dies kann erforderlich sein oder auch nicht. Falls Ihr Wörterbuch zusammengesetzte Objekte (Objekte, die andere Objekte wie Listen oder Klasseninstanzen enthalten) enthält, copy.deepcopysollte dies ebenfalls berücksichtigt werden.

In Python2

d1={'a':1,'b':2}
d2={'a':10,'c':3}

d1 überschreibt d2:

dict(d2,**d1)
# {'a': 1, 'c': 3, 'b': 2}

d2 überschreibt d1:

dict(d1,**d2)
# {'a': 10, 'c': 3, 'b': 2}

Dieses Verhalten ist nicht nur ein Zufall bei der Implementierung. es ist in der Dokumentation garantiert :

Wenn ein Schlüssel sowohl im Positionsargument als auch als Schlüsselwortargument angegeben wird, bleibt der dem Schlüsselwort zugeordnete Wert im Wörterbuch erhalten.

Wenn Sie d1in den Konflikten Vorrang haben möchten , gehen Sie wie folgt vor:

d3 = d2.copy()
d3.update(d1)

Ansonsten umgekehrt d2und d1.

Meine Lösung besteht darin, eine Zusammenführungsfunktion zu definieren . Es ist nicht raffiniert und kostet nur eine Zeile. Hier ist der Code in Python 3.

from functools import reduce
from operator import or_

def merge(*dicts):
    return { k: reduce(lambda d, x: x.get(k, d), dicts, None) for k in reduce(or_, map(lambda x: x.keys(), dicts), set()) }

Tests

>>> d = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> d_letters = {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge(d, d_letters)
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge(d_letters, d)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge(d)
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
>>> merge(d_letters)
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e', 5: 'f', 6: 'g', 7: 'h', 8: 'i', 9: 'j', 10: 'k', 11: 'l', 12: 'm', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'r', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'C', 29: 'D', 30: 'E', 31: 'F', 32: 'G', 33: 'H', 34: 'I', 35: 'J', 36: 'K', 37: 'L', 38: 'M', 39: 'N', 40: 'O', 41: 'P', 42: 'Q', 43: 'R', 44: 'S', 45: 'T', 46: 'U', 47: 'V', 48: 'W', 49: 'X', 50: 'Y', 51: 'Z'}
>>> merge()
{}

Es funktioniert für eine beliebige Anzahl von Wörterbuchargumenten. Gab es doppelte Schlüssel in diesem Wörterbuch, gewinnt der Schlüssel aus dem Wörterbuch ganz rechts in der Argumentliste.

Trey Hunner hat einen schönen Blog-Beitrag , in dem verschiedene Optionen zum Zusammenführen mehrerer Wörterbücher beschrieben sind, darunter (für Python3.3 +) ChainMap und das Entpacken von Wörterbüchern .

Beginnend erstellt Python 3.9der Bediener |ein neues Wörterbuch mit den zusammengeführten Schlüsseln und Werten aus zwei Wörterbüchern:

# d1 = { 'a': 1, 'b': 2 }
# d2 = { 'b': 1, 'c': 3 }
d3 = d2 | d1
# d3: {'b': 2, 'c': 3, 'a': 1}

Dies:

Erstellt ein neues Wörterbuch d3 mit den zusammengeführten Schlüsseln und Werten von d2 und d1. Die Werte von d1 haben Priorität, wenn sich d2 und d1 Schlüssel teilen.

Beachten Sie auch den |=Operator, der d2 durch Zusammenführen von d1 mit Priorität für d1-Werte ändert:

# d1 = { 'a': 1, 'b': 2 }
# d2 = { 'b': 1, 'c': 3 }
d2 |= d1
# d2: {'b': 2, 'c': 3, 'a': 1}

Ich glaube, dass, wie oben erwähnt, die Verwendung d2.update(d1)der beste Ansatz ist und dass Sie auch d2zuerst kopieren können, wenn Sie es noch benötigen.

Obwohl ich darauf hinweisen möchte, dass dies dict(d1, **d2)im Allgemeinen eine schlechte Methode zum Zusammenführen von Wörterbüchern ist, da Schlüsselwortargumente Zeichenfolgen sein müssen, schlägt dies fehl, wenn Sie Folgendes haben dict:

{
  1: 'foo',
  2: 'bar'
}