comment concaténer deux dictionnaires pour en créer un nouveau en Python? [dupliquer]

1. le plus lent et ne fonctionne pas en Python3: concaténez le items et appelez dict sur la liste résultante:

   $ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
   'd4 = dict(d1.items() + d2.items() + d3.items())'
   
   100000 loops, best of 3: 4.93 usec per loop
   

2. le plus rapide: exploiter le constructeur dict jusqu'au bout, puis un update :

   $ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
   'd4 = dict(d1, **d2); d4.update(d3)'
   
   1000000 loops, best of 3: 1.88 usec per loop
   

3. Médiocre: une boucle de update appels sur un initialement vide dict:

   $ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
   'd4 = {}' 'for d in (d1, d2, d3): d4.update(d)'
   
   100000 loops, best of 3: 2.67 usec per loop
   

4. Ou, de manière équivalente, un copier-ctor et deux mises à jour:

   $ python -mtimeit -s'd1={1:2,3:4}; d2={5:6,7:9}; d3={10:8,13:22}' \
   'd4 = dict(d1)' 'for d in (d2, d3): d4.update(d)'
   
   100000 loops, best of 3: 2.65 usec per loop
   

je recommande approche (2), et je recommande particulièrement d'éviter (1) (qui prend également O(N) mémoire auxiliaire supplémentaire pour la liste concaténée d'éléments structure de données temporaire).

d4 = dict(d1.items() + d2.items() + d3.items())

alternativement (et prétendument plus rapide):

d4 = dict(d1)
d4.update(d2)
d4.update(d3)

question précédente donc que ces deux réponses sont venues de est ici .

vous pouvez utiliser la méthode update() pour construire un nouveau dictionnaire contenant tous les articles:

dall = {}
dall.update(d1)
dall.update(d2)
dall.update(d3)

ou, en boucle:

dall = {}
for d in [d1, d2, d3]:
  dall.update(d)

utiliser le constructeur DCT

d1={1:2,3:4}
d2={5:6,7:9}
d3={10:8,13:22}

d4 = reduce(lambda x,y: dict(x, **y), (d1, d2, d3))

en fonction

from functools import partial
dict_merge = partial(reduce, lambda a,b: dict(a, **b))

les frais généraux liés à la création de dictionnaires intermédiaires peuvent être éliminés en utilisant la méthode dict.update() :

from functools import reduce
def update(d, other): d.update(other); return d
d4 = reduce(update, (d1, d2, d3), {})

Voici une doublure ( imports don't count :) qui peut facilement être généralisée pour concaténer n dictionnaires:

Python 2.6+

from itertools import chain
dict(chain.from_iterable(d.iteritems() for d in (d1, d2, d3))

sortie:

>>> from itertools import chain
>>> d1={1:2,3:4}
>>> d2={5:6,7:9}
>>> d3={10:8,13:22}
>>> dict(chain.from_iterable(d.iteritems() for d in (d1, d2, d3)))
{1: 2, 3: 4, 5: 6, 7: 9, 10: 8, 13: 22}

Généralisée pour concaténer N dicts:

from itertools import chain
def dict_union(*args):
    return dict(chain.from_iterable(d.iteritems() for d in args))

Python 3

from itertools import chain
dict(chain.from_iterable(d.items() for d in (d1, d2, d3)))

et:

from itertools import chain
def dict_union(*args):
    return dict(chain.from_iterable(d.items() for d in args))

je suis un peu en retard à cette fête, je sais, mais j'espère que cela aidera quelqu'un.