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 dict
een 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 dict
rechtstreeks 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 blah
is 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 dict
begrip maakt in plaats van een set
begrip (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_list
wilt 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)
enumerate
geeft n
door aan vals
om elke key
te 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 reduce
van functools
.