Is het mogelijk om een woordenboekbegrip in Python te maken (voor de toetsen)?
Zonder lijstbegrippen kun je zoiets als dit gebruiken:
l = []
for n in range(1, 11):
l.append(n)
We kunnen dit inkorten tot een lijstbegrip: l = [n for n in range(1, 11)].
Stel echter dat ik de sleutels van een woordenboek op dezelfde waarde wil instellen.
Ik kan doen:
d = {}
for n in range(1, 11):
d[n] = True # same value for each
Ik heb dit geprobeerd:
d = {}
d[i for i in range(1, 11)] = True
Ik krijg echter een SyntaxError op de for.
Bovendien (ik heb dit onderdeel niet nodig, maar ik vraag het me gewoon af), kun je de sleutels van een woordenboek instellen op een aantal verschillende waarden, zoals deze:
d = {}
for n in range(1, 11):
d[n] = n
Is dit mogelijk met een woordenboekbegrip?
d = {}
d[i for i in range(1, 11)] = [x for x in range(1, 11)]
Dit geeft ook een SyntaxError op de for.
Antwoord 1, autoriteit 100%
Er zijn woordenboekbegrippen in Python 2.7+, maar die zijn er niet werkt niet helemaal zoals je probeert. Net als bij het begrijpen van een lijst, creëren ze een nieuw woordenboek; je kunt ze niet gebruiken om sleutels toe te voegen aan een bestaand woordenboek. U moet ook de sleutels en waarden opgeven, hoewel u natuurlijk een dummy-waarde kunt opgeven als u dat wilt.
>>> d = {n: n**2 for n in range(5)}
>>> print d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Als je ze allemaal op True wilt zetten:
>>> d = {n: True for n in range(5)}
>>> print d
{0: True, 1: True, 2: True, 3: True, 4: True}
Waar je om lijkt te vragen is een manier om meerdere sleutels tegelijk in te stellen op een bestaand woordenboek. Daar is geen directe snelkoppeling voor. Je kunt een lus maken zoals je al hebt laten zien, of je kunt een woordenboekbegrip gebruiken om een nieuw dictaat te maken met de nieuwe waarden, en dan oldDict.update(newDict) doen om de nieuwe waarden samen te voegen met de oude dictaat.
Antwoord 2, autoriteit 27%
U kunt de dict.fromkeys gebruiken klassenmethode …
>>> dict.fromkeys(range(5), True)
{0: True, 1: True, 2: True, 3: True, 4: True}
Dit is de snelste manier om een woordenboek te maken waarin alle sleutels dezelfde waarde hebben.
Maar doe niet gebruik dit met veranderlijke objecten:
d = dict.fromkeys(range(5), [])
# {0: [], 1: [], 2: [], 3: [], 4: []}
d[1].append(2)
# {0: [2], 1: [2], 2: [2], 3: [2], 4: [2]} !!!
Als u niet echt alle sleutels hoeft te initialiseren, kan een defaultdict ook handig zijn:
from collections import defaultdict
d = defaultdict(True)
Om het tweede deel te beantwoorden, is een dict-begrip precies wat je nodig hebt:
{k: k for k in range(10)}
U zou dit waarschijnlijk niet moeten doen, maar u kunt ook een subklasse van dict maken die enigszins werkt als een defaultdict als u __missing__ overschrijft :
>>> class KeyDict(dict):
... def __missing__(self, key):
... #self[key] = key # Maybe add this also?
... return key
...
>>> d = KeyDict()
>>> d[1]
1
>>> d[2]
2
>>> d[3]
3
>>> print(d)
{}
Antwoord 3, autoriteit 5%
>>> {i:i for i in range(1, 11)}
{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10}
Antwoord 4, autoriteit 5%
Ik vind de opmerking van @mgilson erg leuk, want als je twee iterables hebt, één die overeenkomt met de sleutels en de andere met de waarden, kun je ook het volgende doen.
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
geven
d = {‘a’: 1, ‘b’: 2, ‘c’: 3}
Antwoord 5, autoriteit 2%
Beschouw dit voorbeeld van het tellen van woorden in een lijst met behulp van woordenboekbegrip
my_list = ['hello', 'hi', 'hello', 'today', 'morning', 'again', 'hello']
my_dict = {k:my_list.count(k) for k in my_list}
print(my_dict)
En het resultaat is
{'again': 1, 'hi': 1, 'hello': 3, 'today': 1, 'morning': 1}
Antwoord 6, autoriteit 2%
Gebruik dict() op een lijst met tuples, met deze oplossing kun je willekeurige waarden in elke lijst hebben, zolang ze maar even lang zijn
i_s = range(1, 11)
x_s = range(1, 11)
# x_s = range(11, 1, -1) # Also works
d = dict([(i_s[index], x_s[index], ) for index in range(len(i_s))])
Antwoord 7, autoriteit 2%
Het belangrijkste doel van het begrijpen van een lijst is om een nieuwe lijst te maken op basis van een andere zonder de oorspronkelijke lijst te wijzigen of te vernietigen.
In plaats van te schrijven
l = []
for n in range(1, 11):
l.append(n)
of
l = [n for n in range(1, 11)]
je mag alleen schrijven
l = range(1, 11)
In de twee bovenste codeblokken maakt u een nieuwe lijst, doorloopt u deze en geeft u elk element terug. Het is gewoon een dure manier om een lijstkopie te maken.
Als je een nieuw woordenboek wilt krijgen met alle sleutels op dezelfde waarde ingesteld op basis van een ander dictaat, doe je dit:
old_dict = {'a': 1, 'c': 3, 'b': 2}
new_dict = { key:'your value here' for key in old_dict.keys()}
U ontvangt een SyntaxError omdat wanneer u schrijft
d = {}
d[i for i in range(1, 11)] = True
je zegt eigenlijk: “Stel mijn sleutel ‘i for i in range(1, 11)’ in op True” en “i for i in range (1, 11)” is geen geldige sleutel, het is slechts een syntax error. Als dictaten ondersteunde lijsten als sleutels, zou je zoiets doen als
d[[i for i in range(1, 11)]] = True
en niet
d[i for i in range(1, 11)] = True
maar lijsten zijn niet hashbaar, dus je kunt ze niet als dicteertoetsen gebruiken.
Antwoord 8
Een woordenboekbegrip lijkt veel op een begrip van de lijst, maar we krijgen een woordenboek aan het einde ervan, dus we moeten het toewijzen van sleutelwaardeparen in plaats van alleen waarden.
Stel dat we een lijst met gebruikers hebben, waarbij elke gebruikersinformatie in een tuple is opgeslagen. We hebben dus een lijst met vier gebruikers-tupels. Daarin hebben ze een ID, een uniek identificatienummer voor elke gebruiker, een gebruikersnaam en een wachtwoord.
Dus we willen een toewijzing van gebruikersnamen aan gebruikersinformatie maken.
Dit is iets dat je heel vaak zult doen, vooral als je iets doet als webapplicaties en dergelijke.
users = [
(0, "Bob", "password"),
(1, "code", "python"),
(2, "Stack", "overflow"),
(3, "username", "1234"),
]
username_mapping = {user[1]: user for user in users}
userid_mapping = {user[0]: user for user in users}
print(username_mapping)
"""
Why can this be helpful?
Well, imagine you know a user's username,and you want to get their information out.
You just access, let's say, "Bob," in your username_mapping, and you've got the information out.
"""
print(username_mapping["Bob"]) # (0, "Bob", "password")
# -- Can be useful to log in for example --
username_input = input("Enter your username: ")
password_input = input("Enter your password: ")
_, username, password = username_mapping[username_input]
if password_input == password:
print("Your details are correct!")
else:
print("Your details are incorrect.")
Dit is dus een voorbeeld van het uitvoeren van een soort login met deze structuur hier, dit woordenboekbegrip.
Dit is erg handig omdat het je bespaart dat je hier nog een for-lus hoeft te doen, om er zeker van te zijn dat je de juiste gebruikersnaam gebruikt voor hun invoer.
Antwoord 9
je kunt zo’n lijst niet hashen.
probeer dit in plaats daarvan, het gebruikt tuples
d[tuple([i for i in range(1,11)])] = True