Wie füge ich zwei Wörterbücher in einem Ausdruck zusammen?

Wie kann ich das Zusammenführen von zwei Python Wörterbücher in einem einzigen Ausdruck?

Wörterbücher für x und yz wird eine zusammengeführte dictionary mit Werten aus y ersetzen diejenigen vom x.

• In Python 3.5 oder höher :

  z = {**x, **y}

• In Python 2, (oder 3.4 oder niedriger) schreiben Sie eine Funktion:

  def merge_two_dicts(x, y):
      z = x.copy()   # start with x's keys and values
      z.update(y)    # modifies z with y's keys and values & returns None
      return z

  und

  z = merge_two_dicts(x, y)

Erklärung

Sagen, Sie haben zwei dicts und Sie Zusammenführen möchten Sie in ein neues dict-ohne Veränderung des original-dicts:

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

Das gewünschte Ergebnis zu bekommen ist ein neues Wörterbuch (z) mit den Werten verschmolzen, und die zweite dict-Werte überschreiben, die von der ersten.

>>> z
{'a': 1, 'b': 3, 'c': 4}

Eine neue syntax für diese, schlug in PEP 448 und lieferbar als Python-3.5ist

z = {**x, **y}

Und es ist in der Tat ein einzelner Ausdruck. Es ist nun zu zeigen, wie die Umsetzung in der release-Zeitplan für 3.5, PEP 478und hat es nun seinen Weg in Was ist Neu in Python 3.5 Dokument.

Da jedoch viele Organisationen sind immer noch auf Python 2 Sie möchten, können Sie dies tun, in einem rückwärts kompatiblen Art und Weise. Die klassisch-Pythonic way, verfügbar in Python 2 und Python 3.0-3.4, tun dies als ein zwei-Schritt-Prozess:

z = x.copy()
z.update(y) # which returns None since it mutates z

In beiden Ansätzen y kommen zweiten, und Ihre Werte ersetzen x's Werte, so 'b' auf 3 in unserem letzten Ergebnis.

Noch nicht auf Python 3.5, aber ein einzelnen Ausdruck

Wenn Sie noch nicht auf Python 3.5 oder schreiben zu müssen-rückwärts-kompatiblen code, und Sie wollen dies in einem einzelnen Ausdruckdie performant, während der richtige Ansatz ist, um es in eine Funktion:

def merge_two_dicts(x, y):
    """Given two dicts, merge them into a new dict as a shallow copy."""
    z = x.copy()
    z.update(y)
    return z

und dann haben Sie einen einzigen Ausdruck:

z = merge_two_dicts(x, y)

Können Sie auch eine Funktion zum Zusammenführen einer unbestimmten Anzahl von dicts, von null auf eine sehr große Anzahl:

def merge_dicts(*dict_args):
    """
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result

Diese Funktion wird in Python 2 und 3 für alle dicts. z.B. gegeben dicts a zu g:

z = merge_dicts(a, b, c, d, e, f, g) 

- und Schlüssel-Wert-Paare in g Vorrang vor dicts a zu fund so weiter.

Kritiken von Anderen Antworten

Nicht verwenden, was Sie in der früher akzeptierte Antwort:

z = dict(x.items() + y.items())

In Python 2 erstellen Sie zwei Listen im Speicher für jeden dict-erstellen Sie eine Dritte Liste im Speicher mit einer Länge gleich der Länge der beiden ersten zusammen, und legen Sie alle drei Listen zu erstellen, die der dict. In Python 3, wird dies scheiternweil Sie das hinzufügen von zwei dict_items Objekte zusammen, nicht zwei Listen -

>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'

und Sie würden explizit erstellen Sie Listen, z.B. z = dict(list(x.items()) + list(y.items())). Dies ist eine Verschwendung von Ressourcen und Rechenleistung.

Ähnlich, wobei die union der items() in Python 3 (viewitems() in Python 2.7) wird auch scheitern, wenn die Werte unhashable Objekte (wie Listen, zum Beispiel). Auch wenn deine Werte sind hashable, da-Sätze sind semantisch ungeordnete, das Verhalten ist undefiniert in Bezug auf die Rangfolge. So tun Sie das nicht:

>>> c = dict(a.items() | b.items())

Dieses Beispiel zeigt, was passiert, wenn Werte unhashable:

>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Hier ist ein Beispiel, wo y sollte Vorrang haben, sondern der Wert von x wird beibehalten, aufgrund der willkürlichen Reihenfolge der Sätze:

>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}

Anderen hack sollten Sie nicht verwenden:

z = dict(x, **y)

Diese nutzt die dict Konstruktor, und ist sehr schnell, und Speicher effizient (sogar etwas mehr-so, als unsere zwei-Schritt-Prozess), aber es sei denn, Sie wissen genau, was hier passiert (das heißt, die zweite dict übergeben wird als Schlüsselwort-Argumente an die dict-Konstruktor), es ist schwer zu Lesen, es ist nicht die beabsichtigte Verwendung, und so ist es nicht Pythonic.

Hier ist ein Beispiel für die Nutzung als saniert in django.

Dicts geplanten hashable-Tasten (z.B. frozensets oder Tupel), aber versagt diese Methode in Python 3 bei der Schlüsselübergabe, sind keine strings.

>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

Aus der MailinglisteGuido van Rossum, der Schöpfer der Sprache, schrieb:

Ich bin fein mit
deklarieren dict({}, **{1:3}) illegal, denn nach all, es ist Missbrauch
die * * - Mechanismus.

und

Offenbar dict(x, **y) gehen, um als "Cooler hack" für "call
x.update(y) - und return-x". Ich persönlich finde es mehr als verwerflich
cool.

Es ist mein Verständnis (wie auch das Verständnis für die Schöpfer der Sprache), dass die beabsichtigte Nutzung für dict(**y) ist für die Erstellung von dicts für eine bessere Lesbarkeit, z.B.:

dict(a=1, b=10, c=11)

statt

{'a': 1, 'b': 10, 'c': 11}

Reaktion auf Kommentare

Trotz allem, was Guido sagt, dict(x, **y) im Einklang mit der dict-Spezifikation, die btw. funktioniert sowohl für Python 2 und 3. Die Tatsache, dass dies nur bei string-Schlüssel ist eine direkte Folge davon, wie keyword-Parameter arbeiten und nicht eine kurz-kommen, von dict. Noch ist mit dem * * - operator an dieser Stelle einen Missbrauch des Mechanismus, in der Tat ** wurde exakt konstruiert, um pass-dicts als Schlagworte.

Wieder, es doesn ' T Arbeit für 3, wenn die Tasten sind nicht-Streichern. Der implizite Aufruf Vertrages ist, dass namespaces nehmen normalen dicts, während der Benutzer muss nur pass-Schlüsselwort-Argumente sind Zeichenfolgen. Alle anderen callables durchgesetzt. dict brach diese Konsistenz in Python 2:

>>> foo(**{('a', 'b'): None})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{('a', 'b'): None})
{('a', 'b'): None}

Diese Inkonsistenz wurde schlecht gegeben, andere Implementierungen von Python (Pypy, Jython, IronPython). So war es fest in Python 3, als diese Nutzung könnte eine wichtige änderung.

Ich Ihnen zu, dass es bösartig ist Inkompetenz absichtlich code schreiben, das funktioniert nur in einer version, die Sprache oder das funktioniert nur bei bestimmten willkürlichen Einschränkungen.

Anderen Kommentar:

dict(x.items() + y.items()) ist immer noch die lesbare Lösung für Python 2. Die Lesbarkeit zählt.

Meine Antwort: merge_two_dicts(x, y) tatsächlich scheint viel klarer zu mir, wenn wir sind tatsächlich besorgt um die Lesbarkeit zu verbessern. Und es ist nicht aufwärtskompatibel, da Python 2 ist zunehmend veraltet.

Weniger Performant, Aber Korrekte Ad-hocs

Diese Ansätze sind weniger performant, aber Sie werden das richtige Verhalten.
Sie werden viel weniger performant als copy und update oder die neuen Auspacken, weil Sie iterativ durch die einzelnen Schlüssel-Wert-paar auf einer höheren Ebene der Abstraktion, aber Sie tun hinsichtlich der Reihenfolge der Priorität (letztere dicts haben Vorrang)

Können Sie auch die Kette dicts manuell innerhalb eines dict-comprehension:

{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7

oder in python 2.6 (und vielleicht schon 2.4 wenn die generator expressions vorgestellt wurden):

dict((k, v) for d in dicts for k, v in d.items())

itertools.chain wird die Kette mit Iteratoren über die Schlüssel-Wert-Paare in der richtigen Reihenfolge:

import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))

Performance-Analyse

Ich werde nur zu tun, die performance-Analyse der Nutzungen bekannt, die sich korrekt Verhalten.

import timeit

Folgende geschieht auf Ubuntu 14.04

In Python 2.7 (system Python):

>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934

In Python 3.5 (deadsnakes PPA):

>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287

Ressourcen auf Wörterbücher

• Meine Erklärung von Python Wörterbuch Umsetzungaktualisiert für 3.6.
• Antwort auf, wie man einen neuen Schlüssel hinzufügen Wörterbuch
• Mapping zwei Listen in ein dictionary
• Der offiziellen Python - Dokumentation über Wörterbücher
• Das Wörterbuch Noch Mächtiger - Vortrag von Brandon Rhodes auf Pycon 2017
• Moderne Python-Dictionaries, Eine Ansammlung von Tollen Ideen - Vortrag von Raymond Hettinger auf Pycon 2017

InformationsquelleAutor der Antwort Aaron Hall

Alternative:

z = x.copy()
z.update(y)

InformationsquelleAutor der Antwort Matthew Schinckel

Diese wahrscheinlich nicht eine beliebte Antwort, aber Sie fast sicher nicht wollen, dies zu tun. Wenn Sie möchten, eine Kopie, ein merge ist, dann verwenden Sie kopieren (oder deepcopyje nachdem, was Sie wollen) und dann zu aktualisieren. Die zwei Zeilen code sehr viel besser lesbar - mehr Pythonic - als die einzige Zeile die Schöpfung mit .Elemente() + .Elemente(). Explizit ist besser als implizit.

Darüber hinaus, wenn Sie verwenden .Elemente() (vor Python 3.0), erstellen Sie eine neue Liste, die die Elemente enthält, die aus der dict. Wenn Ihre Wörterbücher sind groß, dann ist das ziemlich viel Aufwand (zwei große Listen, die werden weggeworfen, sobald die zusammengeführten dict erstellt wird). update() können effizienter arbeiten, weil es laufen kann, durch die zweite dict-Element-by-Element.

In Bezug auf Zeit:

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

IMO die winzige Abschwächung zwischen den ersten beiden ist es Wert für die Lesbarkeit. Darüber hinaus Schlüsselwort-Argumente für die Wörterbuch-Schöpfung wurde nur Hinzugefügt, in Python 2.3, in der Erwägung, dass copy() und update() funktioniert in älteren Versionen.

InformationsquelleAutor der Antwort Tony Meyer

Ich wollte etwas ähnliches, aber mit der Fähigkeit, um anzugeben, wie die Werte, auf doppelte Schlüssel zusammengeführt wurden, so dass ich gehackt (aber nicht stark testen). Natürlich ist dies nicht ein einzelner Ausdruck, aber es ist eine einzelne Funktion aufrufen.

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

InformationsquelleAutor der Antwort rcreswick

Rekursiv/tief-update ein dict

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

Demonstration:

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

Ausgänge:

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

Dank rednaw bearbeitet werden.

InformationsquelleAutor der Antwort Stan

Python-3.5 (PEP 448) ermöglicht eine schönere syntax option:

x = {'a': 1, 'b': 1}
y = {'a': 2, 'c': 2}
final = {**x, **y} 
final
# {'a': 2, 'b': 1, 'c': 2}

Oder sogar

final = {'a': 1, 'b': 1, **x, **y}

InformationsquelleAutor der Antwort Bilal Syed Hussain

Während die Frage wurde bereits mehrfach beantwortet,
diese einfache Lösung für das problem wurde nicht gelistet.

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

Ist es, so schnell wie z0 und das böse, das z2 erwähnt, aber leicht zu verstehen und zu ändern.

InformationsquelleAutor der Antwort phobie

Wenn Sie denken, dass Lambda-Ausdrücke sind böse, dann Lesen Sie nicht weiter.
Wie gewünscht, können Sie die schnelle und Speicher-effiziente Lösung mit einem Ausdruck:

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

Wie oben angedeutet, mit zwei Linien oder schreiben Sie eine Funktion ist möglicherweise ein besserer Weg zu gehen.

InformationsquelleAutor der Antwort EMS

Werden pythonic. Verwenden Sie eine Verständnis:

z={i:d[i] for d in [x,y] for i in d}

>>> print z
{'a': 1, 'c': 11, 'b': 10}

InformationsquelleAutor der Antwort Robino

Einfache Lösung mit itertools, bewahrt Bestellung (letztere dicts haben Vorrang)

import itertools as it
merge = lambda *args: dict(it.chain.from_iterable(it.imap(dict.iteritems, args)))

Und es Verwendung:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> merge(x, y)
{'a': 1, 'b': 10, 'c': 11}

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 4}

InformationsquelleAutor der Antwort reubano

Obwohl die Antworten waren gut für diese flachen Wörterbuch keine der Methoden definiert hier eigentlich mache einen tiefen Wörterbuch Zusammenführen.

Beispiele:

a = { 'one': { 'depth_2': True }, 'two': True }
b = { 'one': { 'extra': False } }
print dict(a.items() + b.items())

Würde man erwarten, eine Wirkung von etwas wie dies:

{ 'one': { 'extra': False', 'depth_2': True }, 'two': True }

Stattdessen bekommen wir dies:

{'two': True, 'one': {'extra': False}}

Das " man " - Eintrag haben sollte, hatte 'depth_2' und 'extra' als Artikel in seinem Wörterbuch, wenn es war wirklich ein merge.

Mit Kette auch nicht funktioniert:

from itertools import chain
print dict(chain(a.iteritems(), b.iteritems()))

Ergebnisse in:

{'two': True, 'one': {'extra': False}}

Das Tiefe verschmelzen, dass rcwesick gab auch erzeugt das gleiche Ergebnis.

Ja, es wird funktionieren, zum Zusammenführen der Probe Wörterbücher, aber keiner von Ihnen hat einen generischen Mechanismus zu verschmelzen. Ich werde aktualisieren diese später einmal Schreibe ich eine Methode, die ein wahres verschmelzen.

InformationsquelleAutor der Antwort Thanh Lim

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x, z = dict(x), x.update(y) or x
>>> x
{'a': 1, 'b': 2}
>>> y
{'c': 11, 'b': 10}
>>> z
{'a': 1, 'c': 11, 'b': 10}

InformationsquelleAutor der Antwort John La Rooy

Zeichnung auf Ideen hier und anderswo habe ich Begriffen, eine Funktion:

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

Nutzung (getestet in python 3):

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

Könnte man eine lambda statt.

InformationsquelleAutor der Antwort Bijou Trouvaille

(Für Python2.7* nur; es gibt einfachere Lösungen für Python ist3*.)

Wenn Sie nicht abgeneigt zu importieren einer standard-Bibliothek Modul, die Sie tun können,

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

(Die or a bit in der lambda ist notwendig, weil dict.update gibt immer None auf Erfolg.)

InformationsquelleAutor der Antwort kjo

Können Sie toolz.merge([x, y]).

InformationsquelleAutor der Antwort Mike Graham