Python-dictionary’s en verzamelingen

Een dictionary slaat paren op: een sleutel duidt een element aan en de bijbehorende waarde bevat de informatie die je zoekt. Een contactenlijst is een bruikbaar model: een naam leidt naar een telefoonnummer. Bij het opzoeken in een dictionary gebruik je een sleutel, ook als die sleutel toevallig een getal is.

Schrijf de paren

ages = {"Ana": 31, "Ben": 27, "Cara": 35}
print(ages["Ben"])
print(len(ages))

Dit drukt 27 en daarna 3 af. De dubbele punt koppelt elke sleutel aan zijn waarde; komma’s scheiden de paren. len telt paren. Zowel {} als dict() maakt een lege dictionary.

Elke sleutel komt maar één keer voor. In {"a": 1, "b": 2, "a": 3} vervangt de latere waarde voor "a" de eerdere, zodat {'a': 3, 'b': 2} overblijft. Twee verschillende sleutels mogen dezelfde waarde hebben: {"Ana": "blue", "Ben": "blue"} heeft nog steeds twee elementen.

Maak een dictionary van andere gegevens

Kies de vorm die bij de invoer past:

colors = dict(red=1, blue=2)
coordinates = dict([("x", 10), ("y", 20)])
labels = dict(zip(["a", "b", "c"], [1, 2, 3]))

De eerste vorm maakt stringsleutels van de argumentnamen. De tweede leest een sequentie van paren met twee elementen. De derde koppelt overeenkomstige elementen van twee lijsten en levert {'a': 1, 'b': 2, 'c': 3} op. De strings in de eerste vorm zijn 'red' en 'blue', geen opgezochte variabelen.

Kies bruikbare sleutels

Dictionarysleutels moeten hashbaar zijn. Strings en getallen werken, net als tuples die volledig uit hashbare elementen bestaan. Lijsten, dictionary’s en gewone verzamelingen werken niet als sleutel. Gebruik voor een locatie de tuple (2, 3) in plaats van de lijst [2, 3]:

board = {(0, 0): "start", (2, 3): "treasure"}
print(board[(2, 3)])

Dit drukt treasure af. De ronde haakjes maken van het coördinatenpaar één sleutel. Een tuple met een lijst voldoet nog steeds niet aan de regel voor hashbaarheid. Voor dictionarywaarden geldt die beperking niet: een waarde kan een lijst, een andere dictionary of een ander type zijn.

Gelijke numerieke sleutels verwijzen naar hetzelfde sleutel-waardepaar. Omdat 1, 1.0 en True bij vergelijking gelijk zijn, bevat {1: "one", 1.0: "float one"} één paar, met de waarde 'float one'. De string "1" is een andere sleutel dan het getal 1.

Houd volgorde en identiteit uit elkaar

Sinds Python 3.7 bewaren dictionary’s de invoegvolgorde. De leeftijden hierboven verschijnen als Ana, Ben, Cara wanneer je ze afdrukt of met een lus doorloopt. Het blijven sleutels, geen lijstposities: ages[0] vraagt om de sleutel 0 en werpt KeyError: 0 op.

Dictionary’s zijn wijzigbaar. Na backup = ages verwijzen beide namen naar dezelfde dictionary. Als je backup["Ana"] = 32 instelt, verandert ook de waarde die je via ages bereikt. Schrijf backup = ages.copy() of backup = dict(ages) om de buitenste dictionary te kopiëren. Afzonderlijke buitenste dictionary’s kunnen nog steeds geneste lijsten en dictionary’s delen.

De manier van opzoeken moet passen bij wat een ontbrekende sleutel in je programma betekent. Soms wijst die op een fout. Soms is het normaal, zoals bij een product dat nog niet is geteld. Python biedt afzonderlijke manieren om die gevallen af te handelen.

Lees een bestaande waarde

stock = {"apples": 12, "pears": 0, "plums": 7}
print(stock["plums"])

Het opzoeken met vierkante haakjes geeft 7 terug. Sleutels moeten exact overeenkomen: "Plums" verschilt van "plums". Het lezen van stock["kiwis"] werpt KeyError: 'kiwis' op, omdat die sleutel ontbreekt. Je krijgt geen lege waarde of een telling van nul.

Gebruik deze directe zoekmethode als een sleutel verplicht is. Een fout vestigt dan de aandacht op onvolledige gegevens of een spelfout op de plaats waar die voorkomt.

Controleer op een sleutel

De expressie key in stock controleert of een sleutel bestaat. "pears" in stock is True, hoewel de opgeslagen waarde nul is. "kiwis" not in stock is ook True.

item = "kiwis"
if item in stock:
    print(stock[item])
else:
    print("No stock record for", item)

Hier leidt de ontbrekende sleutel tot een melding. Het opzoeken gebeurt alleen in de tak waarin de sleutel bestaat.

Een lidmaatschapscontrole op een dictionary doorzoekt sleutels. 12 in stock is False; om te vragen of een element de opgeslagen waarde 12 heeft, schrijf je 12 in stock.values(). De collectie die je na in zet, bepaalt wat wordt doorzocht.

Lees met een standaardwaarde

stock.get("kiwis") geeft None terug zonder KeyError op te werpen. Geef een tweede argument om een andere standaardwaarde te kiezen: stock.get("kiwis", 0) geeft 0 terug. Geen van beide aanroepen voegt een nieuw element toe. Na beide aanroepen bevat de dictionary nog steeds alleen appels, peren en pruimen.

De standaardwaarde vervangt een ontbrekend zoekresultaat, niet een opgeslagen waarde. stock.get("pears", 99) geeft 0 terug, omdat peren al een waarde heeft.

Verwar nul niet met ontbreken

if stock.get("pears"): controleert de waarheidswaarde van de teruggegeven waarde. Nul is onwaar, dus wordt die tak overgeslagen. Dezelfde toets slaat ook een ontbrekende sleutel over waarvan het opzoeken None teruggeeft. Controleer rechtstreeks of de sleutel aanwezig is om die gevallen te onderscheiden.

Verwerk een hele bestelling

prices = {"coffee": 3.5, "tea": 2.75}
order = ["tea", "coffee", "tea", "soda"]
total = 0
for item in order:
    if item in prices:
        total += prices[item]
    else:
        print("No price for", item)
print(total)

De eerste thee brengt het totaal op 2,75, koffie brengt het op 6,25 en de tweede thee brengt het op 9,0. Frisdrank levert de melding No price for soda op en voegt niets toe. Bij elke doorgang direct opzoeken zou bij frisdrank mislukken; zonder melding een standaardprijs van nul gebruiken zou de ontbrekende prijs verbergen. De afzonderlijke tak maakt die ontbrekende informatie zichtbaar.

Bij het bijwerken van dictionary’s geven sleutels aan wat verandert. Een waarde toekennen kan een nieuw paar toevoegen of een oude waarde vervangen. Het verwijderen van een paar kan ook informatie teruggeven die je nodig hebt, zoals de hoeveelheid die uit een voorraad is verwijderd.

Voeg toe en vervang

scores = {"Ana": 8}
scores["Ben"] = 6
scores["Ana"] = 9
scores["Ben"] += 2
print(scores)

Het resultaat is {'Ana': 9, 'Ben': 8}. Ben wordt toegevoegd, Ana wordt bijgewerkt en daarna stijgt Bens bestaande score. De regel met += leest eerst de oude waarde en werpt dus KeyError op bij een ontbrekende sleutel. Dictionary’s hebben geen methode append.

Combineer dictionary’s

update kopieert paren naar een bestaande dictionary. Bij die scores verandert scores.update({"Ben": 7, "Cara": 10}) Bens score in 7 en voegt het Cara toe met 10.

Sinds Python 3.9 kan de samenvoegoperator een nieuwe dictionary maken:

left = {"x": 1, "y": 2}
right = {"y": 5, "z": 3}
merged = left | right
print(merged)

Dit drukt {'x': 1, 'y': 5, 'z': 3} af. Bij een gedeelde sleutel geldt de rechterwaarde. left blijft ongewijzigd; left |= right zou die ter plaatse bijwerken.

update() geeft None terug. Als je scores = scores.update(new_scores) schrijft, wordt de oude dictionary gewijzigd en verwijst scores daarna naar None. Roep update op een eigen regel aan. Ken het resultaat van left | right toe als je een nieuwe samengevoegde dictionary wilt.

Verwijder paren

Voor {"a": 1, "b": 2, "c": 3} geeft popitem() de tuple ('c', 3) terug. Dit gebruikt de invoegvolgorde, niet de alfabetische volgorde of de grootste waarde.

Volg een voorraadwijziging

inventory = {"pens": 10, "pads": 4}
inventory["pens"] -= 3
inventory["clips"] = 50
removed = inventory.pop("pads")

Na de verkoop blijven 7 pennen over. Door paperclips toe te voegen ontstaat een nieuwe sleutel. Het verwijderen van schrijfblokken slaat 4 op in removed, waarna {'pens': 7, 'clips': 50} overblijft. Dankzij de retourwaarde van pop kan het programma de verwijderde hoeveelheid gebruiken nadat het paar is verdwenen.

Voeg alleen toe als de sleutel ontbreekt

setdefault(key, default) geeft de bestaande waarde terug, of voegt de standaardwaarde toe en geeft die terug als de sleutel ontbreekt. Voor stock = {"apples": 12, "pears": 0, "plums": 7} voegt stock.setdefault("kiwis", 0) kiwi’s toe en geeft 0 terug. stock.setdefault("apples", 99) geeft 12 terug en laat appels ongewijzigd. Dit toevoegen is het verschil met get.

Als je een bestaande sleutel bijwerkt, blijft die op dezelfde plaats. Als je begint met {"a": 1, "b": 2, "c": 3}, blijft "a" vooraan staan wanneer je d["a"] = 10 instelt. Als je "a" verwijdert en opnieuw toevoegt, komt die na "c". Een vervangende waarde en een nieuw ingevoegd paar beïnvloeden de volgorde verschillend.

Kies een lus die je het deel van elk paar geeft dat je nodig hebt. Een dictionary op zichzelf levert sleutels. De weergaven kunnen waarden of volledige paren leveren, zodat je geen informatie hoeft op te zoeken die de lus je rechtstreeks kan geven.

Doorloop sleutels, waarden of paren

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
for day, temp in temps.items():
    print(day, temp)

De temperaturen zijn in graden Fahrenheit. Dit drukt Mon 68, Tue 75 en Wed 71 af op afzonderlijke regels, in invoegvolgorde. Elk element is een tuple met twee elementen die de lus uitpakt in day en temp.

Gebruik bij for day in temps: de expressie temps[day] binnen de lus als je de bijbehorende waarde nodig hebt. Als het programma elke keer beide delen nodig heeft, maakt .items() de taak meestal duidelijker.

Begrijp weergaven

keys(), values() en items() geven weergaven terug, die latere wijzigingen in hun dictionary weerspiegelen. Het zijn geen lijsten en je kunt ze niet op positie indexeren. temps.keys()[0] werpt TypeError op. Zet de weergave om naar een lijst als je een momentopname met posities nodig hebt: list(temps) geeft ['Mon', 'Tue', 'Wed'].

Bereken een totaal of vind een bijbehorende sleutel

sum(temps.values()) geeft 214 terug en delen door len(temps) geeft een gemiddelde van ongeveer 71,33. max(temps.values()) geeft 75 terug. Om te vinden welke dag die waarde heeft, schrijf je max(temps, key=temps.get), dat 'Tue' teruggeeft.

Het argument key= geeft een functie op die voor de vergelijking wordt gebruikt. Python doorloopt hier dagsleutels en roept voor elke sleutel temps.get aan om de temperatuur op te halen. Schrijf de functienaam zonder die aan te roepen: temps.get, niet temps.get(). Als waarden gelijk zijn, geeft max de eerste sleutel terug die het tegenkomt.

Sorteer een rapport

sorted(temps) geeft sleutels in alfabetische volgorde terug. sorted(temps.items()) geeft paren terug die op sleutel zijn gesorteerd. Gebruik sorted(temps, key=temps.get) om dagsleutels op temperatuur te sorteren; dit levert ['Mon', 'Wed', 'Tue'] op. Voeg reverse=True toe voor ['Tue', 'Wed', 'Mon']. Deze aanroepen geven lijsten terug; ze veranderen de volgorde van temps niet.

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
passing = 0
for name, grade in grades.items():
    print(f"{name}: {grade}")
    if grade >= 75:
        passing += 1

Het rapport drukt elke naam met het bijbehorende cijfer af. Ana en Cara halen de drempelwaarde, dus eindigt passing op 2.

Verwijder sleutel-waardeparen zonder het doorlopen te verstoren

Voeg geen sleutels toe en verwijder ze niet terwijl je rechtstreeks over een dictionary itereert. Als de omvang verandert, kan RuntimeError: dictionary changed size during iteration worden opgeworpen. Een bestaande waarde vervangen mag wel.

Om koudere dagen te verwijderen, gebruik je for day in list(temps): en verwijder je temps[day] als de waarde lager is dan 70. De lus doorloopt een afzonderlijke lijst van sleutels, zodat {'Tue': 75, 'Wed': 71} in de dictionary overblijft. Een nieuwe gefilterde dictionary maken is een andere manier om het doorlopen en de wijzigingen gescheiden te houden.

Een nieuwe dictionary ontstaat vaak uit een regel die op bestaande gegevens wordt toegepast. Begin met een lus die je kunt uitleggen en gebruik daarna een comprehensie als dezelfde regel duidelijk in één expressie past.

Maak één paar tegelijk

words = ["kiwi", "fig", "banana"]
lengths = {}
for word in words:
    lengths[word] = len(word)

Elke doorgang kiest een woord als sleutel en de lengte ervan als waarde. Het resultaat is {'kiwi': 4, 'fig': 3, 'banana': 6}. De dictionary wordt vóór de lus aangemaakt, zodat eerdere paren bij latere doorgangen beschikbaar blijven.

Een dictionarycomprehensie drukt hetzelfde werk uit:

lengths = {word: len(word) for word in words}

Lees het for-deel om te zien wat wordt doorlopen en daarna de expressie ervoor om te zien welk paar wordt gemaakt. De dubbele punt scheidt de sleutelexpressie van de waarde-expressie. Zonder die dubbele punt maakt {word for word in words} een verzameling.

Behoud bepaalde elementen

Een if-clausule filtert de invoer:

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
high_grades = {
    name: grade
    for name, grade in grades.items()
    if grade >= 80
}

Ana en Cara voldoen aan de toets, wat {'Ana': 88, 'Cara': 95} geeft. Bens paar wordt weggelaten. De invoerdictionary blijft ongewijzigd; het resultaat bevat alleen paren die aan de voorwaarde voldoen.

Transformeer waarden

Een comprehensie kan de dagen behouden terwijl Fahrenheitmetingen naar Celsius worden omgezet:

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
celsius = {
    day: round((f - 32) * 5 / 9, 1)
    for day, f in temps.items()
}

Het resultaat is {'Mon': 20.0, 'Tue': 23.9, 'Wed': 21.7}. Voor dinsdag geeft 32 aftrekken 43; vermenigvuldigen met 5 en delen door 9 geeft ongeveer 23,89. round(..., 1) slaat 23,9 op. De sleutel blijft hetzelfde terwijl de waarde verandert.

Koppel lijsten zorgvuldig

dict(zip(names, scores)) koppelt elke naam aan de score op dezelfde positie. zip stopt wanneer de kortste invoer eindigt. Als je ["Ana", "Ben", "Cara"] koppelt aan [90, 85], krijg je {'Ana': 90, 'Ben': 85}. Geen foutmelding wijst op Cara’s ontbrekende score, dus controleer de invoerlengtes als elke naam een score moet hebben.

Wissel sleutels en waarden om

favorites = {"Ana": "blue", "Ben": "red", "Cara": "blue"}
by_color = {color: name for name, color in favorites.items()}

Het resultaat is {'blue': 'Cara', 'red': 'Ben'}. Zowel Ana als Cara zou dezelfde nieuwe sleutel nodig hebben, dus vervangt Cara’s latere paar dat van Ana. Omkeren behoudt alleen alle paren als de oude waarden uniek en hashbaar zijn. Een lijstwaarde kan helemaal geen dictionarysleutel worden. Om meerdere namen onder één kleur te behouden, sla je een lijst van namen onder die kleur op.

Gebruik een gewone lus als de taak meerdere instructies, meldingen of controles nodig heeft. Een comprehensie is nuttig omdat ze een korte regel zichtbaar maakt; als je er een grotere procedure in probeert te persen, wordt de regel moeilijker te volgen.

Een frequentietabel geeft aan hoe vaak elk verschillend element voorkomt. De sleutels duiden de elementen aan; de waarden zijn tellers. De dictionary groeit wanneer een nieuw element verschijnt, terwijl latere voorkomens een bestaande telling verhogen.

Volg een teller stap voor stap

counts = {}
for letter in "banana":
    if letter in counts:
        counts[letter] += 1
    else:
        counts[letter] = 1

De eerste letter maakt 'b': 1. De volgende maakt 'a': 1 en daarna ontstaat 'n': 1. De volgende "a" verhoogt de bestaande telling tot 2. Na de laatste twee letters is de dictionary {'b': 1, 'a': 3, 'n': 2}. De volgorde geeft aan wanneer elke letter voor het eerst verscheen, niet welke letter het vaakst voorkomt.

Gebruik nul vóór het eerste voorkomen

De twee takken kunnen samen één toekenning worden:

counts = {}
for letter in "banana":
    counts[letter] = counts.get(letter, 0) + 1

De rechterkant leest de vorige telling, gebruikt nul als de sleutel ontbreekt en telt er dan één bij op. De linkerkant slaat die nieuwe telling op. get zelf voegt niets toe; de toekenning doet dat.

Als je alleen counts[letter] += 1 gebruikt, mislukt dat bij een nieuwe letter. Als je counts = {} binnen de lus zet, ontstaat een ander probleem: elke doorgang wist de eerdere tellingen. Initialiseer de dictionary één keer voordat je de elementen verwerkt.

Bepaal wat als hetzelfde woord telt

Bij tekst beïnvloeden hoofdletters en leestekens de sleutels. De strings "The" en "the" verschillen, net als "dog." en "dog". Schoon de vormen op voordat je ze als sleutels gebruikt:

text = "The cat saw the dog. The dog ran."
counts = {}
for word in text.lower().split():
    word = word.strip(".,!?")
    counts[word] = counts.get(word, 0) + 1

Dit levert {'the': 3, 'cat': 1, 'saw': 1, 'dog': 2, 'ran': 1} op. lower verwerkt hoofdletters en kleine letters, split scheidt woorden bij witruimte en strip verwijdert de vermelde leestekens aan de uiteinden. Het verwijdert geen leestekens uit het midden van een woord.

Vind de meest voorkomende elementen

Voor deze niet-lege tabel geeft max(counts, key=counts.get) de waarde 'the' terug. Om de twee meest voorkomende woorden te vinden, gebruik je sorted(counts, key=counts.get, reverse=True)[:2], wat ['the', 'dog'] geeft. Gelijke tellingen behouden bij het sorteren hun oorspronkelijke volgorde.

Het patroon telt ook getallen of tuples. Voor de worpen [3, 6, 3, 1, 6, 3] maakt het {3: 3, 6: 2, 1: 1}. Een waarde die nooit is waargenomen, heeft geen sleutel-waardepaar. Lees die met een standaardwaarde van nul als dat nuttig is.

Herken de verkorte aanpak uit de bibliotheek

from collections import Counter
letter_counts = Counter("banana")
print(letter_counts.most_common(1))
print(letter_counts["z"])

Dit drukt [('a', 3)] en daarna 0 af. De import maakt Counter uit de standaardbibliotheek van Python beschikbaar. Een Counter is een dictionary die voor tellingen is ontworpen: de sleutels zijn hashbare elementen en het rechtstreeks opzoeken van een ontbrekend element geeft nul terug. De weergegeven tellingen voor deze invoer zijn Counter({'a': 3, 'n': 2, 'b': 1}).

Een dictionary kan onder elke sleutel een hele groep opslaan. De sleutel geeft de categorie aan en een lijst bevat de elementen die eraan zijn toegewezen. Zo blijft elk lid beschikbaar voor latere totalen, gemiddelden of rapporten.

Maak afzonderlijke lijsten voor groepen

words = ["apple", "bean", "avocado", "beet", "corn"]
groups = {}
for word in words:
    first = word[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(word)

Voor "apple" maakt het programma een lege lijst onder "a" en voegt het het woord toe. "bean" begint een afzonderlijke lijst onder "b". "avocado" komt in de bestaande lijst onder "a". Het resultaat is {'a': ['apple', 'avocado'], 'b': ['bean', 'beet'], 'c': ['corn']}.

De lege lijst wordt alleen voor een nieuw label gemaakt. Als je die bij elke doorgang zou maken, zouden de eerdere leden van die groep verloren gaan.

Verkort de initialisatie

groups.setdefault(word[0], []).append(word) voert dezelfde groepeerstap uit. setdefault geeft de bestaande lijst terug als die er is. Anders slaat het de opgegeven lege lijst op en geeft die terug. De daaropvolgende append wijzigt de teruggegeven lijst.

Een andere mogelijkheid maakt lijsten automatisch aan:

from collections import defaultdict
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

Geef list, de functie die een nieuwe lijst maakt, zonder ronde haakjes door. Wanneer een ontbrekende sleutel wordt opgezocht, maakt deze defaultdict een nieuwe lege lijst en slaat die op. Zelfs een leesactie zoals groups["z"] voegt die ontbrekende sleutel toe. Gebruik "z" in groups als je alleen wilt controleren of een groep bestaat.

Houd de lijsten onafhankelijk

groups = dict.fromkeys(["a", "b"], []) plaatst dezelfde lijst onder beide sleutels. Als je via groups["a"] de waarde 1 toevoegt, geeft dat {'a': [1], 'b': [1]}. De lijsten worden gedeeld, niet gekopieerd.

Om met afzonderlijke lijsten te beginnen, gebruik je {key: [] for key in keys}, setdefault met een nieuwe [] of defaultdict(list). Elke nieuwe categorie moet een eigen lijstobject krijgen.

Tel bedragen per categorie op

Bij tellen tel je één op per voorkomen. Bij een categorietotaal tel je het bedrag van elk element op:

expenses = [("food", 12.5), ("travel", 30),
            ("food", 7.25), ("books", 18)]
totals = {}
for category, amount in expenses:
    totals[category] = totals.get(category, 0) + amount

Voeding begint bij 12,5 en krijgt er daarna 7,25 bij, wat eindigt op 19,75. Reizen komt uit op 30 en boeken op 18. Als je alleen amount zou opslaan, zou dat het vorige totaal vervangen in plaats van erbij worden opgeteld.

Bereken een gemiddelde of ontdubbel een groep

Voor scores = {"A": [80, 90], "B": [70]} doorloop je scores.items() en bereken je sum(values) / len(values). Groep A heeft een gemiddelde van 85,0; groep B een gemiddelde van 70,0. Toets if values: voordat je deelt, zodat een lege groep afzonderlijk wordt afgehandeld.

Gebruik verzamelingen als waarden wanneer herhalingen binnen elke groep moeten verdwijnen. tags.setdefault(post, set()).add(tag) maakt een verzameling voor een nieuw bericht en voegt het label toe. Een herhaald label blijft één element; een lijst zou elk voorkomen bewaren.

Een record brengt samenhangende velden bij elkaar, zoals de leeftijd, studierichting en cijfers van een student. Een geneste dictionary slaat een andere dictionary op als waarde. De buitenste sleutels kunnen records aanduiden, terwijl de binnenste sleutels velden aanduiden.

Lees één niveau tegelijk

students = {
    "ana": {"age": 19, "major": "math", "grades": [88, 92]},
    "ben": {"age": 22, "major": "history", "grades": [75, 81, 79]},
}

students["ana"] geeft Ana’s recorddictionary. Door ["major"] toe te voegen lees je haar studierichting, dus students["ana"]["major"] geeft 'math' terug. Voor Bens laatste cijfer bereikt students["ben"]["grades"][-1] het record, daarna de lijst en vervolgens het laatste lijstelement, 79.

Elke zoekactie werkt op het object dat de vorige zoekactie teruggeeft. Dezelfde syntaxis met vierkante haakjes kan op het ene niveau een dictionarysleutel betekenen en op een ander niveau een lijstpositie.

Wijzig een veld of voeg een record toe

students["ana"]["age"] = 20
students["ben"]["email"] = "ben@example.com"
students["cara"] = {"age": 21, "major": "art", "grades": []}
students["cara"]["grades"].append(90)

De eerste twee regels wijzigen velden in bestaande records of voegen er velden aan toe. De derde voegt een volledig record toe onder een nieuwe ID. De vierde bereikt Cara’s cijferlijst en voegt er een cijfer aan toe.

De toekenning students["dev"]["age"] = 30 mislukt omdat het buitenste opzoeken van "dev" eerst gebeurt en KeyError: 'dev' opwerpt. Maak het record aan voordat je waarden aan de velden toekent.

Voor een optionele leesactie geeft students.get("dev", {}).get("age") de waarde None terug. De eerste standaardwaarde is een lege dictionary, zodat de tweede get een dictionary heeft om te lezen, ook als het record ontbreekt. Bij deze records is elke buitenste waarde zelf een dictionary.

Kies een structuur die bij het benaderen past

Een lijst van dictionary’s houdt rijen op volgorde:

rows = [{"name": "Ana", "city": "Austin"},
        {"name": "Ben", "city": "Denver"}]
print(rows[1]["city"])

Dit drukt Denver af: eerst de lijstindex, daarna de veldsleutel. Een dictionary van lijsten, zoals {"A": [80, 90], "B": [70]}, slaat meerdere waarden per label op. Je kunt deze structuren combineren als een record zowel benoemde velden als een geordende lijst nodig heeft.

Wanneer namen rijen uniek aanduiden, maak je by_name = {row["name"]: row for row in rows}. Daarna vindt by_name["Ben"] Bens rij rechtstreeks. De waarden zijn de bestaande rijdictionary’s, dus wijzigingen via deze index beïnvloeden ook die rijen. Als namen zich herhalen, vervangt een latere rij een eerdere onder die sleutel.

Kopieer geneste gegevens bewust

backup = students deelt de volledige dictionary. backup = students.copy() maakt een afzonderlijke buitenste dictionary, maar behoudt dezelfde binnenste records. Na die ondiepe kopie verandert backup["ana"]["age"] = 99 ook Ana’s leeftijd in students.

import copy
independent = copy.deepcopy(students)
independent["ana"]["age"] = 25

Voor deze geneste dictionary’s en lijsten maakt de diepe kopie ook afzonderlijke binnenste objecten. Als je de gekopieerde leeftijd wijzigt, blijft de oorspronkelijke leeftijd ongewijzigd. Gebruik consistente veldnamen in alle records, zodat dezelfde zoekcode voor elk record werkt.

Bij het verwerken van geneste gegevens houd je bij welk niveau de lus heeft bereikt. Een buitenste lus kiest een record. Door een veld op te zoeken bereik je een waarde binnen dat record en een binnenste lus kan vervolgens de elementen van een opgeslagen lijst doorlopen.

Vat per doorgang één record samen

students = {
    "ana": {"major": "math", "grades": [88, 92]},
    "ben": {"major": "history", "grades": [75, 81, 79]},
    "cara": {"major": "art", "grades": []},
}
for name, info in students.items():
    grades = info["grades"]
    major = info["major"]
    if grades:
        average = sum(grades) / len(grades)
        print(f"{name}: {major}, average {average:.1f}")
    else:
        print(f"{name}: {major}, no grades")

Ana’s cijfers tellen op tot 180, dus haar gemiddelde is 90,0. Bens totaal is 235 over drie cijfers, wat ongeveer 78,33 geeft; de opmaak :.1f toont 78,3. Cara’s lijst is leeg, dus drukt het programma cara: art, no grades af zonder door nul te delen.

Door grades en major binnen de lus toe te kennen, krijgt elke naam de waarden van het huidige record. Ook het gemiddelde hoort binnen de lus: het moet voor elke student afzonderlijk worden berekend.

Lees optionele velden

info.get("email", "no email") levert tekst voor een optioneel e-mailveld. Een directe info["email"] zou KeyError opwerpen voor een record zonder dat veld. Een standaardwaarde hoort op het niveau waar het veld kan ontbreken. De get van de buitenste dictionary zou student-ID’s doorzoeken, geen e-mailvelden.

Selecteer records

math_students = []
for name, info in students.items():
    if info["major"] == "math":
        math_students.append(name)

Dit levert ['ana'] op. De voorwaarde leest een veld van het huidige record; de toegevoegde waarde is de buitenste sleutel. Als het rapport volledige records nodig had, zou het in plaats daarvan info kunnen toevoegen. Bepaal welk soort resultaat het volgende deel van het programma nodig heeft.

Doorloop elk opgeslagen cijfer

count = 0
for info in students.values():
    for grade in info["grades"]:
        if grade > 80:
            count += 1

De binnenste lus doorloopt Ana’s 88 en 92, daarna Bens 75, 81 en 79. Cara’s lege lijst levert geen doorgangen op. Drie cijfers zijn hoger dan 80: 88, 92 en 81. De telling wordt buiten beide lussen geïnitialiseerd omdat die alle studenten samen beschrijft. Als je die binnen de buitenste lus opnieuw zou instellen, zou alleen de telling van het laatste record overblijven.

Tel records op basis van een veld

majors = {}
for info in students.values():
    major = info["major"]
    majors[major] = majors.get(major, 0) + 1

Elk record telt één op bij zijn studierichting. Voor alleen Ana en Ben is het resultaat {'math': 1, 'history': 1}; als Cara meetelt, komt daar 'art': 1 bij. Om een ander veld op te tellen of te groeperen, behoud je de buitenste lus over records en verander je de waarde die het record bijdraagt.

Druk voor leesbare rapporten één opgemaakte regel per record af in plaats van de hele geneste dictionary. Sla in een f-string een veld eerst op in een variabele, zoals hierboven, of gebruik het andere type aanhalingstekens binnen de accolades, zoals in f"{name}: {info['major']}".

Een verzameling houdt bij welke verschillende waarden aanwezig zijn. Elk element komt er één keer in voor en de volgorde is niet gegarandeerd. Verzamelingen zijn geschikt voor lidmaatschapscontroles en voor het verwijderen van duplicaten wanneer het aantal voorkomens niet van belang is.

Maak een verzameling

colors = {"red", "green"}
numbers = set([3, 1, 3, 2, 1])
print(len(numbers))
print(sorted(numbers))

Dit drukt 3 en daarna [1, 2, 3] af. Herhaalde invoer wordt één element. Een lege verzameling is set(); {} maakt een lege dictionary.

set("banana") doorloopt de tekens van de string en houdt de verschillende letters "a", "b" en "n" over. {"banana"} geeft de hele string als één element. Net als bij dictionarysleutels tellen gelijke numerieke waarden één keer: {1, 1.0, True} heeft één element.

Elementen moeten hashbaar zijn. Getallen, strings en tuples van hashbare waarden werken; lijsten, dictionary’s en gewone verzamelingen niet. Gebruik (1, 2) als coördinatenelement in plaats van [1, 2]. Een frozenset is een onwijzigbare verzameling en kan zelf een element van een verzameling of een dictionarysleutel zijn.

Werk zonder posities

colors[0] werpt TypeError op omdat een verzameling geen posities heeft. De afdrukvolgorde is niet gegarandeerd en stringelementen kunnen bij een andere uitvoering in een andere volgorde verschijnen. sorted(colors) maakt een nieuwe gesorteerde lijst als de elementen vergelijkbaar zijn. Het geeft de verzameling zelf geen volgorde.

Wijzig de elementen

add("blue") voegt één string toe. update(["blue", "gold"]) voegt twee strings toe. update("blue") voegt daarentegen afzonderlijke tekens toe, omdat een string itereerbaar is. Verzamelingen hebben geen methode append.

Behoud zo nodig de volgorde van eerste voorkomens

list(set(items)) verwijdert duplicaten, maar verliest de oorspronkelijke volgorde. Als de volgorde van eerste voorkomens belangrijk is, gebruik je de invoegvolgorde van een dictionary:

items = [3, 1, 3, 2, 1]
unique = list(dict.fromkeys(items))
print(unique)

Dit drukt [3, 1, 2] af. De waarden worden dictionarysleutels, zodat elke waarde één keer verschijnt in de volgorde waarin ze voor het eerst voorkwam.

Je kunt de rollen ook expliciet houden:

seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

De verzameling geeft aan of een element al is voorgekomen; de lijst bewaart de eerste voorkomens op volgorde. Beide vormen vereisen hashbare invoerelementen.

Tel verschillende elementen of controleer lidmaatschap

Voor de acht woorden in "the cat saw the dog the dog ran".split() is len(set(words)) gelijk aan 5: the, cat, saw, dog en ran. Dit telt verschillende woorden, niet hoe vaak ze voorkomen.

Met een verzameling van geblokkeerde afzenders geeft sender in blocked aan of een adres aanwezig is. Bij grote collecties is een lidmaatschapscontrole op een verzameling of dictionary doorgaans veel sneller dan een lijst element voor element doorzoeken.

Verzamelingsbewerkingen drukken vragen uit over lidmaatschap van twee collecties. Gebruik de bewerking die bij de vraag past: iedereen in de ene of de andere collectie, alleen gedeelde leden of leden die na uitsluiting overblijven.

Bekijk de vier bewerkingen

Stel dat de cursusinschrijvingen zijn:

python = {"Ana", "Ben", "Cara", "Dev"}
sql = {"Ben", "Dev", "Eli"}

De vereniging bevat alle vijf studenten één keer. De doorsnede bevat alleen de twee gedeelde studenten. Het verschil begint bij de linkerverzameling en sluit alles uit wat in de rechterverzameling zit. Als je het verschil omkeert, verandert de vraag: sql - python bevat alleen Eli. Het symmetrisch verschil bevat de twee niet-overlappende delen; het is gelijk aan de vereniging min de doorsnede.

De benoemde vormen zijn python.union(sql), python.intersection(sql), python.difference(sql) en python.symmetric_difference(sql).

Toets een relatie

a <= b vraagt of elk element van a tot b behoort. Dat is de deelverzamelingstoets. a < b vereist bovendien dat b ten minste één extra element heeft, waardoor a een echte deelverzameling is. a >= b en a > b toetsen de bijbehorende relaties voor bovenverzamelingen.

print({"Ben"} <= sql)
print(sql <= sql)
print(sql < sql)
print(python.isdisjoint(sql))

Dit drukt True, True, False en False af. Een verzameling is een deelverzameling van zichzelf, maar geen echte deelverzameling van zichzelf. Disjuncte verzamelingen hebben geen gedeelde elementen; Python en SQL delen Ben en Dev. De methodevormen issubset en issuperset geven ook booleaanse resultaten terug.

Houd resultaten afzonderlijk of wijzig een verzameling

result = a | b maakt een nieuwe verzameling en laat beide invoerverzamelingen ongewijzigd. De vormen voor bewerking ter plaatse a |= b, a &= b, a -= b en a ^= b veranderen a in de vereniging, doorsnede, het verschil of het symmetrisch verschil. Elke andere naam die naar dezelfde verzameling verwijst, ziet de wijziging.

Benoemde verzamelingsmethoden accepteren itereerbare objecten zoals lijsten. python.union(["Fay"]) werkt. De gewone verzamelingsoperatoren vereisen verzamelingen als operanden: {"a"} | ["b"] werpt TypeError op.

Gebruik | om verzamelingen te combineren, niet +. Houd ook & en and uit elkaar: {1, 2} and {3} geeft {3} terug omdat de linkerverzameling als waar wordt beschouwd. Het berekent geen gemeenschappelijke elementen.

Vind ontbrekende vereisten

required = {"python", "sql", "git"}
skills = {"python", "excel", "git"}
missing = required - skills
extra = skills - required
qualified = required <= skills

De verzameling met ontbrekende vaardigheden bevat "sql"; de verzameling met extra vaardigheden bevat "excel". De doorsnede bevat "git" en "python". qualified is False, omdat ten minste één vereiste vaardigheid ontbreekt. Een kandidaat kan veel vaardigheden hebben en toch niet slagen voor de deelverzamelingstoets: alle specifieke vereiste elementen moeten aanwezig zijn.

Kies een collectie op basis van wat het programma ermee moet doen. Volgorde, herhalingen, opzoeken op naam en wijzigbaarheid zijn afzonderlijke behoeften. Een programma kan meerdere collectietypen gebruiken omdat verschillende delen van de gegevens verschillende taken dienen.

Vergelijk de ingebouwde collecties

Een lijst past bij een reeks gebeurtenissen: de volgorde is belangrijk en dezelfde gebeurtenis kan meer dan eens voorkomen. Een tuple past bij een vaste groep samenhangende waarden, zoals coördinaten. Een tuple kan een wijzigbaar object bevatten, dus de vaste plaatsen van de tuple maken niet elk object erin onwijzigbaar. Alleen een tuple met hashbare elementen kan een dictionarysleutel of een element van een verzameling zijn.

Een dictionary past bij benoemde informatie: een ID leidt naar een record of een productnaam leidt naar een hoeveelheid. De waarden mogen zich herhalen en kunnen volledige collecties zijn. Een verzameling past bij een lidmaatschapsvraag: het programma moet weten of een ID aanwezig is, zonder een afzonderlijke waarde ervoor nodig te hebben.

Behoud de informatie die de taak nodig heeft

Als je [1, 2, 1] omzet naar een verzameling, verlies je zowel het herhaalde voorkomen als de volgorde. Dat is nuttig voor een lijst van verschillende elementen, maar onjuist voor een volledig gebeurtenissenlogboek. Een dictionary zoals {"reader": True, "editor": True} kan vaak worden vervangen door {"reader", "editor"} als de waarden geen aanvullende informatie bevatten. Als elke rol een machtigingsniveau nodig heeft, behoud je de dictionary.

Gelijkheid volgt de betekenis van elke collectie. [1, 2] == [2, 1] is False, omdat de volgorde verschilt. {1, 2} == {2, 1} is True. Dictionary’s met gelijke sleutel-waardeparen zijn bij vergelijking gelijk, ook als de sleutels in een andere volgorde zijn ingevoegd. Hun invoegvolgorde beïnvloedt het itereren, niet die gelijkheidstoets.

Vergelijk dictionarysleutels als verzamelingen

store_a = {"pens": 10, "pads": 4, "ink": 2}
store_b = {"pads": 7, "clips": 30, "ink": 5}
common = store_a.keys() & store_b.keys()
only_a = store_a.keys() - store_b.keys()

De gemeenschappelijke sleutels zijn "ink" en "pads"; only_a bevat "pens". Dit zijn producten die worden verkocht, ongeacht hun hoeveelheden. De twee winkels hebben verschillende hoeveelheden inkt, maar inkt is nog steeds een gedeelde sleutel.

Sleutelweergaven van dictionary’s ondersteunen verzamelingsbewerkingen omdat sleutels uniek en hashbaar zijn. Waardeweergaven ondersteunen deze operatoren niet: store_a.values() & {1} werpt TypeError op. Waarden naar een verzameling omzetten is mogelijk als ze hashbaar zijn, maar verwijdert herhaalde waarden en stelt een andere vraag dan het vergelijken van productsleutels.

Combineer structuren in één programma

Een bibliotheek kan een dictionary gebruiken die boek-ID’s aan recorddictionary’s koppelt, een verzameling van momenteel uitgeleende ID’s en een lijst van de uitleningen van vandaag in tijdvolgorde. Een tuple zoals ("Dune", 1965) houdt een titel en jaar bij elkaar. De dictionary vindt de gegevens van een boek; de verzameling controleert de uitleenstatus; de lijst bewaart de geschiedenis van de dag.