Ik hou van de syntaxis voor het begrijpen van de Python-lijst.

Kan het ook worden gebruikt om woordenboeken te maken? Door bijvoorbeeld paren van sleutels en waarden te herhalen:

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

Antwoord 1, autoriteit 100%

Gebruik een dictaatbegrip:

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

Opmerking: dit is voor Python 3.x (en 2.7 en hoger). Vroeger in Python 2.6 en eerder, kon de ingebouwde dicteen iterabel aantal sleutel/waarde-paren ontvangen, zodat je het een lijstbegrip of generator-expressie kunt doorgeven. Bijvoorbeeld:

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

In eenvoudige gevallen heb je helemaal geen begrip nodig…

Maar als je al iterable(s) van sleutels en/of waarden hebt, roep dan het ingebouwde dictrechtstreeks aan:

1) consumed from any iterable yielding pairs of keys/vals
dict(pairs)
2) "zip'ped" from two separate iterables of keys/vals
dict(zip(list_of_keys, list_of_values))

Antwoord 2, autoriteit 12%

In Python 3 en Python 2.7+ zien woordenboekbegrippen er als volgt uit:

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

Voor Python 2.6 of eerder, zie het antwoord van fortran.

Antwoord 3, autoriteit 3%

In feite hoeft u niet eens over de iezak te itereren als het al een soort mapping begrijpt, de DICT-constructor die het genadig voor u doet:

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

Antwoord 4, Autoriteit 2%

in Python 2.7, het gaat als:

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

rits ze !

Antwoord 5, Autoriteit 2%

Maak een woordenboek met lijstbegrip in Python

Ik hou van de Begrip Syntaxis van Python List.

Kan het worden gebruikt om woordenboeken te maken? Bijvoorbeeld door iterating
Over paren sleutels en waarden:

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

U zoekt naar de uitdrukking “dict Begrip” – het is eigenlijk:

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

Veronderstellend blah blah blahis een tiselijk van twee-tuples – je bent zo dichtbij. Laten we een aantal “blahs” maken:

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

DICT Gevuldige Syntaxis:

De syntaxis hier is het toewijzingsgedeelte. Wat dit een dictbegrip maakt in plaats van een setbegrip (wat uw pseudo-code benadert) is de dubbele punt, :zoals hieronder:

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

En we zien dat het werkte en de invoegvolgorde zou moeten behouden vanaf Python 3.7:

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

In Python 2 en tot 3.6 was de bestelling niet gegarandeerd:

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

Een filter toevoegen:

Alle comprehensies bevatten een mapping-component en een filtercomponent die u kunt voorzien van willekeurige uitdrukkingen.

Je kunt dus een filtergedeelte aan het einde toevoegen:

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

Hier testen we alleen of het laatste teken deelbaar is door 2 om gegevens uit te filteren voordat de sleutels en waarden worden toegewezen.

Antwoord 6

Python-versie >= 2.7, doe het onderstaande:

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

Python-versie < 2.7_{^{(RIP, 3 juli 2010 – 31 december 2019)}}, doe het onderstaande:

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

Antwoord 7

Om toe te voegen aan @fortran’s antwoord, als je een lijst met sleutels key_listwilt herhalen, evenals een lijst met waarden value_list:

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

of

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

Antwoord 8

Hier is nog een voorbeeld van het maken van woordenboeken met behulp van dictumbegrip:

Wat ik hier probeer te doen, is een alfabetisch woordenboek maken waarin elk paar; is de engelse letter en de bijbehorende positie in het engelse alfabet

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

Let op het gebruik van enumerate hier om een lijst van alfabetten en hun indexen in de lijst te krijgen en het verwisselen van de alfabetten en indexen om het sleutelwaardepaar voor woordenboek te genereren

Ik hoop dat het je een goed idee geeft van woordenboekcom en je aanmoedigt om het vaker te gebruiken om je code compact te maken

Antwoord 9

Probeer dit,

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

Stel dat we twee lijsten hebben: landen hoofdstad

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

Maak vervolgens een woordenboek van de twee lijsten:

print get_dic_from_two_lists(country, capital)

De uitvoer is als volgt,

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

Antwoord 10

Deze code maakt een woordenboek met behulp van lijstbegrip voor meerdere lijsten met verschillende waarden die kunnen worden gebruikt voor 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)}
#Convert dict to dataframe
df=pd.DataFrame(data)
display(df)

enumerategeeft ndoor aan valsom elke keyte matchen met zijn lijst

Antwoord 11

Om nog een voorbeeld te noemen. Stel je voor dat je de volgende lijst hebt:

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

en je wilt er een dictaat van maken waarbij de sleutel de index is en waarde het element in de lijst. U kunt dit doen met de volgende regel code:

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

Antwoord 12

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

Python ondersteunt het begrip van dictaten, waarmee u het maken van woordenboeken tijdens runtime kunt uitdrukken met een even beknopte syntaxis.

Een woordenboekbegrip heeft de vorm {key: value for (key, value) in iterable}. Deze syntaxis is geïntroduceerd in Python 3 en gebackporteerd tot Python 2.7, dus je zou het moeten kunnen gebruiken, ongeacht welke versie van Python je hebt geïnstalleerd.

Een canoniek voorbeeld is het nemen van twee lijsten en het maken van een woordenboek waarbij het item op elke positie in de eerste lijst een sleutel wordt en het item op de corresponderende positie in de tweede lijst de waarde.

De zip-functie die binnen dit begrip wordt gebruikt, retourneert een iterator van tupels, waarbij elk element in de tupel vanuit dezelfde positie in elk van de invoer-iterables wordt genomen. In het bovenstaande voorbeeld bevat de geretourneerde iterator de tuples (“a”, 1), (“b”, 2), enz.

Uitvoer:

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

Antwoord 13

Ja, dat is mogelijk. In Python kan Begrip worden gebruikt in Lijst, Set, Woordenboek, enz.
Je kunt het op deze manier schrijven

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

Nog een gedetailleerd voorbeeld van woordenboekbegrip met de voorwaardelijke instructie en lus:

parents = [father, mother]
parents = {parent:1 - P["mutation"] if parent in two_genes else 0.5 if parent in one_gene else P["mutation"] for parent in parents}

Antwoord 14

Je kunt voor elk paar een nieuw dictaat maken en dit samenvoegen met het vorige dictaat:

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

Uiteraard vereist deze aanpak reducevan functools.