Begrip van Woordenboeken in Python 3

Introductie

Het woordenboek is het ingebouwde mapping type van Python. Woordenboeken koppelen sleutels aan w aarden en deze sleutel-waarde paren bieden een handige manier om gegevens in Python op te slaan.

Meestal worden ze gebruikt om gegevens bij te houden die gerelateerd zijn, zoals de informatie in een ID of een gebruikersprofiel, woordenboeken worden geconstrueerd met accolades aan beide zijden { }.

A dictionary looks like this:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

Naast de accolades zijn er ook dubbele punten (:) in het hele woordenboek.

De woorden links van de dubbele punten zijn de sleutels. Sleutels kunnen bestaan uit elk onveranderlijk gegevenstype. De sleutels in het bovenstaande woordenboek zijn:

• 'gebruikersnaam'
• 'online'
• 'volgers'

Elk van de sleutels in het bovenstaande voorbeeld zijn tekenreeks waarden.

De woorden rechts van de dubbele punten zijn de waarden. Waarden kunnen bestaan uit elk gegevenstype. De waarden in het bovenstaande woordenboek zijn:

• 'sammy-shark'
• True
• 987

Elk van deze waarden is ofwel een tekenreeks, Boolean of geheel getal.

Laten we het woordenboek sammy afdrukken:

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': True}

Kijkend naar de output, kan de volgorde van de sleutel-waardeparen zijn verschoven. In Python-versie 3.5 en eerder is het gegevenstype van het woordenboek ongeordend. Echter, in Python-versie 3.6 en later, blijft het gegevenstype van het woordenboek geordend. Ongeacht of het woordenboek geordend is of niet, de sleutel-waardeparen blijven intact, waardoor we toegang hebben tot gegevens op basis van hun relationele betekenis.

Vereisten

U moet Python 3 geïnstalleerd hebben en een programmeeromgeving hebben opgezet op uw computer of server. Als u nog geen programmeeromgeving heeft opgezet, kunt u verwijzen naar de installatie- en instelgidsen voor een lokale programmeeromgeving of voor een programmeeromgeving op uw server die geschikt is voor uw besturingssysteem (Ubuntu, CentOS, Debian, enz.).

Toegang tot Woordenboekelementen

We kunnen de waarden van een woordenboek oproepen door te verwijzen naar de bijbehorende sleutels.

Toegang tot Gegevenselementen met Sleutels

Omdat woordenboeken sleutel-waardeparen bieden voor het opslaan van gegevens, kunnen ze belangrijke elementen zijn in uw Python-programma.

Als we de gebruikersnaam van Sammy willen isoleren, kunnen we dat doen door sammy['gebruikersnaam'] aan te roepen. Laten we dat afdrukken:

print(sammy['username'])

Output
sammy-shark

Woordenboeken gedragen zich als een database in die zin dat in plaats van een geheel getal te noemen om een bepaalde indexwaarde te krijgen zoals je zou doen met een lijst, je een waarde toewijst aan een sleutel en die sleutel kunt noemen om de bijbehorende waarde te krijgen.

Door de sleutel 'gebruikersnaam' aan te roepen, ontvangen we de waarde van die sleutel, wat 'sammy-shark' is.

De overgebleven waarden in het woordenboek sammy kunnen op dezelfde manier worden opgeroepen met hetzelfde formaat:

sammy['followers']
# Geeft 987 terug

sammy['online']
# Geeft True terug

Door gebruik te maken van de sleutel-waardeparen van woordenboeken kunnen we sleutels verwijzen om waarden op te halen.

Het gebruik van methoden om elementen te benaderen

Naast het gebruik van sleutels om waarden te benaderen, kunnen we ook werken met enkele ingebouwde methoden:

• dict.keys() isoleert sleutels
• dict.values() isoleert waarden
• dict.items() retourneert items in een lijstformaat van (sleutel, waarde) tuple paren

Om de sleutels terug te krijgen, zouden we de dict.keys() methode gebruiken. In ons voorbeeld zou dat de variabelenaam gebruiken en sammy.keys() zijn. Laten we dat aan een print() methode doorgeven en de uitvoer bekijken:

print(sammy.keys())

Output
dict_keys(['followers', 'username', 'online'])

We ontvangen output die de sleutels plaatst binnen een iterabel weergaveobject van de klasse dict_keys. De sleutels worden vervolgens afgedrukt in een lijstformaat.

Deze methode kan worden gebruikt om te zoeken in dictionaries. Bijvoorbeeld, we kunnen kijken naar de gemeenschappelijke sleutels die worden gedeeld tussen twee dictionary datastructuren:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}
jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

for common_key in sammy.keys() & jesse.keys():
    print(sammy[common_key], jesse[common_key])

De dictionary sammy en de dictionary jesse zijn elk een gebruikersprofiel dictionary.

Hun profielen hebben verschillende sleutels, echter, omdat Sammy een sociaal profiel heeft met bijbehorende volgers, en Jesse heeft een gameprofiel met bijbehorende punten. De 2 sleutels die ze gemeen hebben zijn gebruikersnaam en online status, die we kunnen vinden wanneer we dit kleine programma uitvoeren:

Output
sammy-shark JOctopus
True False

We zouden zeker het programma kunnen verbeteren om de uitvoer meer leesbaar voor de gebruiker te maken, maar dit illustreert dat dict.keys() kan worden gebruikt om te controleren welke sleutels verschillende dictionaries gemeen hebben of niet. Dit is vooral handig voor grote dictionaries.

Vergelijkbaar kunnen we de dict.values()-methode gebruiken om de waarden in de sammy-dictionary op te vragen, die geconstrueerd zou worden als sammy.values(). Laten we die afdrukken:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

print(sammy.values())

Output
dict_values([True, 'sammy-shark', 987])

Zowel de methoden keys() als values() retourneren ongesorteerde lijsten van de sleutels en waarden die aanwezig zijn in de sammy-dictionary met de weergaveobjecten van dict_keys en dict_values respectievelijk.

Als we geïnteresseerd zijn in alle items in een dictionary, kunnen we er toegang toe krijgen met de items()-methode:

print(sammy.items())

Output
dict_items([('online', True), ('username', 'sammy-shark'), ('followers', 987)])

De geretourneerde indeling hiervan is een lijst die bestaat uit (sleutel, waarde)-tupleparen met het weergaveobject dict_items.

We kunnen over de geretourneerde lijstindeling itereren met een for-lus. We kunnen bijvoorbeeld elk van de sleutels en waarden van een gegeven dictionary afdrukken en het vervolgens menselijker maken door een string toe te voegen:

for key, value in sammy.items():
    print(key, 'is the key for the value', value)

Output
online is the key for the value True
followers is the key for the value 987
username is the key for the value sammy-shark

De for-lus hierboven itereerde over de items binnen de sammy-dictionary en drukte de sleutels en waarden regel voor regel af, met informatie om het gemakkelijker te maken voor mensen om te begrijpen.

We kunnen ingebouwde methoden gebruiken om items, waarden en sleutels te benaderen vanuit dictionary-gegevensstructuren.

Wijzigen van Woordenboeken

Woordenboeken zijn een veranderlijke datastructuur, dus je kunt ze aanpassen. In dit gedeelte zullen we het hebben over het toevoegen en verwijderen van elementen uit een woordenboek.

Toevoegen en Veranderen van Elementen in Woordenboeken

Zonder een methode of functie te gebruiken, kun je sleutel-waardeparen toevoegen aan woordenboeken door de volgende syntaxis te gebruiken:

dict[key] = value

We zullen kijken hoe dit in de praktijk werkt door een sleutel-waardepaar toe te voegen aan een woordenboek genaamd gebruikersnamen:

usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

usernames['Drew'] = 'squidly'

print(usernames)

Output
{'Drew': 'squidly', 'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

We zien nu dat het woordenboek is bijgewerkt met het sleutel-waardepaar 'Drew': 'inktvis'. Omdat woordenboeken ongeordend kunnen zijn, kan dit paar overal in de uitvoer van het woordenboek voorkomen. Als we later in ons programma bestand het gebruikersnamen-woordenboek gebruiken, zal het de extra sleutel-waardekoppeling bevatten.

Bovendien kan deze syntaxis worden gebruikt om de waarde die aan een sleutel is toegewezen te wijzigen. In dit geval verwijzen we naar een bestaande sleutel en geven we er een andere waarde aan.

Laten we een woordenboek drew overwegen dat een van de gebruikers is op een gegeven netwerk. We zullen zeggen dat deze gebruiker vandaag een stijging in volgers heeft gekregen, dus moeten we de gehele waarde bijgewerkt doorgeven aan de sleutel 'volgers'. We zullen de print()-functie gebruiken om te controleren of het woordenboek is gewijzigd.

drew = {'username': 'squidly', 'online': True, 'followers': 305}

drew['followers'] = 342

print(drew)

Output
{'username': 'squidly', 'followers': 342, 'online': True}

In de uitvoer zien we dat het aantal volgers is gestegen van de gehele waarde van 305 naar 342.

We kunnen deze methode gebruiken om sleutel-waardeparen toe te voegen aan woordenboeken met gebruikersinvoer. Laten we een snel programma schrijven, gebruikersnamen.py, dat wordt uitgevoerd op de opdrachtregel en invoer van de gebruiker toestaat om meer namen en bijbehorende gebruikersnamen toe te voegen:

# Definieer oorspronkelijk woordenboek
usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

# Stel een while-lus in om te itereren
while True:

    # Vraag de gebruiker om een naam in te voeren
    print('Enter a name:')

    # Wijs toe aan naamvariabele
    name = input()

    # Controleer of de naam in het woordenboek staat en geef feedback weer
    if name in usernames:
        print(usernames[name] + ' is the username of ' + name)

    # Als de naam niet in het woordenboek staat...
    else:

        # Geef feedback weer        
        print('I don\'t have ' + name + '\'s username, what is it?')

        # Neem een nieuwe gebruikersnaam in voor de bijbehorende naam
        username = input()

        # Wijs gebruikersnaamwaarde toe aan naam sleutel
        usernames[name] = username

        # Geef feedback weer dat de gegevens zijn bijgewerkt
        print('Data updated.')

Laten we het programma uitvoeren op de opdrachtregel:

python usernames.py

Wanneer we het programma uitvoeren, krijgen we iets als de volgende output:

Output
Enter a name:
Sammy
sammy-shark is the username of Sammy
Enter a name:
Jesse
I don't have Jesse's username, what is it?
JOctopus
Data updated.
Enter a name:

Wanneer we klaar zijn met het testen van het programma, kunnen we CTRL + C indrukken om het programma te verlaten. Je kunt een trigger instellen om het programma te beëindigen (zoals het typen van de letter q) met een voorwaardelijke verklaring om de code te verbeteren.

Dit laat zien hoe je woordenboeken interactief kunt aanpassen. Met dit specifieke programma verlies je zodra je het programma afsluit met CTRL + C al je gegevens, tenzij je een manier implementeert om het lezen en schrijven van bestanden te behandelen.

We kunnen ook woordenboeken toevoegen en aanpassen door de dict.update()-methode te gebruiken. Dit verschilt van de append() methode die beschikbaar is in lijsten.

In het onderstaande woordenboek jesse, laten we de sleutel 'volgers' toevoegen en deze een geheel getalwaarde geven met jesse.update(). Daarna laten we de bijgewerkte dictionary print()en.

jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

jesse.update({'followers': 481})

print(jesse)

Output
{'followers': 481, 'username': 'JOctopus', 'points': 723, 'online': False}

Uit de output kunnen we zien dat we succesvol de sleutel-waarde-paar 'volgers': 481 aan het woordenboek jesse hebben toegevoegd.

We kunnen ook de dict.update()-methode gebruiken om een bestaand sleutel-waarde-paar te wijzigen door een gegeven waarde te vervangen voor een specifieke sleutel.

Laten we de online status van Sammy van True naar False wijzigen in het sammy-woordenboek:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

sammy.update({'online': False})

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': False}

De regel sammy.update({'online': False}) verwijst naar de bestaande sleutel 'online' en wijzigt de Boolean-waarde van True naar False. Wanneer we de print()-functie oproepen voor het woordenboek, zien we de update plaatsvinden in de output.

Om items aan woordenboeken toe te voegen of waarden te wijzigen, kunnen we zowel de syntaxis dict[key] = value als de methode dict.update() gebruiken.

Verwijderen van Woordenboekelementen

Net zoals je sleutel-waardeparen kunt toevoegen en waarden binnen het woordenboektype kunt wijzigen, kun je ook items binnen een woordenboek verwijderen.

Om een sleutel-waardepaar uit een woordenboek te verwijderen, zullen we de volgende syntaxis gebruiken:

del dict[key]

Laten we het jesse-woordenboek nemen dat een van de gebruikers vertegenwoordigt. We zullen zeggen dat Jesse niet langer het online platform gebruikt om games te spelen, dus we zullen het item dat geassocieerd is met de sleutel 'points' verwijderen. Vervolgens zullen we het woordenboek afdrukken om te bevestigen dat het item is verwijderd:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

del jesse['points']

print(jesse)

Output
{'online': False, 'username': 'JOctopus', 'followers': 481}

De regel del jesse['points'] verwijdert het sleutel-waardepaar 'points': 723 uit het jesse-woordenboek.

Als we een woordenboek van al zijn waarden willen wissen, kunnen we dat doen met de dict.clear()-methode. Dit houdt een gegeven woordenboek in stand voor het geval we het later in het programma nodig hebben, maar het bevat geen items meer.

Laten we alle items binnen het jesse-woordenboek verwijderen:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

jesse.clear()

print(jesse)

Output
{}

Het uitvoer toont aan dat we nu een leeg woordenboek hebben zonder sleutel-waardeparen.

Als we geen specifiek woordenboek meer nodig hebben, kunnen we del gebruiken om het volledig te verwijderen:

del jesse

print(jesse)

Wanneer we een oproep doen naar print() na het verwijderen van het jesse-woordenboek, zullen we de volgende foutmelding ontvangen:

Output
...
NameError: name 'jesse' is not defined

Omdat woordenboeken mutable datatypes zijn, kunnen ze worden toegevoegd, gewijzigd en kunnen items worden verwijderd en gewist.

Conclusie

Deze tutorial behandelde de woordenboek datastructuur in Python. Woordenboeken bestaan uit sleutel-waardeparen en bieden een manier om gegevens op te slaan zonder afhankelijk te zijn van indexering. Hierdoor kunnen we waarden ophalen op basis van hun betekenis en relatie tot andere gegevenstypen.

Vanaf hier kunt u meer leren over andere gegevenstypen in onze tutorial “Understanding Data Types“.

Je kunt het woordenboek gegevenstype zien gebruikt in programmeerprojecten zoals web scraping met Scrapy.