Adatszerkezetek.

Egy osztály 28 tanulójának jegyét nem tároljuk 28 külön változóban (jegy1, jegy2, …): egyetlen adatszerkezetbe tesszük őket, amelyen aztán ciklussal végig tudunk menni. A Python három alapvető, egymás mellett is használt adatszerkezetét ismered meg:

A Pythonnak van egy negyedik alapvető adatszerkezete is, a szótár (dict) – neki a 8. modult szenteljük.

A listát szögletes zárójelek között, vesszővel elválasztott elemekkel hozzuk létre. Az elemek típusa vegyes is lehet, de a gyakorlatban egy listában általában azonos fajta adatok állnak. Az üres lista: []. Az elemek számát a len() adja meg.

jegyek = [5, 3, 4, 5, 2]
nevek = ["Anna", "Béla", "Csilla"]
ures = []
print(jegyek)
print(len(jegyek), len(nevek), len(ures))
print(jegyek[0], jegyek[1], jegyek[4])
print(nevek[-1])

jegyek = [5, 3, 4, 5, 2]
print(jegyek[5])

Szeletelés

A lista[start:stop] egy új listát ad a start indextől a stop előttiig – ugyanúgy, mint a range()-nél, a stop már nem része. Bármelyik határ elhagyható (akkor az elejétől / a végéig), és harmadikként lépésköz is megadható. A szeletelés szövegre is működik, és sosem ad IndexError-t. Negatív lépésköznél a szelet hátulról indul, ezért a [::-1] a teljes sorozat megfordítva.

szamok = [10, 20, 30, 40, 50, 60]
print(szamok[1:4])
print(szamok[:2])
print(szamok[3:])
print(szamok[::2])
print(szamok[::-1])
szo = "Python"
print(szo[0], szo[-1], szo[:3])

szo = "Python"
print("p" + szo[1:])
szo[0] = "p"

x = [3, 1, 4, 1, 5, 9]
print(x[2:5], x[-2])

A lista módosítható (mutable): egy eleme felülírható, és elemek adhatók hozzá vagy vehetők ki belőle – mindez helyben, ugyanabban a listában történik. A leggyakoribb műveletek (a többit a 6. modul mutatja be):

kosar = ["alma", "kenyér"]
kosar.append("tej")
kosar.insert(0, "sajt")
kosar[2] = "barna kenyér"
print(kosar)
kosar.remove("alma")
utolso = kosar.pop()
print(kosar, "– kivettük:", utolso)
print("tej" in kosar, "sajt" in kosar)

Kövesd lépésenként: a Memória részben a kosar változó egy nyíllal mutat a lista objektumra, és látod, ahogy a lista celláiba új elemek kerülnek, mások eltűnnek.

A lista bejárása

A for ciklus a lista elemein megy végig. Ha az indexre is szükség van (pl. sorszámozáshoz vagy egy elem módosításához), a range(len(lista)) adja a 0, 1, …, n−1 indexeket.

nevek = ["Anna", "Béla", "Csilla"]
for nev in nevek:
    print("Szia,", nev)
for i in range(len(nevek)):
    print(f"{i + 1}. {nevek[i]}")

Lista építése ciklussal

Nagyon gyakori minta: üres listából indulunk, és a ciklusban append()-del gyűjtjük bele az elemeket – például a beolvasott vagy egy feltételnek megfelelő értékeket.

szamok = []
szam = int(input("Szám (0 = vége): "))
while szam != 0:
    szamok.append(szam)
    szam = int(input("Szám (0 = vége): "))
parosak = []
for sz in szamok:
    if sz % 2 == 0:
        parosak.append(sz)
print("A számok:", szamok)
print("Ebből páros:", parosak)

Az első modulban láttuk, hogy a b = a után az a megváltoztatása nem hat a b-re. Listáknál ez másképp látszik, és ez a kezdők egyik legnagyobb meglepetése:

a = [1, 2, 3]
b = a
b.append(4)
print("a:", a)
print("b:", b)

A számoknál és szövegeknél ez azért nem okoz gondot, mert ezek nem módosíthatók: a kor = kor + 1 nem a régi számot változtatja meg, hanem egy új értékhez köti a nevet. A lista viszont helyben is változhat.

Ha önálló másolat kell, kérjük kifejezetten: a.copy(), list(a) vagy a[:]. Ezek új külső listát készítenek: számokból vagy szövegekből álló listánál a két lista teljesen külön módosítható. Ha viszont a lista elemei maguk is listák (vagy más módosítható objektumok), a belső elemek közösek maradnak – ez a sekély másolat. A 8. modulban egy példán meg is nézzük.

eredeti = [1, 2, 3]
masolat = eredeti.copy()
masolat.append(4)
print("eredeti:", eredeti)
print("másolat:", masolat)

x = [10, 20]
y = x
x = x + [30]
print(y)

A tuple (magyarul néha „rendezett n-es”) olyan, mint egy lista, amely létrehozása után nem változtatható meg: nem írható felül eleme, nem bővíthető, nem törölhető belőle. Kerek zárójellel írjuk – de valójában a vessző teszi tuple-lé (kivétel az üres tuple: ()).

pont = (3, 4)
szin = (255, 128, 0)
egyelemu = (7,)
nem_tuple = (7)
print(pont[0], pont[1], len(szin))
print(type(egyelemu), type(nem_tuple))
koordinatak = 10, 20
print(koordinatak)

pont = (3, 4)
pont[0] = 5

Kicsomagolás

A tuple (és a lista) elemei egyetlen értékadással szétoszthatók több változóba – a bal oldalon annyi név kell, ahány elem van. Ezzel egy sorban megoldható két változó cseréje is, segédváltozó nélkül: a jobb oldalon előbb elkészül a (b, a) tuple, és csak utána osztódik szét.

pont = (3, 4)
x, y = pont
print("x =", x, " y =", y)
a = "alma"
b = "körte"
a, b = b, a
print(a, b)
elso, *tobbi = [5, 8, 2, 7]
print(elso, tobbi)

Az utolsó sorban a * előtagú név „összegyűjti” a megmaradt elemeket egy listába: elso = 5, tobbi = [8, 2, 7].

A halmaz a matematikai halmazhoz hasonló: egy elem vagy benne van, vagy nincs – kétszer nem lehet benne, és az elemeknek nincs sorrendje, ezért indexelni sem lehet. Kapcsos zárójellel írjuk, az üres halmaz viszont set(), mert a {} üres szótárat jelent.

szinek = {"piros", "kék", "piros", "zöld"}
print(len(szinek))
print("kék" in szinek)
szinek.add("sárga")
szinek.discard("piros")
print(sorted(szinek))
jegyek = [5, 3, 5, 4, 3, 5]
print(set(jegyek))
print("Különböző jegyek száma:", len(set(jegyek)))

Halmazműveletek

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
print("unió:", A | B)
print("metszet:", A & B)
print("különbség:", A - B)
print("szimmetrikus különbség:", A ^ B)
print("részhalmaz-e:", {1, 2} <= A)

Az átalakítás a típus nevével történik: list(...), tuple(...), set(...). Egy lista ismétlődéseit így lehet kiszűrni: list(set(lista)) – de vigyázz, a sorrend ilyenkor elveszhet.