Ich mag die Python-Listenverständnis-Syntax.

Kann damit auch Wörterbücher erstellt werden? Zum Beispiel durch Iteration über Schlüssel- und Wertepaare:

mydict = {(k,v) for (k,v) in blah blah blah}  # doesn't work

Ab Python 2.7 und 3 sollten Sie nur die Syntax des Diktatverständnisses verwenden :

{key: value for (key, value) in iterable}

In Python 2.6 und früheren dictVersionen kann das integrierte Element eine Iteration von Schlüssel / Wert-Paaren empfangen, sodass Sie ihm ein Listenverständnis oder einen Generatorausdruck übergeben können. Zum Beispiel:

dict((key, func(key)) for key in keys)

Wenn Sie jedoch bereits iterierbare Schlüssel und / oder Werte haben, müssen Sie überhaupt kein Verständnis verwenden - am einfachsten rufen Sie einfach die dicteingebauten direkt auf:

# consumed from any iterable yielding pairs of keys/vals
dict(pairs)

# "zipped" from two separate iterables of keys/vals
dict(zip(list_of_keys, list_of_values))

In Python 3 und Python 2.7+ sieht das Wörterbuchverständnis wie folgt aus:

d = {k:v for k, v in iterable}

Informationen zu Python 2.6 oder früher finden Sie in der Antwort von fortran .

Tatsächlich müssen Sie nicht einmal über das Iterable iterieren, wenn es bereits eine Art Mapping umfasst. Der Diktatkonstruktor erledigt dies freundlicherweise für Sie:

>>> ts = [(1, 2), (3, 4), (5, 6)]
>>> dict(ts)
{1: 2, 3: 4, 5: 6}
>>> gen = ((i, i+1) for i in range(1, 6, 2))
>>> gen
<generator object <genexpr> at 0xb7201c5c>
>>> dict(gen)
{1: 2, 3: 4, 5: 6}

In Python 2.7 sieht es so aus:

>>> list1, list2 = ['a', 'b', 'c'], [1,2,3]
>>> dict( zip( list1, list2))
{'a': 1, 'c': 3, 'b': 2}

Reiß sie ab !

Erstellen Sie in Python ein Wörterbuch mit Listenverständnis

Ich mag die Python-Listenverständnis-Syntax.

Kann damit auch Wörterbücher erstellt werden? Zum Beispiel durch Iteration über Schlüssel- und Wertepaare:

mydict = {(k,v) for (k,v) in blah blah blah}

Sie suchen nach dem Ausdruck "Diktatverständnis" - es ist eigentlich:

mydict = {k: v for k, v in iterable}

Angenommen, es blah blah blahhandelt sich um eine Iteration von zwei Tupeln - Sie sind so nah dran. Lassen Sie uns einige "Blahs" wie diese erstellen:

blahs = [('blah0', 'blah'), ('blah1', 'blah'), ('blah2', 'blah'), ('blah3', 'blah')]

Diktatverständnissyntax:

Die Syntax hier ist nun der Zuordnungsteil. Was dies zu einem dictVerständnis anstelle eines setVerständnisses macht (was Ihr Pseudocode annähert), ist der Doppelpunkt :wie folgt :

mydict = {k: v for k, v in blahs}

Und wir sehen, dass es funktioniert hat und die Einfügereihenfolge ab Python 3.7 beibehalten sollte:

>>> mydict
{'blah0': 'blah', 'blah1': 'blah', 'blah2': 'blah', 'blah3': 'blah'}

In Python 2 und bis 3.6 war die Reihenfolge nicht garantiert:

>>> mydict
{'blah0': 'blah', 'blah1': 'blah', 'blah3': 'blah', 'blah2': 'blah'}

Hinzufügen eines Filters:

Alle Verständnisse enthalten eine Zuordnungskomponente und eine Filterkomponente, die Sie mit beliebigen Ausdrücken versehen können.

So können Sie am Ende ein Filterteil hinzufügen:

>>> mydict = {k: v for k, v in blahs if not int(k[-1]) % 2}
>>> mydict
{'blah0': 'blah', 'blah2': 'blah'}

Hier testen wir nur, ob das letzte Zeichen durch 2 teilbar ist, um Daten herauszufiltern, bevor die Schlüssel und Werte zugeordnet werden.

Python-Version <2.7 _{^{(RIP, 3. Juli 2010 - 31. Dezember 2019)}} , gehen Sie wie folgt vor:

d = dict((i,True) for i in [1,2,3])

Python-Version> = 2.7, gehen Sie wie folgt vor:

d = {i: True for i in [1,2,3]}

So fügen Sie die Antwort von @ fortran hinzu, wenn Sie eine Liste von Schlüsseln key_listsowie eine Liste von Werten durchlaufen möchten value_list:

d = dict((key, value) for (key, value) in zip(key_list, value_list))

oder

d = {(key, value) for (key, value) in zip(key_list, value_list)}

Hier ist ein weiteres Beispiel für die Erstellung eines Wörterbuchs mit Diktatverständnis:

Was ich hier tun möchte, ist ein Alphabet-Wörterbuch zu erstellen, in dem jedes Paar; ist der englische Buchstabe und seine entsprechende Position im englischen Alphabet

>>> import string
>>> dict1 = {value: (int(key) + 1) for key, value in 
enumerate(list(string.ascii_lowercase))}
>>> dict1
{'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4, 'g': 7, 'f': 6, 'i': 9, 'h': 8, 
'k': 11, 'j': 10, 'm': 13, 'l': 12, 'o': 15, 'n': 14, 'q': 17, 'p': 16, 's': 
19, 'r': 18, 'u': 21, 't': 20, 'w': 23, 'v': 22, 'y': 25, 'x': 24, 'z': 26}
>>> 

Beachten Sie die Verwendung von enumerate hier, um eine Liste der Alphabete und ihrer Indizes in der Liste abzurufen und die Alphabete und Indizes auszutauschen, um das Schlüsselwertpaar für das Wörterbuch zu generieren

Ich hoffe, es gibt Ihnen eine gute Vorstellung von Dictionary Comp und ermutigt Sie, es häufiger zu verwenden, um Ihren Code kompakt zu machen

Versuche dies,

def get_dic_from_two_lists(keys, values):
    return { keys[i] : values[i] for i in range(len(keys)) }

Angenommen, wir haben zwei Listen Land und Hauptstadt

country = ['India', 'Pakistan', 'China']
capital = ['New Delhi', 'Islamabad', 'Beijing']

Erstellen Sie dann ein Wörterbuch aus den beiden Listen:

print get_dic_from_two_lists(country, capital)

Die Ausgabe ist wie folgt:

{'Pakistan': 'Islamabad', 'China': 'Beijing', 'India': 'New Delhi'}

>>> {k: v**3 for (k, v) in zip(string.ascii_lowercase, range(26))}

Python unterstützt das Verständnis von Diktaten, mit denen Sie die Erstellung von Wörterbüchern zur Laufzeit mithilfe einer ähnlich präzisen Syntax ausdrücken können.

Ein Wörterbuchverständnis hat die Form {Schlüssel: Wert für (Schlüssel, Wert) in iterierbar}. Diese Syntax wurde in Python 3 eingeführt und bis Python 2.7 zurückportiert, sodass Sie sie unabhängig von der installierten Python-Version verwenden können sollten.

Ein kanonisches Beispiel besteht darin, zwei Listen zu erstellen und ein Wörterbuch zu erstellen, in dem das Element an jeder Position in der ersten Liste zu einem Schlüssel und das Element an der entsprechenden Position in der zweiten Liste zum Wert wird.

Die in diesem Verständnis verwendete Zip-Funktion gibt einen Iterator von Tupeln zurück, wobei jedes Element im Tupel in jeder der Eingabe-Iterables von derselben Position übernommen wird. Im obigen Beispiel enthält der zurückgegebene Iterator die Tupel ("a", 1), ("b", 2) usw.

Ausgabe:

{'i': 512, 'e': 64, 'o': 2744, 'h': 343, 'l': 1331, 's': 5832, 'b': 1, 'w': 10648, ' c ': 8,' x ': 12167,' y ': 13824,' t ': 6859,' p ': 3375,' d ': 27,' j ': 729,' a ': 0,' z ' : 15625, 'f': 125, 'q': 4096, 'u': 8000, 'n': 2197, 'm': 1728, 'r': 4913, 'k': 1000, 'g': 216 , 'v': 9261}

Dieser Code erstellt ein Wörterbuch mit Listenverständnis für mehrere Listen mit unterschiedlichen Werten, für die verwendet werden kann pd.DataFrame()

#Multiple lists 
model=['A', 'B', 'C', 'D']
launched=[1983,1984,1984,1984]
discontinued=[1986, 1985, 1984, 1986]

#Dictionary with list comprehension
keys=['model','launched','discontinued']
vals=[model, launched,discontinued]
data = {key:vals[n] for n, key in enumerate(keys)}

enumeratewird an übergeben n, valsum jedes keymit seiner Liste abzugleichen

Nur um ein anderes Beispiel zu nennen. Stellen Sie sich vor, Sie haben die folgende Liste:

nums = [4,2,2,1,3]

und Sie möchten daraus ein Diktat machen, bei dem der Schlüssel der Index und der Wert das Element in der Liste ist. Sie können dies mit der folgenden Codezeile tun:

{index:nums[index] for index in range(0,len(nums))}

Sie können für jedes Paar ein neues Diktat erstellen und es mit dem vorherigen Diktat zusammenführen:

reduce(lambda p, q: {**p, **{q[0]: q[1]}}, bla bla bla, {})

Offensichtlich erfordert dieser Ansatz reducevon functools.