¿Cómo puedo hacer un diccionario (dict) a partir de listas separadas de claves y valores?

Quiero combinar estos:

keys = ['name', 'age', 'food']
values = ['Monty', 42, 'spam']

En un solo diccionario:

{'name': 'Monty', 'age': 42, 'food': 'spam'}

Como esto:

keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = dict(zip(keys, values))
print(dictionary) # {'a': 1, 'b': 2, 'c': 3}

Voila 🙂 Los pares dict constructor y zip función son increíblemente útiles.

Imagina que tienes:

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')

¿Cuál es la forma más sencilla de producir el siguiente diccionario?

dict = {'name' : 'Monty', 'age' : 42, 'food' : 'spam'}

más eficaz, dict constructor con zip

new_dict = dict(zip(keys, values))

En Python 3, zip ahora devuelve un iterador perezoso, y este es ahora el enfoque de mayor rendimiento.

dict(zip(keys, values)) requiere la búsqueda global única para cada dict y zippero no forma estructuras de datos intermedias innecesarias ni tiene que lidiar con búsquedas locales en la aplicación de funciones.

Subcampeón, comprensión de dictados:

Un finalista cercano al uso del constructor dict es usar la sintaxis nativa de una comprensión dict (no un lista comprensión, como otros han dicho erróneamente):

new_dict = {k: v for k, v in zip(keys, values)}

Elija esto cuando necesite mapear o filtrar según las claves o el valor.

En Python 2, zip devuelve una lista, para evitar crear una lista innecesaria, utilice izip en su lugar (el alias de zip puede reducir los cambios de código cuando pasa a Python 3).

from itertools import izip as zip

Entonces eso sigue siendo (2.7):

new_dict = {k: v for k, v in zip(keys, values)}

Python 2, ideal para

izip de itertools se convierte zip en Phyton 3. izip es mejor que zip para Python 2 (porque evita la creación de listas innecesarias) e ideal para 2.6 o inferior:

from itertools import izip
new_dict = dict(izip(keys, values))

Resultado para todos los casos:

En todos los casos:

>>> new_dict
{'age': 42, 'name': 'Monty', 'food': 'spam'}

Explicación:

Si miramos la ayuda en dict vemos que toma una variedad de formas de argumentos:

>>> help(dict)

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)

El enfoque óptimo es usar un iterable y evitar crear estructuras de datos innecesarias. En Python 2, zip crea una lista innecesaria:

>>> zip(keys, values)
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

En Python 3, el equivalente sería:

>>> list(zip(keys, values))
[('name', 'Monty'), ('age', 42), ('food', 'spam')]

y Python 3 zip simplemente crea un objeto iterable:

>>> zip(keys, values)
<zip object at 0x7f0e2ad029c8>

Dado que queremos evitar la creación de estructuras de datos innecesarias, generalmente queremos evitar Python 2 zip (ya que crea una lista innecesaria).

Alternativas de menor rendimiento:

Esta es una expresión generadora que se pasa al constructor dict:

generator_expression = ((k, v) for k, v in zip(keys, values))
dict(generator_expression)

o equivalente:

dict((k, v) for k, v in zip(keys, values))

Y esta es una lista de comprensión que se pasa al constructor dict:

dict([(k, v) for k, v in zip(keys, values)])

En los dos primeros casos, se coloca una capa adicional de cálculo no operativo (por lo tanto, innecesario) sobre el zip iterable, y en el caso de la lista por comprensión, se crea innecesariamente una lista adicional. Esperaría que todos ellos tuvieran menos rendimiento, y ciertamente no más.

Revisión de desempeño:

En Python 3.8.2 de 64 bits proporcionado por Nix, en Ubuntu 16.04, ordenado del más rápido al más lento:

>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
0.6695233230129816
>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.6941362579818815
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
0.8782548159942962
>>> 
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.077607496001292
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.1840861019445583

dict(zip(keys, values)) gana incluso con pequeños conjuntos de claves y valores, pero para conjuntos más grandes, las diferencias en el rendimiento serán mayores.

Un comentarista dijo:

min parece una mala manera de comparar el rendimiento. Seguramente mean y/o max serían indicadores mucho más útiles para el uso real.

Usamos min porque estos algoritmos son deterministas. Queremos conocer el rendimiento de los algoritmos en las mejores condiciones posibles.

Si el sistema operativo se bloquea por algún motivo, no tiene nada que ver con lo que estamos tratando de comparar, por lo que debemos excluir ese tipo de resultados de nuestro análisis.

si usáramos meanese tipo de eventos sesgarían mucho nuestros resultados, y si usáramos max solo obtendremos el resultado más extremo, el más probablemente afectado por tal evento.

Un comentarista también dice:

En python 3.6.8, usando valores medios, la comprensión de dict es aún más rápida, aproximadamente un 30 % para estas listas pequeñas. Para listas más grandes (10k números aleatorios), el dict la llamada es un 10% más rápida.

Supongo que queremos decir dict(zip(... con 10k números aleatorios. Eso suena como un caso de uso bastante inusual. Tiene sentido que las llamadas más directas predominen en grandes conjuntos de datos, y no me sorprendería que los bloqueos del sistema operativo dominen dado el tiempo que llevaría ejecutar esa prueba, sesgando aún más sus números. Y si usas mean o max Consideraría que sus resultados no tienen sentido.

Usemos un tamaño más realista en nuestros mejores ejemplos:

import numpy
import timeit
l1 = list(numpy.random.random(100))
l2 = list(numpy.random.random(100))

Y vemos aquí que dict(zip(... de hecho, se ejecuta más rápido para conjuntos de datos más grandes en aproximadamente un 20%.

>>> min(timeit.repeat(lambda: {k: v for k, v in zip(l1, l2)}))
9.698965263989521
>>> min(timeit.repeat(lambda: dict(zip(l1, l2))))
7.9965161079890095

Prueba esto:

>>> import itertools
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> adict = dict(itertools.izip(keys,values))
>>> adict
{'food': 'spam', 'age': 42, 'name': 'Monty'}

En Python 2, también es más económico en el consumo de memoria en comparación con zip.

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')
out = dict(zip(keys, values))

Producción:

{'food': 'spam', 'age': 42, 'name': 'Monty'}

También puede usar comprensiones de diccionario en Python ≥ 2.7:

>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> {k: v for k, v in zip(keys, values)}
{'food': 'spam', 'age': 42, 'name': 'Monty'}

Una forma más natural es usar la comprensión del diccionario.

keys = ('name', 'age', 'food')
values = ('Monty', 42, 'spam')    
dict = {keys[i]: values[i] for i in range(len(keys))}

Si necesita transformar claves o valores antes de crear un diccionario, entonces un generador de expresión puede ser usado. Ejemplo:

>>> adict = dict((str(k), v) for k, v in zip(['a', 1, 'b'], [2, 'c', 3])) 

Echar un vistazo Codifique como un Pythonista: Python idiomático.