Új lapon nyílik meg

6. lecke

Listák és szótárak

9 rész25 kódpélda1 ábra
Miről szól ez a lecke?

A valódi programok nem egy-két értékkel, hanem sok adattal dolgoznak. Ez a lecke a Python két legfontosabb adattárolóját mutatja be: a listát, amely sorszám (index) szerint tárolja az elemeket, és a szótárat, amely névvel ellátott kulcsokhoz rendel értékeket. Megtanulod az elemek elérését és módosítását, a rajtuk való végighaladást, és a gyakran használt „lista szótárakkal" mintát.

Amit ebben a leckében megtanulsz
  • Mi az a lista?
  • Elemek elérése — indexelés
  • Lista módosítása
  • Végigmenni egy listán — for ciklussal
  • Mi az a szótár (dictionary)?
  • Értékek elérése a szótárban
  • Szótár módosítása
  • Végigmenni egy szótáron
  • Lista szótárakkal — gyakori minta
Tudnivalók
  • Olvasási idő: kb. 5 perc (a kódok kipróbálásával több)
  • 9 rész · 25 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat
Lista sorszámozott cellákkal és szótár kulcs-érték párokkal
Két alapvető adattároló: a lista sorszám (index) szerint tartja az elemeket 0-tól, a szótár pedig névre szóló kulcsokkal — mint egy telefonkönyv.

1. Mi az a lista?

PYTHON● ● ●
nevek = ["Anna", "Béla", "Csilla"]
szamok = [10, 25, 3, 47, 8]
PYTHON● ● ●
print(nevek)
print(szamok)
SzéljegyzetMi történik a memóriában, amikor egy listát létrehozok?

Míg egy sima változó (kor = 27) egyetlen memóriahelyre mutat, egy lista valójában egy "dobozsor" — a Python lefoglal annyi (összekapcsolt) helyet a memóriában, amennyi elem van a listában, és a "nevek" címke az egész sorozatra mutat. Fontos tudni: a lista mérete rugalmas — ha később hozzáadsz egy elemet (.append(), lásd lejjebb), a Python a háttérben szükség esetén új, nagyobb helyet foglal, és átmásolja oda a tartalmat. Ez teszi lehetővé, hogy a lista hossza menet közben változhasson, míg pl. egy sima szám vagy szöveg mérete "fix" a memóriában.

SzéljegyzetLehet egyszerre több elemet is kivenni egy listából, nem csak egyet?

Igen, ezt hívják szeletelésnek (slicing): nevek[1:3] az 1-es és 2-es indexű elemeket adja vissza egy új listaként — a 3-as indexű már nem kerül bele, ugyanaz a "felső határ kizárt" szabály, mint a range()-nél. A nevek[:2] az elejétől, a nevek[1:] pedig egy adott ponttól a végéig szeletel.

2. Elemek elérése — indexelés

PYTHON● ● ●
nevek = ["Anna", "Béla", "Csilla"]
PYTHON● ● ●
print(nevek[0])   # "Anna" — az első elem
print(nevek[1])   # "Béla" — a második elem
print(nevek[2])   # "Csilla" — a harmadik elem
PYTHON● ● ●
print(nevek[-1])  # "Csilla" — az utolsó elem
print(nevek[-2])  # "Béla" — az utolsó előtti

Miért 0-tól indul az indexelés (emlékezz az 5. leckére, ez ugyanaz az elv), és hogyan működik a negatív index? A negatív index egy kényelmi megoldás, amit a Python készítői építettek be: ahelyett, hogy ki kellene számolnod a lista pontos hosszát ahhoz, hogy elérd az utolsó elemet (pl. nevek[len(nevek) - 1]), egyszerűen írhatsz nevek[-1]-et, ami "hátulról az elsőt" jelenti. A Python belsőleg ezt úgy oldja meg, hogy ha negatív számot lát indexként, hozzáadja a lista hosszát ehhez a számhoz (pl. egy 3 elemű listánál a -1 valójában 3 + (-1) = 2-t jelent, ami pontosan az utolsó elem "normál" indexe). Ez egy tiszta programozói kényelem, nem valami "másik számolási rendszer".

3. Lista módosítása

PYTHON● ● ●
nevek = ["Anna", "Béla", "Csilla"]
PYTHON● ● ●
nevek.append("Dénes")        # hozzáad a lista végéhez
print(nevek)                 # ["Anna", "Béla", "Csilla", "Dénes"]
PYTHON● ● ●
nevek[0] = "Andrea"          # felülírja az első elemet
print(nevek)                 # ["Andrea", "Béla", "Csilla", "Dénes"]
PYTHON● ● ●
nevek.remove("Béla")         # eltávolítja a "Béla" elemet
print(nevek)                 # ["Andrea", "Csilla", "Dénes"]
PYTHON● ● ●
print(len(nevek))            # 3 — a lista hossza (elemszám)

Mi a különbség a nevek.append(...) és a nevek[0] = ... között — miért néz ki másképp a két módosítás? Ez egy fontos, finom különbség: a nevek[0] = "Andrea" egy már létező helyet ír felül (ott, ahol eddig "Anna" volt) — ez olyan, mintha kicserélnéd egy már meglévő doboz tartalmát. A nevek.append("Dénes") viszont egy metódus hívás (a pont utáni rész egy, a listához "tartozó" függvény, amit majd részletesebben az objektum-orientált programozásnál tanulhatsz meg, de egyelőre elég annyit tudni: ez egy beépített képessége minden listának) — ez egy teljesen új helyet hoz létre a lista végén, és oda teszi az új elemet, megnövelve a lista méretét. A .remove() hasonlóan egy metódus, ami megkeresi a megadott értéket a listában, és ha megtalálja, eltávolítja azt, majd "összecsúsztatja" a mögötte lévő elemeket, hogy ne maradjon "lyuk" a listában.

Mit csinál pontosan a len()? A len() egy beépített függvény (nem csak listákra, hanem szövegekre, szótárakra is működik), ami megszámolja, hány elem van a megadott dologban. Listánál ez az elemek száma, szövegnél a karakterek száma. Ez azért hasznos, mert a lista mérete (mint fentebb írtuk) dinamikusan változhat, így nem tudhatod előre, fixen "beégetve" a kódba, hány elem lesz benne — a len() mindig a jelenlegi, aktuális méretet adja vissza.

SzéljegyzetHogyan tudom gyorsan megnézni, hogy egy elem benne van-e egy listában, anélkül hogy végig kéne ciklizálnom?

Erre való az in kulcsszó: "Anna" in nevek egyetlen lépésben megadja, hogy True vagy False — tehát benne van-e az elem a listában. Szótárnál ugyanez a kulcsokra vonatkozik: "kor" in szemely.

4. Végigmenni egy listán — for ciklussal

PYTHON● ● ●
gyumolcsok = ["alma", "banán", "körte"]
PYTHON● ● ●
for gyumolcs in gyumolcsok:
    print("Gyümölcs:", gyumolcs)

5. Mi az a szótár (dictionary)?

PYTHON● ● ●
szemely = {
    "nev": "Norbi",
    "kor": 27,
    "varos": "Veszprém"
}
PYTHON● ● ●
print(szemely)

Miért van szükség szótárra, ha már van listánk? Mi a valódi különbség? Ez egy kulcsfontosságú különbség: egy listában az elemek sorrendje (pozíciója) hordozza a jelentést — a nevek[0] azért érthető, mert tudod, hogy az "első" elem a lista elején van. Egy szótárban viszont nincs "sorrend alapú" jelentés — helyette minden értékhez egy saját, egyedi kulcsot (nevet) rendelünk, és ezen a néven keresztül érjük el. Ez akkor előnyös, amikor az adatok különböző típusú, nevesített tulajdonságokat írnak le (mint egy személy neve, kora, városa) — sokkal olvashatóbb és biztonságosabb szemely["kor"]-t írni, mint szemely[1]-et, ahol el kellene emlékezned, hogy pontosan a második pozíción van a kor.

A háttérben a szótár egy speciális adatszerkezetet (hash táblát) használ, ami azt jelenti, hogy egy adott kulcshoz tartozó érték megtalálása rendkívül gyors, akkor is, ha a szótárban emberileg belegondolva rengeteg kulcs-érték pár van — nem kell "végigkeresgélnie" az összeset, hanem szinte azonnal "tudja", hol keresse.

6. Értékek elérése a szótárban

PYTHON● ● ●
szemely = {
    "nev": "Norbi",
    "kor": 27,
    "varos": "Veszprém"
}
PYTHON● ● ●
print(szemely["nev"])     # "Norbi"
print(szemely["kor"])     # 27
print(szemely["varos"])   # "Veszprém"
SzéljegyzetMiért szögletes zárójel [ ] a kulcsnál, ha ez nem is 'index' a hagyományos értelemben?

Jó megfigyelés — a Python tudatosan ugyanazt a jelölésmódot (szögletes zárójel) használja listáknál és szótáraknál is, mert a mögöttes gondolat hasonló: "add meg, mi alapján keressem meg az elemet." listánál ez egy szám (pozíció), szótárnál egy kulcs (szöveg vagy más érték) — de a Python "filozófiája" szerint mindkettő egyfajta "elérési módnak" számít, ezért kapják ugyanazt a szintaxist.

SzéljegyzetVan mód elkerülni a KeyError-t, ha nem vagyok biztos benne, hogy létezik-e egy kulcs?

Igen, a .get() metódus erre való: szemely.get("telefonszam") hibaüzenet helyett egyszerűen None-t ad vissza, ha a kulcs nem létezik — vagy megadhatsz egy alapértelmezett értéket is: szemely.get("telefonszam", "nincs megadva").

7. Szótár módosítása

PYTHON● ● ●
szemely = {
    "nev": "Norbi",
    "kor": 27
}
PYTHON● ● ●
szemely["kor"] = 28              # meglévő érték módosítása
print(szemely)
PYTHON● ● ●
szemely["varos"] = "Veszprém"    # új kulcs-érték pár hozzáadása
print(szemely)
PYTHON● ● ●
del szemely["kor"]               # kulcs-érték pár törlése
print(szemely)

Honnan tudja a Python, hogy a szemely['varos'] = ... egy új kulcsot hoz létre, míg a szemely['kor'] = 28 egy meglévőt módosít — nem ugyanaz a szintaxis? A Python egyszerű szabályt követ: megnézi, létezik-e már az adott kulcs a szótárban. Ha igen, felülírja az ahhoz tartozó értéket (ez történt a "kor"-nál). Ha nem létezik még, létrehoz egy vadonatúj kulcs-érték párt (ez történt a "varos"-nál). Ez egy tudatos kényelmi döntés — nem kell két külön parancsot ismerned "módosításra" és "létrehozásra", a Python automatikusan eldönti, melyikre van szükség.

8. Végigmenni egy szótáron

PYTHON● ● ●
szemely = {
    "nev": "Norbi",
    "kor": 27,
    "varos": "Veszprém"
}
PYTHON● ● ●
for kulcs in szemely:
    print(kulcs, ":", szemely[kulcs])
PYTHON● ● ●
for kulcs, ertek in szemely.items():
    print(kulcs, "->", ertek)

Mit csinál pontosan az .items(), és miért kell két változó (kulcs, ertek) a for után? Az .items() egy metódus, ami a szótár minden egyes kulcs-érték párját egy párosított formában adja vissza (a szakmában ezt "tuple"-nek, magyarul "rendezett párnak" hívják). Amikor azt írod: for kulcs, ertek in szemely.items():, a Python minden körben szétbontja ezt a párost — a párosítás első eleme a "kulcs" változóba, a második eleme az "ertek" változóba kerül. Ez egy elterjedt Python-mintázat, amit "szétcsomagolásnak" (unpacking) hívnak — a lényeg, hogy egyetlen sorban, kényelmesen hozzáférhetsz mindkét adathoz egyszerre, külön-külön kezelve azokat.

9. Lista szótárakkal — gyakori minta

PYTHON● ● ●
emberek = [
    {"nev": "Anna", "kor": 25},
    {"nev": "Béla", "kor": 30},
    {"nev": "Csilla", "kor": 22}
]
PYTHON● ● ●
for ember in emberek:
    print(ember["nev"], "-", ember["kor"], "éves")

Miért pont ez a kombináció (lista + szótárak) olyan gyakori — mi teszi ezt különlegessé? Ez a mintázat pontosan azt a struktúrát tükrözi, ahogy a valós világ adatai gyakran néznek ki: egy táblázat (pl. Excel-tábla, vagy egy adatbázis-tábla), ahol minden sor egy "dolgot" (pl. egy embert, egy terméket, egy megrendelést) ír le, és minden sornak ugyanazok a nevesített tulajdonságai (oszlopai) vannak. A "lista" itt a táblázat egészét jelenti (az összes sort), a "szótár" pedig egy-egy sort (egy konkrét ember adatait). Ez a minta olyan gyakran előfordul, hogy amikor majd a Pandas-t tanuljuk (11. lecke), rá fogsz jönni: a Pandas "DataFrame" nevű adatszerkezete valójában ugyanezt a gondolatot valósítja meg, csak sokkal kényelmesebb, kifinomultabb eszközökkel.

Gyakorlás
  1. Hozz létre egy listát a kedvenc ételeidből (legalább 4 elemmel), majd írasd ki for ciklussal mindegyiket.
  2. Hozz létre egy szótárat, ami egy autó adatait tárolja (márka, típus, évjárat), és írasd ki mindhármat.
  3. Hozz létre egy listát 3 szótárral, ami 3 különböző autó adatait tartalmazza, majd for ciklussal írasd ki mindegyiket egy szép mondatba foglalva.
  4. Új gyakorlat: próbálj meg elérni egy olyan kulcsot a szemely szótárban, ami nem létezik (pl. print(szemely["telefonszam"])) — nézd meg pontosan, milyen hibaüzenetet kapsz, és gondold át, miért pont ilyen hibát ad (összevetve azzal, mi történne egy listánál, ha egy nem létező indexet kérnél le).