Umwandlung von zwei Listen in ein Wörterbuch
-
03-07-2019 - |
Frage
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'}
Lösung
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
Andere Tipps
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
.
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
>>> keys = ('name', 'age', 'food')
>>> values = ('Monty', 42, 'spam')
>>> dict(zip(keys, values))
{'food': 'spam', 'age': 42, 'name': 'Monty'}
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'}
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))}
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 .
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'}
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))}
- 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')
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.
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]}
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'}