Question Convertir deux listes dans un dictionnaire en Python


Imaginez que vous avez:

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

Quel est le moyen le plus simple de produire le dictionnaire suivant?

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

748
2017-10-16 19:05


origine


Réponses:


Comme ça:

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

Voila :-) Les deux dict constructeur et zip La fonction est incroyablement utile: https://docs.python.org/3/library/functions.html#func-dict


1384
2017-10-16 19:09



Essaye ça:

>>> 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, il est également plus économique en consommation de mémoire par rapport à zip.


110
2017-10-16 19:16



Imaginez que vous avez:

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

Quel est le moyen le plus simple de produire le dictionnaire suivant?

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

Les plus performants - Python 2.7 et 3, dictent la compréhension:

Une amélioration possible de l'utilisation du constructeur de dict est d'utiliser la syntaxe native d'une compréhension de dict (pas une compréhension de liste, comme d'autres l'ont dit par erreur):

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

En Python 2, zip renvoie une liste, pour éviter de créer une liste inutile, utilisez izip à la place (aliaser en zip peut réduire les changements de code lorsque vous passez à Python 3).

from itertools import izip as zip

Alors c'est encore:

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

Python 2, idéal pour <= 2.6

izip de itertools devient zip en Python 3. izip est mieux que zip pour Python 2 (car il évite la création de liste inutile), et idéal pour 2.6 ou ci-dessous:

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

Python 3

En Python 3, zip devient la même fonction qui était dans le itertools module, c'est simplement:

new_dict = dict(zip(keys, values))

Une compréhension dictée serait plus performante cependant (voir la revue de performance à la fin de cette réponse).

Résultat pour tous les cas:

Dans tous les cas:

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

Explication:

Si nous regardons l'aide sur dict nous voyons qu'il faut une variété de formes d'arguments:

>>> 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)

L'approche optimale consiste à utiliser un itérable tout en évitant de créer des structures de données inutiles. En Python 2, zip crée une liste inutile:

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

En Python 3, l'équivalent serait:

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

et Python 3 zip crée simplement un objet itérable:

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

Puisque nous voulons éviter de créer des structures de données inutiles, nous voulons généralement éviter Python 2 zip (puisqu'il crée une liste inutile).

Alternatives moins performantes:

C'est une expression de générateur passée au constructeur de dict:

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

ou équivalent:

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

Et ceci est une compréhension de liste transmise au constructeur de dict:

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

Dans les deux premiers cas, une couche supplémentaire de calcul non-opérationnel (donc non-nécessaire) est placée sur la fermeture-éclair itérable, et dans le cas de la compréhension de la liste, une liste supplémentaire est créée inutilement. Je m'attendrais à ce que tous soient moins performants, et certainement pas plus ...

Examen du rendement:

En Python 3.4.3 64 bits, sous Ubuntu 14.04, du plus rapide au plus lent:

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



Vous pouvez également utiliser les définitions de dictionnaire 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 vous devez transformer des clés ou des valeurs avant de créer un dictionnaire, un expression du générateur peut être utilisé. Exemple:

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

Regarde Code comme un Pythonista: Python idiomatique.


13
2017-10-16 20:45



Un moyen plus naturel consiste à utiliser la compréhension du dictionnaire

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



avec Python 3.x, va pour les dictées

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

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

print(dic)

Plus sur dict des compréhensions ici, un exemple est là:

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

8
2018-05-25 13:47