Pregunta Convierta dos listas en un diccionario en Python


Imagina que tienes:

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

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

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

748
2017-10-16 19:05


origen


Respuestas:


Me gusta esto:

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

Voila :-) El pairwise dict constructor y zip la función es tremendamente útil: https://docs.python.org/3/library/functions.html#func-dict


1384
2017-10-16 19:09



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.


110
2017-10-16 19:16



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 - Python 2.7 y 3, comprensión dict:

Una posible mejora en el uso del constructor dict es usar la sintaxis nativa de una comprensión dict (no una lista de comprensión, como otros lo han dicho erróneamente):

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

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

from itertools import izip as zip

Entonces eso es así:

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

Python 2, ideal para <= 2.6

izip de itertools se convierte zip en Python 3. izip es mejor que zip para Python 2 (porque evita la creación innecesaria de listas), y es ideal para 2.6 o menos:

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

Python 3

En Python 3, zip se convierte en la misma función que estaba en el itertools módulo, entonces eso es simplemente:

new_dict = dict(zip(keys, values))

Sin embargo, una comprensión dict sería más eficiente (ver revisión de desempeño al final de esta respuesta).

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 evitando la creación de 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's zip simplemente crea un objeto iterable:

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

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

Alternativas menos efectivas:

Esta es una expresión del generador 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 primeros dos casos, se coloca una capa adicional de computación no operativa (por lo tanto innecesaria) sobre el archivo comprimible, y en el caso de la comprensión de la lista, se crea innecesariamente una lista adicional. Esperaría que todos ellos fueran menos eficientes, y ciertamente no más ... así.

Revisión de rendimiento:

En 64 bit Python 3.4.3, en Ubuntu 14.04, ordenado de más rápido a más lento:

>>> min(timeit.repeat(lambda: {k: v for k, v in zip(keys, values)}))
0.7836067057214677
>>> min(timeit.repeat(lambda: dict(zip(keys, values))))
1.0321204089559615
>>> min(timeit.repeat(lambda: {keys[i]: values[i] for i in range(len(keys))}))
1.0714934510178864
>>> min(timeit.repeat(lambda: dict([(k, v) for k, v in zip(keys, values)])))
1.6110592018812895
>>> min(timeit.repeat(lambda: dict((k, v) for k, v in zip(keys, values))))
1.7361853648908436

85
2017-11-16 13:54



>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}

29
2017-10-16 19:09



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'}

26
2018-06-10 20:03



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

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

Echar un vistazo Código como un Pythonista: Python Idiomático.


13
2017-10-16 20:45



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

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

9
2017-11-16 05:03



con Python 3.x, va para las comprensiones dict

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

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

print(dic)

Más en dict comprensión aquí, un ejemplo está allí:

>>> print {i : chr(65+i) for i in range(4)}
    {0 : 'A', 1 : 'B', 2 : 'C', 3 : 'D'}

8
2018-05-25 13:47



Para aquellos que necesitan un código simple y no están familiarizados con zip:

List1 = ['This', 'is', 'a', 'list']
List2 = ['Put', 'this', 'into', 'dictionary']

Esto se puede hacer con una línea de código:

d = {List1[n]: List2[n] for n in range(len(List1))}

5
2018-03-29 19:13



  • 2018-04-18

La mejor solución es aún:

In [92]: keys = ('name', 'age', 'food')
...: values = ('Monty', 42, 'spam')
...: 

In [93]: dt = dict(zip(keys, values))
In [94]: dt
Out[94]: {'age': 42, 'food': 'spam', 'name': 'Monty'}

Tranponerlo:

    lst = [('name', 'Monty'), ('age', 42), ('food', 'spam')]
    keys, values = zip(*lst)
    In [101]: keys
    Out[101]: ('name', 'age', 'food')
    In [102]: values
    Out[102]: ('Monty', 42, 'spam')

2
2018-04-18 02:41



puedes usar este código a continuación:

dict(zip(['name', 'age', 'food'], ['Monty', 42, 'spam']))

Pero asegúrate de que la longitud de las listas sea la misma. Si la longitud no es la misma, la función zip convierte la más larga.


1
2017-11-16 13:36