Kihagyás

Kollekciók

Ezen a gyakorlaton áttekintjük a fontosabb tudnivalókat a Python két hasznos 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, amely tetszőleges számú, nem feltétlen azonos típusú elemek tárolására alkalmas adatszerkezet.

Lista létrehozása

Pythonban egy listát létrehozhatunk...

  • ...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 az előző 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_neve[index].

Az indexelés itt is 0-tól kezdődik. Az előző 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 (a 3. indexű elem már nincs benne)
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. Ezt úgy is mondjuk, hogy a lista egy mutable (módosítható) típus. (A stringek karaktereit nem tudtuk módosítani, hiszen a string egy immutable típus volt.)

1
2
3
4
gyumolcsok = ["alma", "citrom", "barack", "pomeló"]
gyumolcsok[1] = "görögdinnye"       # listaelem módosítása

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. A lista elemeit bejárhatjuk a korábban tanult, listaszerű for ciklussal vagy akár az indexeken végigmenve is megvalósítható az elemek bejárása.

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

for gyumi in gyumolcsok:            # listaszerű for ciklus
    print(gyumi)

print("--------------------")

for i in range(len(gyumolcsok)):    # index alapú for ciklus
    print(gyumolcsok[i])

Ha az elemeket módosítani szeretnénk a bejárás során, akkor az index alapú bejárást válasszuk!

Referencia szerinti működés

Pythonban a listák referencia szerint működnek. Ez azt jelenti, hogy ha átadunk egy függvénynek egy listát paraméterül, akkor a függvény nem a kapott lista másolatával, hanem az eredeti listával fog dolgozni.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def nagybetusit(lista):
    for i in range(len(lista)): # egy stringekből álló lista összes elemét nagybetűsítjük
        lista[i] = lista[i].upper()

    return lista

gyumolcsok = ["alma", "citrom", "barack", "pomeló"]
nagybetus_gyumolcsok = nagybetusit(gyumolcsok)

print(nagybetus_gyumolcsok)
print(gyumolcsok)               # az eredeti lista is módosul!

Kimenet

['ALMA', 'CITROM', 'BARACK', 'POMELÓ'] ['ALMA', 'CITROM', 'BARACK', 'POMELÓ']

A fenti kódpéldában jól látható, hogy a függvényhívás következtében az eredeti gyumolcsok lista tartalma módosult a referencia szerinti paraméterátadás következtében.

Ha nem szeretnénk, hogy az eredeti listánk tartalmát módosítsa a függvény, akkor készítsünk a listánkról egy másolatot, és dolgozzunk azzal! Egy lista lemásolásához használjuk a lista_neve[:] szintaxist!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def nagybetusit(lista):
    for i in range(len(lista)):
        lista[i] = lista[i].upper()

    return lista

gyumolcsok = ["alma", "citrom", "barack", "pomeló"]
nagybetus_gyumolcsok = nagybetusit(gyumolcsok[:])   # egy másolatot adunk át

print(nagybetus_gyumolcsok)
print(gyumolcsok)               # az eredeti lista tartalma megmarad!

Kimenet

['ALMA', 'CITROM', 'BARACK', 'POMELÓ'] ['alma', 'citrom', 'barack', 'pomeló']

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

Az elem in lista szintaxissal lekérdezhetjü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']

Listák összefűzése

A + (plusz) operátorral összefűzhetjük két vagy több lista tartalmát.

Példa: Két lista összefűzése

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

osszefuzott = bosszuallok1 + bosszuallok2
print(osszefuzott)

Kimenet

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

Egy lista extend() metódusával hozzá tudjuk fűzni az adott listához egy másik lista elemeit.

Példa: A bosszuallok1 listához hozzáfűzzük a bosszuallok2 lista elemeit

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

bosszuallok1.extend(bosszuallok2)
print(bosszuallok1)

Kimenet

['Thor', 'Hulk', 'Vízió', '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, így az eredeti listát módosítja (ha ezt nem szeretnénk, akkor használhatjuk a sorted(lista) függvényt)
    • többféle adattípusra is működik: szövegeket tartalmazó listákat ábécé-sorrendbe, számokat tartalmazó listákat növekvő sorrendbe rendezi alapértelmezés szerint
  • 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 a 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! Amíg a "Thor" elem szerepel a listánkban, addig mindig töröljünk ki 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']

Szövegből lista, listából szöveg

A stringeknél láttuk, hogy egy szöveget könnyedén feldarabolhatunk a split() metódussal egy adott karakter(sorozat) mentén. A metódus egy listával tér vissza, amiben a feldarabolás után kapott értékek szerepelnek.

Példa: Egy szöveg szavainak lekérdezése egy listában

1
2
3
4
szoveg = "A Python egy nagyon klassz nyelv!"
szavak = szoveg.split(" ")          # szöveg feldarabolása szóközök mentén

print(szavak)

Kimenet

['A', 'Python', 'egy', 'nagyon', 'klassz', 'nyelv!']

Most megnézzük a fordított irányt is. Ha egy lista elemeit szeretnénk egyesíteni egy adott karakter(sorozat) mentén, akkor a join() függvényt használjuk.

Példa: Egy lista egyesítése szöveggé

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

print(" ".join(gyumolcsok))     # szöveggé egyesítés szóköz karakterek mentén
print(";".join(gyumolcsok))     # szöveggé egyesítés pontosvesszők mentén
print(" --- ".join(gyumolcsok)) # tetszőleges karaktersorozatot is megadhatunk

Kimenet

alma citrom barack pomeló alma;citrom;barack;pomeló alma --- citrom --- barack --- pomeló

Dictionary

A dictionary (szótár) egy kulcs-érték párokat tartalmazó adatszerkezet, tulajdonképpen egy rendezetlen leképezé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 szerepelhet, az értékre ilyen megkötés nincs.

  • Egy dictionary-ben található kulcs bármi lehet, viszont a gyakorlatban általában string típusú kulcsokat használunk (ennek oka a JSON-formátummal való kompatibilitás).
  • Egy dictionary-ben található érték tetszőleges típusú lehet (pl. logikai érték, szám, string, lista, dictionary, saját típus stb.).

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

Egy dictionary hosszát (azaz a benne található kulcs-érték párok számát) jó barátunkkal, a len() függvénnyel kérdezhetjü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-ben egy adott kulcshoz tartozó értéket, akkor ezt Pythonban kétféleképpen tehetjük meg:

  • hagyományos indexeléssel: dictionary_neve[kulcs]
  • 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 indexelé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, akkor használjuk a get() metódust a hagyományos indexelé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 indexelé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

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 indexelé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(suti)

Kimenet

{'nev': 'gyümölcskrémes', 'szeletek': 12, 'elfogyott': False}

Ú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: 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("A", suti["nev"], "ára:", suti["ar"], "forint")

Kimenet

A dobostorta ára: 5200 forint

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
3
4
suti = {"nev": "dobostorta", "szeletek": 12, "elfogyott": False}

for kulcs in suti:
    print(kulcs)

Kimenet

nev szeletek elfogyott

Értékek bejárása

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

for ertek in suti.values():
    print(ertek)

Kimenet

dobostorta 12 False

Kulcsok és értékek együttes bejárása

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

for kulcs, ertek in suti.items():
    print(kulcs, "értéke:", ertek)

Kimenet

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

A get() metódus egy gyakorlati haszna

A korábbiakban láttuk a get() metódus egyik főbb használatát: segítségével egy dictionary egy adott kulcsához tartozó értékét kérdezhetjük le. Most megnézzük egy másik gyakorlati hasznát ugyanennek a metódusnak.

A get() metódust 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 csoportosítási feladat.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
my_dict = {
    1: "alma",
    2: "körte",
    3: "szilva",
    12: "alma",
    23: "körte",
    32: "szilva",
    41: "alma",
    42: "körte",
    34: "szilva"
}

# Hozzunk létre egy olyan dictionary-t, amely az értékek alapján csoportosítja a dictionary kulcsait!
# Tehát az elvárt output: {'alma': [1, 12, 41], 'körte': [2, 23, 42], 'szilva': [3, 32, 34]}

csoportok = {}
for kulcs, ertek in my_dict.items():
    # Ha létezik az adott csoportnak megfelelő lista, akkor csak beletesszük az új elemet.
    # Ha nincs még ilyen lista, akkor létrehozunk egy üres listát (get() metódus 2. paramétere), amibe beletesszük az elemet.
    csoportok[ertek] = csoportok.get(ertek, []) + [kulcs]

print(csoportok)

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

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: 2021-09-13 14:05:13