Szótárak.

A listában az elemeket sorszámuk (indexük) alapján érjük el. Sokszor azonban természetesebb egy név szerint keresni: egy diák jegye a diák neve alapján, egy termék ára a termék neve alapján, egy szó jelentése a szó alapján. Erre való a szótár.

diak = {
    "nev": "Kiss Anna",
    "kor": 17,
    "varos": "Pécs",
}
print(diak["nev"])
print(diak["kor"] + 1)
print(len(diak))
print(diak)

Kövesd lépésenként: a Memóriában a szótár egy kétoszlopos táblázatként jelenik meg, bal oldalon a kulcsokkal, jobb oldalon az értékekkel. A szótár megőrzi a beszúrás sorrendjét, de indexe nincs: a diak[0] nem az első elemet jelenti, hanem a 0 kulcsot keresi.

Nem létező kulcsra a szotar[kulcs] KeyError-t ad. Ha nem vagyunk biztosak benne, hogy a kulcs létezik, két biztonságos út van:

• kulcs in szotar – megvizsgálja, hogy a kulcs benne van-e (a kulcsok között keres, nem az értékek között);
• szotar.get(kulcs) – az értéket adja, nem létező kulcsnál pedig None-t; szotar.get(kulcs, alap) ilyenkor az alap értéket.

arak = {"alma": 450, "körte": 620, "banán": 590}
termek = input("Melyik termék ára érdekel? ")
if termek in arak:
    print(f"A(z) {termek} ára {arak[termek]} Ft/kg.")
else:
    print("Ilyen termékünk nincs.")
print("Szilva:", arak.get("szilva"))
print("Szilva:", arak.get("szilva", "nincs készleten"))

arak = {"alma": 450, "körte": 620}
print(arak["szilva"])

d = {"a": 1, "b": 2}
print("a" in d, 1 in d, d.get("c", 0))

keszlet = {}
keszlet["alma"] = 120
keszlet["körte"] = 40
keszlet["alma"] = keszlet["alma"] - 20
keszlet.update({"szilva": 75, "körte": 55})
eladva = keszlet.pop("szilva")
print("Szilvát vittek:", eladva)
print(keszlet)

d = {}
for betu in "anna":
    d[betu] = d.get(betu, 0) + 1
d["a"] = 5
print(d)

A for k in d a kulcsokon megy végig. Ha az értékek kellenek, a d.values()-n, ha mindkettő, a d.items()-en – ez utóbbi párokat (tuple-öket) ad, amelyeket a ciklus fejében rögtön kicsomagolunk.

jegyek = {"Anna": 5, "Bence": 3, "Csilla": 4}
for nev in jegyek:
    print(nev, end=" ")
print()
print(list(jegyek.keys()))
print(list(jegyek.values()), "átlag:", sum(jegyek.values()) / len(jegyek))
for nev, jegy in jegyek.items():
    print(f"{nev}: {jegy}")
for nev in sorted(jegyek):
    print(nev, jegyek[nev])

Hányszor fordul elő egy-egy szó a szövegben? Hány tanuló kapott egyes, kettes, … ötös jegyet? A szótár kulcsai a „kategóriák”, az értékei a darabszámok. Minden elemnél eggyel növeljük a hozzá tartozó számlálót – ha a kulcs még nincs a szótárban, 0-ról indulva:

szoveg = input("Szöveg: ")
gyakorisag = {}
for szo in szoveg.lower().split():
    gyakorisag[szo] = gyakorisag.get(szo, 0) + 1
print(gyakorisag)

leggyakoribb = None
for szo, db in gyakorisag.items():
    if leggyakoribb is None or db > gyakorisag[leggyakoribb]:
        leggyakoribb = szo
print(f"Leggyakoribb: „{leggyakoribb}” ({gyakorisag[leggyakoribb]}×)")

A kulcssor a gyakorisag.get(szo, 0) + 1: ha a szó már szerepelt, a régi számlálóhoz ad egyet; ha nem, a 0 alapértékhez – így az első előfordulásnál 1 lesz. Kövesd lépésenként, és figyeld, ahogy a szótár sorai megjelennek és nőnek. A leggyakoribb szó keresése a 3. modul szélsőérték-mintája, csak most a szótár párjain. A leggyakoribb szó keresésénél a leggyakoribb is None feltétel az első kört ismeri fel: az is azt vizsgálja, hogy a két oldal ugyanaz az objektum-e – a None-ra mindig így kérdezünk rá.

Az érték bármi lehet – lista vagy újabb szótár is. Így írhatók le a valódi, többszintű adatok. Az elérés láncolt indexeléssel történik, kívülről befelé.

naplo = {
    "Anna": {"matematika": [5, 4, 5], "magyar": [4, 4]},
    "Bence": {"matematika": [3, 2], "magyar": [5, 4, 5]},
}
print(naplo["Anna"]["matematika"])
print(naplo["Anna"]["matematika"][-1])
naplo["Bence"]["matematika"].append(4)

for nev, tantargyak in naplo.items():
    for targy, jegyek in tantargyak.items():
        atlag = sum(jegyek) / len(jegyek)
        print(f"{nev:7} {targy:11} {jegyek}  átlag: {atlag:.2f}")

A lépésenkénti nézetben jól látszik a szerkezet: a naplo szótár értékei újabb szótárakra mutatnak, azok értékei pedig listákra.

Listában szótárak: rekordok

Táblázatszerű adatokat (sorok, mindegyikben ugyanazok a mezők) gyakran szótárak listájaként tárolunk – minden szótár egy „rekord”:

termekek = [
    {"nev": "laptop", "ar": 250000, "keszlet": 5},
    {"nev": "egér", "ar": 5000, "keszlet": 0},
    {"nev": "monitor", "ar": 65000, "keszlet": 12},
]
osszertek = 0
for t in termekek:
    if t["keszlet"] == 0:
        print(f"Elfogyott: {t['nev']}")
    osszertek += t["ar"] * t["keszlet"]
print(f"A raktár értéke: {osszertek} Ft")

Másolás többszintű adatnál

A copy() a szótárnál is sekély másolatot készít: új külső szótár jön létre, de az értékként tárolt listák közösek maradnak. Kövesd lépésenként, és figyeld a Memóriában a nyilakat:

jegyek = {"Anna": [5, 4], "Bence": [3]}
masolat = jegyek.copy()
masolat["Cili"] = [5]          # új kulcs: csak a másolatban
masolat["Anna"].append(2)      # a közös listát módosítja!
print(jegyek)
print(masolat)

Az új kulcs csak a másolatba került, Anna új jegye viszont mindkét szótárban megjelent, mert a két "Anna" kulcs ugyanarra a listára mutat. Ha a belső listákat is le kell másolni, arra a copy modul deepcopy() függvénye való (mély másolat).