Kihagyás

Dictionary, rekurzió

Tartalom

A Python dict adattípusa. Rekurzió. Feladatmegoldások dict és rekurzió segítségével.

A szótárak (dict) alapjai

A szótár (dictionary) egy olyan adatszerkezet, amely kulcs-érték párokat tárol.
Minden kulcshoz (key) egy érték (value) tartozik, és a kulcsok egyediek.

Szótár létrehozása

A szótárakat kapcsos zárójelekkel ({}) hozhatjuk létre, ahol a kulcsokat és értékeket kettőspont (:) választja el.

Egyszerű szótár 
1
2
3
4
5
6
7
diak = {
    "nev": "Anna",
    "kor": 20,
    "varos": "Szeged"
}

print(diak)

Kimenet

1
{'nev': 'Anna', 'kor': 20, 'varos': 'Szeged'}

Üres szótár létrehozása: 

1
ures = {}

vagy

1
ures = dict()

Kulcsok egyedisége

Egy kulcs csak egyszer szerepelhet a szótárban. Ha újra megadjuk ugyanazt a kulcsot, az felülírja a kulcs korábbi értéket.

Értékek elérése és módosítása

A szótárban az értékeket kulcs alapján érhetjük el.

Érték lekérdezése 
1
2
3
4
diak = {"nev": "Anna", "kor": 20}

print(diak["nev"])
print(diak.get("kor"))

Kimenet

1
2
Anna
20

Az [] használata hibát dob, ha a kulcs nem létezik. A get() ezzel szemben biztonságosabb, és visszaadhat egy alapértelmezett értéket is:

1
print(diak.get("varos", "ismeretlen"))  # ismeretlen
Érték módosítása vagy hozzáadása 
1
2
3
4
5
diak = {"nev": "Anna", "kor": 20}
print(diak)
diak["kor"] = 21           # meglévő kulcs értékének módosítása
diak["varos"] = "Szeged"   # új kulcs hozzáadása
print(diak)

Kimenet

1
2
{'nev': 'Anna', 'kor': 20}
{'nev': 'Anna', 'kor': 21, 'varos': 'Szeged'}

Kulcsok, értékek, elemek bejárása

Bejárás kulcsokkal 
1
2
3
4
diak = {"nev": "Anna", "kor": 20, "varos": "Szeged"}

for kulcs in diak: # vagy diak.keys()
    print(kulcs)

Kimenet

1
2
3
nev
kor
varos
Bejárás kulcs-érték párokkal 
1
2
for kulcs, ertek in diak.items():
    print(kulcs, "->", ertek)

Kimenet

1
2
3
nev -> Anna
kor -> 20
varos -> Szeged

A legfontosabb függvények:

  • diak.keys() - csak a kulcsok
  • diak.values() - csak az értékek
  • diak.items() - kulcs-érték párok

Elem törlése

Törlés különböző módokon 
1
2
3
4
5
diak = {"nev": "Anna", "kor": 20, "varos": "Szeged"}

del diak["varos"]      # adott kulcs törlése
diak.pop("kor")        # adott kulcs törlése, érték visszaadásával
diak.clear()           # az összes elem törlése

A pop() hasznos

A pop(kulcs) visszaadja a törölt értéket, így akár el is mentheted vagy felhasználhatod.

Beágyazott szótárak

Szótárak értékei lehetnek más szótárak is. Ez lehetővé teszi összetettebb adatszerkezetek létrehozását.

Beágyazott szótár 
1
2
3
4
5
6
diakok = {
    "Anna": {"kor": 20, "varos": "Szeged"},
    "Béla": {"kor": 22, "varos": "Pécs"}
}

print(diakok["Anna"]["varos"])

Kimenet

1
Szeged

Gyakori műveletek

Művelet Leírás Példa
len(d) Elemszám len(diak)
"kulcs" in d Ellenőrzi, van-e kulcs "nev" in diak
d.update(masik_dict) Összefűzés / frissítés diak.update({"kor": 21})
d.copy() Másolat készítése masolat = diak.copy()

Rekurzió alapjai

A rekurzió azt jelenti, hogy egy függvény saját magát hívja meg a megoldás során. Ez különösen hasznos olyan problémáknál, amelyek ugyanarra a logikára épülnek kisebb részfeladatokban is.

Alapötlet

Minden rekurzív függvénynek két része van:

  1. Alapeset (base case) - amikor a függvény nem hívja meg magát újra, hanem visszatér egy eredménnyel.
  2. Rekurzív eset (recursive case) - amikor a függvény újra meghívja önmagát a probléma egy kisebb részével.
Egyszerű rekurzív példa - visszaszámlálás 
1
2
3
4
5
6
7
8
def visszaszamlal(n):
    if n == 0:
        print("Bumm!")
    else:
        print(n)
        visszaszamlal(n - 1)

visszaszamlal(5)

Kimenet

1
2
3
4
5
6
5
4
3
2
1
Bumm!

További példák rekurzióra

Fibonacci-sorozat 
1
2
3
4
5
6
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(6))

Kimenet

1
8
Lista elemeinek összege 
1
2
3
4
5
6
def lista_osszeg(lista):
    if not lista:
        return 0
    return lista[0] + lista_osszeg(lista[1:])

print(lista_osszeg([1, 2, 3, 4]))

Kimenet

1
10

Rekurzió és iteráció

A rekurzió átláthatóbb, de néha lassabb, mint a ciklusos megoldás. Mindig legyen alapeset, különben a függvény végtelenül hívná önmagát.

Feladatok szótárakhoz és rekurzióhoz

1. feladat - Diák adatai

Készíts egy szótárat, amely tartalmazza egy diák nevét, életkorát és városát, majd írd ki az adatokat egyesével!

Példamegoldás 
1
2
3
diak = {"nev": "Anna", "kor": 20, "varos": "Szeged"}
for kulcs, ertek in diak.items():
    print(kulcs, ":", ertek)
2. feladat - Szótár módosítása

Készíts egy szótárat filmekről és pontszámokról. Adj hozzá egy új filmet, majd módosítsd az egyik pontszámát!

Példamegoldás 
1
2
3
4
filmek = {"Inception": 9, "Titanic": 8}
filmek["Matrix"] = 10
filmek["Titanic"] = 7
print(filmek)
3. feladat - Közös kulcsok

Adott két szótár, amelyek termékeket és áraikat tartalmazzák.
Írd ki, mely termékek szerepelnek mindkettőben!

Példamegoldás 
1
2
3
4
5
bolt1 = {"alma": 300, "körte": 250, "banán": 400}
bolt2 = {"banán": 420, "alma": 290, "szilva": 500}

kozos = set(bolt1.keys()) & set(bolt2.keys())
print("Mindkettőben:", kozos)
4. feladat - Legnagyobb érték

Készíts egy szótárat pontszámokkal, és írd ki, melyik kulcshoz tartozik a legnagyobb érték!

Példamegoldás 
1
2
3
pontok = {"Anna": 85, "Béla": 92, "Csaba": 78}
legjobb = max(pontok, key=pontok.get)
print("Legjobb diák:", legjobb)
5. feladat - Beágyazott szótár kezelése

Készíts egy szótárat, amely több diák adatait tárolja (név → {kor, város}).
Írd ki az összes diák nevét és városát!

Példamegoldás 
1
2
3
4
5
6
7
diakok = {
"Anna": {"kor": 20, "varos": "Szeged"},
"Béla": {"kor": 21, "varos": "Debrecen"}
}

for nev, adatok in diakok.items():
    print(nev, "->", adatok["varos"])
6. feladat - Összeg számítása

Írj rekurzív függvényt, amely kiszámolja az első n szám összegét!

7. feladat - Faktoriális

Írj függvényt, amely kiszámolja egy szám faktoriálisát rekurzívan!

8. feladat - Lista elemeinek összege

Írj rekurzív függvényt, amely egy lista összes elemét összeadja!

9. feladat - Fibonacci-szám

Írj függvényt, amely visszaadja az n-edik Fibonacci-számot!

Összefoglalás

A szótár (dict) az egyik leghasznosabb adattípus Pythonban, mivel:

  • kulcs-érték párokat tárol,
  • gyorsan elérhetők az adatok kulcs alapján,
  • rugalmasan bővíthető és módosítható,
  • beágyazott formában összetett adatok is kezelhetők.

A rekurzió pedig egy alapvető programozási technika, amely:

  • lehetővé teszi, hogy a függvény saját magát hívja meg,
  • ideális ismétlődő szerkezetű problémákhoz (pl. faktoriális, fában keresés, Fibonacci),
  • a kulcs az alapeset meghatározása, hogy a végtelen hívás elkerülhető legyen.

A szótárak és a rekurzió ismerete erős alapot ad az adatszerkezetek és algoritmusok megértéséhez.