Come faccio a unire un elenco di dict in un unico dict?

Come posso trasformare un elenco di dict come questo

[{'a':1}, {'b':2}, {'c':1}, {'d':2}]

In un unico dict come questo

{'a':1, 'b':2, 'c':1, 'd':2}

Funziona per dizionari di qualsiasi lunghezza:

>>> result = {}
>>> for d in L:
...    result.update(d)
... 
>>> result
{'a':1,'c':1,'b':2,'d':2}

Come comprensione :

# Python >= 2.7
{k: v for d in L for k, v in d.items()}

# Python < 2.7
dict(pair for d in L for pair in d.items())

In caso di Python 3.3+, c'è una ChainMapraccolta :

>>> from collections import ChainMap
>>> a = [{'a':1},{'b':2},{'c':1},{'d':2}]
>>> dict(ChainMap(*a))
{'b': 2, 'c': 1, 'a': 1, 'd': 2}

Vedi anche:

• Qual è lo scopo di collections.ChainMap?

>>> L=[{'a': 1}, {'b': 2}, {'c': 1}, {'d': 2}]    
>>> dict(i.items()[0] for i in L)
{'a': 1, 'c': 1, 'b': 2, 'd': 2}

Nota: l'ordine di "b" e "c" non corrisponde al tuo output perché i dict non sono ordinati

se i dict possono avere più di una chiave / valore

>>> dict(j for i in L for j in i.items())

Per i dizionari piatti puoi fare questo:

from functools import reduce
reduce(lambda a, b: dict(a, **b), list_of_dicts)

Questo è simile a @delnan ma offre la possibilità di modificare gli elementi k / v (chiave / valore) e credo sia più leggibile:

new_dict = {k:v for list_item in list_of_dicts for (k,v) in list_item.items()}

ad esempio, sostituire gli elementi k / v come segue:

new_dict = {str(k).replace(" ","_"):v for list_item in list_of_dicts for (k,v) in list_item.items()}

decomprime la tupla k, v dal generatore di dizionario .items () dopo aver estratto l'oggetto dict dalla lista

dict1.update( dict2 )

Questo è asimmetrico perché devi scegliere cosa fare con le chiavi duplicate; in questo caso, dict2sovrascriveràdict1 . Scambiali con l'altro modo.

EDIT: Ah, scusa, non l'ho visto.

È possibile farlo in una singola espressione:

>>> from itertools import chain
>>> dict( chain( *map( dict.items, theDicts ) ) )
{'a': 1, 'c': 1, 'b': 2, 'd': 2}

Nessun merito per me per quest'ultimo!

Tuttavia, direi che potrebbe essere più Pythonic (esplicito> implicito, piatto> annidato) farlo con un semplice forciclo. YMMV.

Puoi usare la funzione join dalla libreria funcy :

from funcy import join
join(list_of_dicts)

Piccolo miglioramento per la risposta di @dietbuddha con lo spacchettamento del dizionario da PEP 448 , per me è più leggibile in questo modo, inoltre, è anche più veloce :

from functools import reduce
result_dict = reduce(lambda a, b: {**a, **b}, list_of_dicts)

Ma tieni presente che funziona solo con le versioni di Python 3.5+.

>>> dictlist = [{'a':1},{'b':2},{'c':1},{'d':2, 'e':3}]
>>> dict(kv for d in dictlist for kv in d.iteritems())
{'a': 1, 'c': 1, 'b': 2, 'e': 3, 'd': 2}
>>>

Nota ho aggiunto una seconda coppia chiave / valore all'ultimo dizionario per mostrare che funziona con più voci. Anche le chiavi dei dict più avanti nell'elenco sovrascriveranno la stessa chiave di un dict precedente.

dic1 = {'Maria': 12, 'Paco': 22, 'Jose': 23} dic2 = {'Patricia': 25, 'Marcos': 22 'Tomas': 36}

dic2 = dict (dic1.items () + dic2.items ())

e questo sarà il risultato:

dic2 {'Jose': 23, 'Marcos': 22, 'Patricia': 25, 'Tomas': 36, 'Paco': 22, 'Maria': 12}