Umwandlung von zwei Listen in ein Wörterbuch

Question

Stellen Sie sich vor, dass Sie:

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

Was ist der einfachste Weg, um die folgende Wörterbuch zu produzieren?

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

Answer 1

Wie folgt aus:

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

Voila :-) Der paarweise dict Konstruktor und zip Funktion ist awesomely nützlich: https://docs.python.org/3/library/functions.html#func-dict

Answer 2

Versuchen Sie folgendes:

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

In Python 2, sondern auch sparsamer im Speicherverbrauch im Vergleich zu zip.

Answer 3

  

Stellen Sie sich vor, dass Sie:

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

     

Was ist der einfachste Weg, um die folgende Wörterbuch zu produzieren?

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

Die meisten performant - Python 2.7 und 3, dict Verständnis:

Eine mögliche Verbesserung des dict Konstruktor auf der Verwendung ist die native Syntax eines dict Verständnisses zu verwenden (keine Liste Verständnis, wie andere fälschlicherweise es haben) setzen:

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

In Python 2, zip gibt eine Liste, um zu verhindern, eine unnötige Liste erstellen, verwenden Sie izip statt (aliased können zip reduzieren Code ändert sich, wenn Sie Python bewegen 3).

from itertools import izip as zip

Das ist also nach wie vor:

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

Python 2, ideal für <= 2.6

izip von itertools wird zip in Python 3. izip ist besser als zip für Python 2 (weil es die unnötige Listenerstellung vermeidet) und ideal für 2,6 oder unter:

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

Python 3

In Python 3 zip wird die gleiche Funktion, die im itertools Modul war, so dass ist einfach:

new_dict = dict(zip(keys, values))

Ein dict Verständnis wäre performant aber (Leistungsüberprüfung am Ende dieser Antwort sehen).

Ergebnis für alle Fälle:

In allen Fällen gilt:

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

Erklärung:

Wenn wir die Hilfe auf dict schauen wir sehen, dass es eine Vielzahl von Formen der Argumente nimmt:

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

Der optimale Ansatz ist es, eine iterable zu verwenden, während unnötige Datenstrukturen vermeiden zu schaffen. In Python 2, zip bedeutet eine unnötige Liste:

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

In Python 3, das äquivalent wäre:

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

und Python 3 zip nur schafft ein iterable Objekt:

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

Da wir unnötige Datenstrukturen zu schaffen vermeiden wollen, wir wollen in der Regel Python 2 ist zip zu vermeiden (da es eine unnötige Liste erstellt).

Weniger performant Alternativen:

Dies ist ein Generator zum Ausdruck, dict Konstruktor übergeben werden:

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

oder äquivalent:

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

Und das ist eine Liste Verständnis auf das dict-Konstruktor übergeben werden:

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

In den ersten beiden Fällen wird eine zusätzliche Schicht von nicht-operative (somit nicht erforderlich) Berechnung wird über die zip iterable platziert, und im Fall der Liste Verständnis, eine zusätzliche Liste unnötig erstellt. Ich würde alle von ihnen erwartet, dass weniger performant, und schon gar nicht mehr lala.

Leistungsüberprüfung:

In 64-Bit-Python 3.4.3 auf Ubuntu 14.04, bestellt vom schnellsten zum langsamsten:

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

Answer 4

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

Answer 5

Sie können auch Wörterbuch Comprehensions in Python ≥ 2.7 verwenden

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

Answer 6

Eine natürliche Art und Weise ist Wörterbuch Verständnis verwenden

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

Answer 7

Wenn Sie Schlüssel oder Werte zu transformieren, bevor ein Wörterbuch dann einem Generator Ausdruck zu schaffen könnte verwendet werden. Beispiel:

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

Hier finden Sie aktuelle -Code wie ein Pythonista: Idiomatic Python .

Answer 8

mit Python 3.x, geht für dict Comprehensions

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

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

print(dic)

Mehr dict Comprehensions hier , ist ein Beispiel gibt:

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

Answer 9

Für diejenigen, die einfachen Code benötigen und sind nicht vertraut mit zip:

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

Dies kann durch eine Codezeile erfolgen:

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

Answer 10

• 2018.04.18

Die beste Lösung ist nach wie vor:

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

Transponierung es:

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

Answer 11

Sie können diese verwenden, unter Code:

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

Aber stellen Sie sicher, dass Länge der Listen Länge same.if werden nicht same.then zip Funktion turncate je länger ein.

Answer 12

Hier ist auch ein Beispiel einer Liste Wert des Hinzufügens in Sie Dictionary

list1 = ["Name", "Surname", "Age"]
list2 = [["Cyd", "JEDD", "JESS"], ["DEY", "AUDIJE", "PONGARON"], [21, 32, 47]]
dic = dict(zip(list1, list2))
print(dic)

immer sicherstellen, dass die Ihr "Key" (list1) ist immer im ersten Parameter.

{'Name': ['Cyd', 'JEDD', 'JESS'], 'Surname': ['DEY', 'AUDIJE', 'PONGARON'], 'Age': [21, 32, 47]}

Answer 13

Methode ohne Zip-Funktion

l1 = [1,2,3,4,5]
l2 = ['a','b','c','d','e']
d1 = {}
for l1_ in l1:
    for l2_ in l2:
        d1[l1_] = l2_
        l2.remove(l2_)
        break  

print (d1)


{1: 'd', 2: 'b', 3: 'e', 4: 'a', 5: 'c'}