¿Cómo puedo combinar diccionarios con las mismas claves en python?

Digamos que tengo una lista de diccionarios así:

dict[0] is {'key_a': valuex1, 'key_b': valuex2, 'key_c': valuex3} dict[1] is {'key_a': valuey1, 'key_b': valuey2, 'key_c': valuey3} dict[2] is {'key_a': valuez1, 'key_b': valuez2, 'key_c': valuez3} 

Me gustaría tomar estos y construir un gran diccionario como tal:

 big_dict: {'key_a': [valuex1, valuey1, valuez1], 'key_b': [valuex2, valuey2, valuez2], 'key_c': [valuex3, valuey3, valuez3]} 

¿Hay alguna forma elegante de ” zip ” para que yo haga esto?

Todas las llaves siempre van a ser idénticas.

Siempre puedo iterar las claves de cada una y construir un nuevo diccionario de listas, pero eso parece muy poco parecido a un python.

 big_dict = {} for k in dicts[0]: big_dict[k] = [d[k] for d in dicts] 

( dicts nombre de tus dict a dicts ya que dict está integrado, y los dicts tienen más sentido).

O, con un dictado de comprensión:

 { k:[d[k] for d in dicts] for k in dicts[0] } 

o, para Python <2.7:

 dict((k, [d[k] for d in dicts]) for k in dicts[0]) 

Si todos los dictados tienen el mismo conjunto de claves, esto funcionará:

 dict((k, [d[k] for d in dictList]) for k in dictList[0]) 

Si pueden tener claves diferentes, primero deberá crear un conjunto de claves haciendo uniones de conjuntos en las claves de los distintos dictados:

 allKeys = reduce(operator.or_, (set(d.keys()) for d in dictList), set()) 

Entonces deberás protegerte de las claves que faltan en algunos dictados:

 dict((k, [d[k] for d in [a, b] if k in d]) for k in allKeys) 

Puedes fusionar diccionarios de la siguiente manera:

 def merge_dicts(dict_list, separator=''): """ Merges list of dictionaries to a single dictionary, Concatenates values with the same key. :param dict_list: list of dictionaries to be merged. :param separator: separator to be inserted between values of same key. :return: Merged dictionary. """ return {k1: separator.join([d[k1] for d in dict_list if k1 in d]) for k1 in set(reduce(lambda x, y: x+y, [k.keys() for k in dict_list])) } 

Puede utilizar collections.defaultdict . El beneficio de esta solución es que no requiere que las claves sean coherentes en todos los diccionarios, y aún mantiene la complejidad mínima de O ( n ).

 from collections import defaultdict dictList = [{'key_a': 'valuex1', 'key_b': 'valuex2', 'key_c': 'valuex3'}, {'key_a': 'valuey1', 'key_b': 'valuey2', 'key_c': 'valuey3'}, {'key_a': 'valuez1', 'key_b': 'valuez2', 'key_c': 'valuez3'}] d = defaultdict(list) for myd in dictList: for k, v in myd.items(): d[k].append(v) 

Resultado:

 print(d) defaultdict(list, {'key_a': ['valuex1', 'valuey1', 'valuez1'], 'key_b': ['valuex2', 'valuey2', 'valuez2'], 'key_c': ['valuex3', 'valuey3', 'valuez3']}) 

Si está contento de usar una biblioteca de terceros, puede usar Pandas. El constructor pd.DataFrame acepta una lista de diccionarios directamente:

 import pandas as pd res = pd.DataFrame(dictList).to_dict(orient='list') {'key_a': ['valuex1', 'valuey1', 'valuez1'], 'key_b': ['valuex2', 'valuey2', 'valuez2'], 'key_c': ['valuex3', 'valuey3', 'valuez3']}