Kihagyás

3. gyakorlat

A gyakorlat anyaga

Ezen a gyakorlaton áttekintjük a főbb tudnivalókat a Python két fontos adatszerkezetéről: a listáról és a dictionary-ről.

Lista

Pythonban nincs natív, statikus tömb adatszerkezet, ehelyett listát használunk.

A listára tekinthetünk egy dinamikus méretű tömbként - tetszőleges számú, nem feltétlen azonos típusú elemek tárolására alkalmas adatszerkezet.

Lista létrehozása

Pythonban a listákat létrehozhatjuk...

  • ...a list() beépített függvénnyel (ez tulajdonképpen egy konstruktor)
  • ...a listaelemek szögletes zárójelek közötti felsorolásával.

Példa: Lista létrehozása

1
2
3
4
ures1 = list()      # üres lista létrehozása (1. verzió)
ures2 = []          # üres lista létrehozása (2. verzió)

kutyak = ["Ubul", "Snoopy", "Scooby Doo"]   # stringeket tároló lista

Lista hosszának lekérdezése

Ha le szeretnénk kérdezni egy lista hosszát (azaz a listában található elemek számát), akkor ezt a múlt gyakorlaton megismert len() függvénnyel tudjuk megtenni.

1
2
kutyak = ["Ubul", "Snoopy", "Scooby Doo"]
print(len(kutyak))

Kimenet

3

Listaelemek indexelése

A listák elemeit a szokásos tömbindex operátorokkal tudjuk elérni: lista[index].

Az indexelés itt is 0-tól kezdődik. A múlt gyakorlaton a stringeknél tanult negatív, illetve intervallumos indexelés a listáknál is működik.

1
2
3
4
5
6
7
8
gyumolcsok = ["alma", "citrom", "barack", "pomeló"]

print(gyumolcsok[0])        # a legelső listaelem
print(gyumolcsok[-1])       # az utolsó listaelem
print(gyumolcsok[1:3])      # az 1-3. indexű elemek
print(gyumolcsok[2:])       # az elemek a 2, indextől a lista végéig
print(gyumolcsok[:])        # a teljes lista
print(gyumolcsok[::2])      # minden második listaelem

Kimenet

alma pomeló ['citrom', 'barack'] ['barack', 'pomeló'] ['alma', 'citrom', 'barack', 'pomeló'] ['alma', 'barack']

Ha egy listát meg szeretnénk fordítani, akkor a stringeknél tanult trükköt itt is használhatjuk.

1
2
gyumolcsok = ["alma", "citrom", "barack", "pomeló"]
print(gyumolcsok[::-1])

Kimenet

['pomeló', 'barack', 'citrom', 'alma']

A stringekkel ellentétben a listáknál lehetőségünk van egy adott indexen lévő elem értékének módosítására (a stringek karaktereit nem tudtuk módosítani, hiszen a string egy immutable adattípus Pythonban).

1
2
3
4
gyumolcsok = ["alma", "citrom", "barack", "pomeló"]
gyumolcsok[1] = "görögdinnye"

print(gyumolcsok)

Kimenet

['alma', 'görögdinnye', 'barack', 'pomeló']

Listaelemek bejárása

Ha végig szeretnénk iterálni egy lista elemein, akkor ezt egy for ciklussal egyszerűen megtehetjük. Ha valakinek esetleg idegen az alábbi szintaxis, akkor ő az előző gyakorlat anyagában talál a Pythonbeli for-ciklusról részletesebb leírást.

1
2
3
4
gyumolcsok = ["alma", "citrom", "barack", "pomeló"]

for gyumi in gyumolcsok:
    print(gyumi)

Kimenet

alma citrom barack pomeló

Listaelem előfordulásának ellenőrzése

Az elem in lista szintaxissal egyszerűen ellenőrizhetjük, hogy elem szerepel-e a lista elemei között.

Példa: Szerepel-e Hulk a bosszúállók között?

1
2
3
4
bosszuallok = ["Thor", "Hulk", "Vízió", "Hangya", "Vasember"]

if "Hulk" in bosszuallok:
    print("Hulk a bosszúállók közé tartozik.")

Kimenet

Hulk a bosszúállók közé tartozik.

Adott indexű listaelem törlése

A del lista[i] szintaxissal törölhetjük a lista i. indexén található elemet.

Példa: A 2. indexű elem törlése egy listából

1
2
3
4
bosszuallok = ["Thor", "Hulk", "Vízió", "Hangya", "Vasember"]
del bosszuallok[2]

print(bosszuallok)

Kimenet

['Thor', 'Hulk', 'Hangya', 'Vasember']

Listakezelő függvények

Pythonban számos beépített függvényt használhatunk listák kezelésére. Néhány fontosabb:

  • lista.append(e): beszúrja az e elemet a lista végére
  • lista.insert(i, e): beszúrja az e elemet a lista i. indexére
  • lista.remove(e): törli a lista-ból az e elem legelső előfordulását
  • lista.sort(): rendezi a lista elemeit (helyben rendez!)
  • lista.clear(): kiüríti a lista-t.

Példa: Listakezelő függvények alkalmazása

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
bosszuallok = ["Thor", "Hulk", "Vízió", "Thor"]

bosszuallok.append("Hangya")    # hozzáfűzés a lista végéhez
print(bosszuallok)
bosszuallok.insert(0, "Vasember")   # beszúrás a lista elejére
print(bosszuallok)

bosszuallok.remove("Thor")      # a legelső "Thor"-t törli
bosszuallok.sort()              # rendezés (itt: ábécé-sorrend)
print(bosszuallok)

bosszuallok.clear()             # lista kiürítése
print(bosszuallok)

Kimenet

['Thor', 'Hulk', 'Vízió', 'Thor', 'Hangya'] ['Vasember', 'Thor', 'Hulk', 'Vízió', 'Thor', 'Hangya'] ['Hangya', 'Hulk', 'Thor', 'Vasember', 'Vízió'] []

Kérdés: Láthatjuk, hogy a fenti kódban remove() függvény csak a legelső "Thor"-t törli a listából. Hogyan lehetne elérni, hogy a listában szereplő összes "Thor"-t töröljük?

Válasz: Használjunk while ciklust! Mindaddig, amíg a "Thor" elem szerepel a listánkban, töröljünk ki mindig egy előfordulást.

1
2
3
4
5
6
bosszuallok = ["Thor", "Hulk", "Vízió", "Thor", "Hangya", "Thor", "Vasember"]

while "Thor" in bosszuallok:
    bosszuallok.remove("Thor")

print(bosszuallok)      # ebben már nem szerepel "Thor"

Kimenet

['Hulk', 'Vízió', 'Hangya', 'Vasember']

Dictionary

A dictionary (szótár) egy kulcs-érték párokat tartalmazó adatszerkezet, tulajdonképpen egy rendezetlen leképzés. Működését tekintve leginkább a Javából ismerős map-hez vagy a PHP-ban megismert asszociatív tömbhöz hasonlít.

Dictionary létrehozása

Pythonban egy dictionary-t létrehozhatunk...

  • ...a dict() beépített függvénnyel (ez tulajdonképpen egy konstruktor)
  • ...a kulcs-érték párok kapcsos zárójelek közti felsorolásával.

A kulcsot, illetve az ahhoz tartozó értéket kulcs: érték formában adjuk meg.

Adott kulcs egy dictionary-ben csak egyszer fordulhat elő, értékre ilyen megkötés nincs.

Példa: Dictionary-k létrehozása

1
2
3
4
5
ures1 = dict()  # üres dictionary létrehozása (1. verzió)
ures2 = {}      # üres dictionary létrehozása (2. verzió)

# kulcs-érték párokat tartalmazó dictionary
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }

Dictionary hosszának lekérdezése

A dictionary-k hosszát jó barátunkkal, a len() függvénnyel kérhetjük le.

1
2
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }
print(len(suti))

Kimenet

3

Dictionary elemeinek elérése

Ha le szeretnénk kérdezni egy dictionary adott kulcshoz tartozó értékét, akkor ezt Pythonban kétféleképpen tehetjük meg:

  1. Hagyományos tömbindexeléssel: dictionary_neve[kulcs]
  2. A get() metódus segítségével: dictionary_neve.get(kulcs)

A lényegi különbség a két módszer között, hogy ha a kérdéses kulcs nem szerepel a dictionary-ben, akkor hagyományos tömbindexeléssel hibát kapunk, míg get() metódus használata esetén nem (ekkor a get() metódus None értékkel tér vissza).

Tipp

Ha úgy gondoljuk, hogy előfordulhat, hogy a kérdéses kulcs nem szerepel a dictionary-ben, használjuk a get() metódust tömbindexelés helyett.

Példa: Dictionary elemeinek elérése

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }

# hagyományos tömbindexelés

print(suti["nev"])      
# print(suti["laktozmentes"])   # HIBA!!! (nem létező kulcs)

# get() metódus

print(suti.get("nev"))      
print(suti.get("laktozmentes")) 

Kimenet

dobostorta dobostorta None

A get() függvényt a gyakorlatban sokszor használják különböző aggregációk megvalósítására. Ilyenek lehetnek a különböző számlálással kapcsolatos feladatok vagy az alábbi példában bemutatott klaszterezéssel kapcsolatos konverzió.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
# elem és a hozzá tartozó klasztert tartalmazó dictionary

    clustering = {
        1: 'alma',
        2: 'körte',
        3: 'szilva',
        12: 'alma',
        23: 'körte',
        32: 'szilva',
        41: 'alma',
        42: 'körte',
        34: 'szilva'
    }

# célunk, hogy átalakítsuk úgy hogy az egyes klaszterhez tartozó elemeket külön listákba gyüjtsük.
# groups = {'alma': [1, 12, ...] }

    groups = {}
    for key, value in clustering.items():
        # ha létezik az adott klaszternek megfelelő lista akkor csak beletesszük az új elemet,
        # ha nincs még ilyen lista akkor létrehozzuk egy üres dictionary-val és utánna tesszük bele az elemet
        groups[value] = groups.get(value, []) + [key]

Ez a módszer leginkább akkor hasznos ha az elemek vagy klaszterek száma előre nem ismert így folyamatosan kell létrehzozni őket. Ez akkor fordul elő ha pl. felhasználótól vagy egyéb külső forrásból olvassuk be őket.

Műveletek dictionary-ken

Elem módosítása

A dictionary a listákhoz hasonlóan mutable (módosítható) adatszerkezet. Ha szeretnénk valamely kulcsához tartozó értéket módosítani, akkor ezt a szokásos tömbindexelés-értékadás kombinációval tehetjük meg.

Példa: Módosítsuk a süteményünk nevét

1
2
3
4
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }
suti["nev"] = "gyümölcskrémes"

print("A mai desszert:", suti["nev"])   

Kimenet

A mai desszert: gyümölcskrémes

Új elem hozzáadása

Ha egy dictionary-be be szeretnénk szúrni egy új kulcs-érték párt, akkor egyszerűen csak megadjuk az új elem kulcsára az értéket tömbindexelés segítségével:

dictionary_neve[uj_kulcs] = uj_ertek.

Példa: Tároljuk el a süti árát is a dictionary-ben

1
2
3
4
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }
suti["ar"] = 5200

print(suti["nev"], "ára:", suti["ar"], "HUF")

Kimenet

dobostorta ára: 5200 HUF

Elem törlése

Ha egy dictionary-ből szeretnénk egy adott kulcsú elemet törölni, akkor használhatjuk a del dictionary_neve[kulcs] szintaxist (ahol kulcs értelemszerűen a kérdéses kulcs).

Példa: Nem számít, hány szeletes a süti. Töröljük ki a "szeletek" kulcsú elemet.

1
2
3
4
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }
del suti["szeletek"]

print(suti) 

Kimenet

{'nev': 'dobostorta', 'elfogyott': False}

Kulcs előfordulásának ellenőrzése

A kulcs in dictionary_neve kifejezéssel ellenőrizhetjük, hogy kulcs szerepel-e a dictionary kulcsai között. Eredményül egy logikai értéket kapunk (igazat, ha szerepel a kulcs a dictionary-ben, hamisat, ha nem).

Példa: Ismerjük-e, hogy hány szeletes a süti?

1
2
3
4
5
6
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }

if "szeletek" in suti:
    print("A süteményünk", suti["szeletek"], "szeletes.")
else:
    print("Nem tudjuk, hogy hány szeletes a süti.")

Kimenet

A süteményünk 12 szeletes.

Próbáljuk ki a fenti kódot úgy is, hogy a suti dictionary-ből töröljük a "szeletek" kulcsú elemet még a feltételvizsgálat előtt.

Érték előfordulásának ellenőrzése

Ha nem a dictionary kulcsai, hanem értékei között keresünk, akkor az ertek in dictionary_neve.values() szintaxist használjuk. Ez igazat ad vissza, ha az ertek szerepel a dictionary értékei között, egyébként pedig hamisat.

1
2
3
4
suti = { "nev": "dobostorta", "szeletek": 12, "elfogyott": False }

if "dobostorta" in suti.values():
    print("Ma dobostortát eszünk.")

Kimenet

Ma dobostortát eszünk.

Dictionary bejárása

Egy dictionary-t legegyszerűbben egy for-ciklussal járhatunk be. Lehetőségünk van csak külön a kulcsokat vagy csak külön az értékeket bejárnunk, illetve bejárhatjuk a kulcs-érték párokat egyszerre is. Járjuk be a fent létrehozott süti dictionary-t!

Kulcsok bejárása
1
2
for kulcs in suti:
    print(kulcs)

Kimenet

nev szeletek elfogyott

Értékek bejárása
1
2
for ertek in suti.values():
    print(ertek)

Kimenet

dobostorta 12 False

Kulcsok és értékek együttes bejárása
1
2
for kulcs, ertek in suti.items():
    print(kulcs, "értéke:", ertek)

Kimenet

nev értéke: dobostorta szeletek értéke: 12 elfogyott értéke: False

Kiegészítés: Egyéb adatszerkezetek

A listákon és a dictionary-ken kívül további hasznos adatszerkezetek is léteznek Pythonban.

A tuple egy rendezett elem n-es, tulajdonképpen egy immutable lista (tehát a listával ellentétben az elemeit nem lehet módosítani). A listáknál tanultak többsége a tuple-nél is működik: az elemek indexelése, bejárása, előfordulás eldöntése ugyanúgy történik, mint a listáknál. A legtöbb listakezelő függvényt tuple esetén is használhatjuk, kivéve az append() és sort() metódusokat (ezek tuple-ök esetén nem működnek).

A halmaz (set) olyan adatszerkezet, amelyben nem lehetnek duplikátumok, és az elemek között nincs sorrendiség. Fontosabb metódusaira példát a linkre kattintva láthatunk.

Ez a két adatszerkezet az előadáson kerül tárgyalásra.

Feladatok

Az anyagrészhez tartozó gyakorló feladatsor elérhető itt.


Utolsó frissítés: 2020-09-30 18:50:55