Adatszerkezetek

Formázott kimenet

Néhány zűrzavaros print() utasítás:

print("A szó " + str(i) + ". betűje: " + szo[i] + ".")
print(x * y, end="\t")

print("A szó ", str(i), ". betűje: ", szo[i], ".", sep="")

1       2       3       4   
2       4       6       8   
3       6       9       12  
4       8       12      16  
5       10      15      20  
...

• Nehéz átlátni.
• A kiírást nehéz formázni.

Hogy lehetne használhatóbbá és áttekinthetőbbé tenni a kimenet formázását?

A formázó működése

formazott= f"A szó {i}. betűje: {szo[i]}"

• A sztringek elé egy 'f' betű kerül
• A kapcsos zárójelek {} helyére helyettesíti be az adatot
• Az adat tetszőleges kiértékelhető Python kifejezés lehet
• Python 3.6 verzió felett használható (2016. december)

Használata

szo="Barack"

for i in range(len(szo)):
    print( f"A szó {i}. betűje: {szo[i]}")

Nem törvényszerű, de legtöbbször az így leírt kifejezés eredményét (amely egy sztring) rögtön a print()-nek adjuk.

Módosítók

gyumolcs="körte"
print(f"|{'alma':<12}|")
print(f"|{gyumolcs:>12}|")
print(f"|{math.pi:12.5}|")
print(f"|{math.pi/2.0:12.5e}|")

|alma        |
|       körte|
|      3.1416|
| 1.57080e+00|

A szorzótábla javított megoldása:

y = 1
while y <= 5:
    x = 1
    while x <= 5:
        print(f"{x*y:3}", end="")
        x+=1
    print()
    y+=1

maxx = 10
maxy = 10
maxszel = len(str(maxx * maxy))+1

for y in range(1, maxy+1):
    for x in range(1, maxx+1):
        print(f"{x*y:{maxszel}}", end="")
    print()

A formázó működése

minta = "A szó {}. betűje: {}"
eredmeny = minta.format(i, szo[i])

Használata

szo = "barack"

for i in range(0, len(szo)):
    print("A szó {}. betűje: {}".format(i+1, szo[i]))

Általában egy sorba írjuk, "...".format(...) módon. Bár ez nem törvényszerű, de legtöbbször az így leírt kifejezés eredményét (amely egy sztring) rögtön a print()-nek adjuk.

Általános forma

eredmeny = "minta" % (adat1, adat2, ...)

Régebbi Python verziókban a formázást a % operátorral lehetett elvégezni. Bal oldalon a mintát megadó sztring (lásd lentebb), jobb oldalon pedig zárójelben a behelyettesítendő adatok.

Példák

print("%s %d éves." % ("Ernőke", 4))
print("|%8.4f|" % math.pi)

Ernőke 4 éves.
|  3.1416|

Az adatokat az egyes százalékjellel megjelölt helyre helyettesítette be. A százalékjel után opcionálisan szélességet lehetett megadni, végül pedig egy karakter következett, amely a típust reprezentálta. Sztringek esetén ez s, egész számoknál d („decimal”, mert tízes számrendszerben íródtak ki), valósaknál pedig f („floating point”).

Ezt a módszert a C nyelvtől örökölte meg a Python. Manapság, új programokat írva már nem használjuk. Azért érdemes tudni róla, mert régebben írt programokban elég gyakran előfordul.

Adatszerkezetek

Feladat: egy évfolyam kis ZH-iról szeretnénk statisztikát készíteni. A dolgozatok 0–10 pontosak lehetnek. A kérdésünk, hogy melyik pontszámból hány darab lett.

5
7
10
9
10
...

 0 p     1 db
 1 p     7 db
 2 p     3 db
...     
 9 p    34 db
10 p    17 db

Egy nem túl jó megoldás a következő:

# pontok beolvasása
pontok = []
be = input("Pont? ")
while be != "":
    pontok.append(int(be))
    be = input("Pont? ")

# 0–10-ig megszámoljuk mindig
for keresett in range(0, 10+1):
    db = 0
    for pont in pontok:
        if pont == keresett:
            db += 1
    print(f"{keresett:2} p, {db:2}")

Miért mondjuk azt, hogy ez nem túl jó megoldás? Egyrészt felesleges eltárolni az összes pontszámot. Mint azt később látni fogjuk, nincsen rá szükség. Másrészt pedig érezzük, hogy a megszámlálásokból túl sok van. 11-féle pontszám lehetséges (nullától tízig), és a programunk 11-szer megy végig a listán, újra és újra mindig egy másik pontszámot keresve. Így alakul ki végül a táblázat, ami a kimenetre kerül. De tényleg ehhez végig kell menni 11-szer? Nem lehetne valahogyan előre meghatározni ezt a táblázatot, egy lépésben?

Lássunk egy egyszerűbb kérdést: hány nulla pontos dolgozat lett?

Ehhez a megszámlálás tételét alkalmazzuk a szokásos módon.

db = 0
for pont in pontok:
    if pont == 0:
        db += 1
print(f"0 p, {db:2} db")

Vegyük észre: több számlálóval több pontszámot is kiválogathatnánk.

db0 = 0
db1 = 0
db2 = 0
# ...
for pont in pontok:
    if pont == 0:
        db0 += 1
    if pont == 1:
        db1 += 1
    if pont == 2:
        db2 += 1
    # ...
print(f"0 p, {db0:2} db")
print(f"1 p, {db1:2} db")
print(f"2 p, {db2:2} db")
# ...

Adatszerkezet: definíció

Az adataink strukturális elrendezése a programban.

Az adatszerkezet

Tizenegy számlálót kell használni. Legyen egy listánk:

Az ötlet a következő. A számlálók tárolásához ne tizenegy, egymástól független változót használjunk. Legyen inkább helyettük egyetlen egy lista, amelyik a számlálókat tartalmazza.

Az adatok elérése

Ez a lista lesz a programunkban az adatszerkezet, amelyben a számunkra lényeges információkat tároljuk. Az adatszerkezetek tervezésekor azt is végig kell gondolni, hogy az adatot hogyan érjük el. Jelen esetben egyszerű a dolgunk: a nulladik számláló a lista nulladik eleme (0. indexű), az első számláló a lista első eleme, és így tovább.

db[0] += 1      # 0 pontos
db[2] += 1      # 2 pontos

db[pont] += 1   # általában: indirekt adatelérés

Vagyis mindig éppen annyiadik indexű számlálóval, azaz listaelemmel dolgozunk, ahány pontos dolgozatot épp találtunk. Ezt fogalmazza meg általánosságban a db[pont] += 1 sor, ahol a db lista tartalmazza a számlálókat, a pont változó pedig a dolgozat eredményét 0 és 10 között.

# pontok beolvasása
pontok = []
be = input("Pont? ")
while be != "":
    pontok.append(int(be))
    be = input("Pont? ")

# válogatás
db = [0] * 11
for pont in pontok:
    db[pont] += 1   # indirekt adatelérés

# eredmény
for pont in range(0, 10+1):
    print(f"{pont:2} p, {db[pont]:2} db")

Észre kell venni itt egy nagyon fontos dolgot. A pont nevű változó a dolgozatok megszámlálása közben nem ciklusváltozó. Vagyis a listát nem ciklusváltozóval indexeljük, nem járjuk be. Ehelyett a lista indexe tulajdonképp a bejövő adat az algoritmusban, amit a felhasználó gépelt be. Ezért nevezzük ezt indirekt adatelérésnek vagy indirekt szabálynak. A program megírásakor nem is tudjuk, milyen sorrendben lesznek elérve a lista elemei; ez teljes mértékben attól függ, hogy futás közben milyen bemenő adatokat kap a program.

Tulajdonképp ez a legfontosabb gondolat és kódsor a programban. A db[pont] kifejezés egyébként az eredményt kiíró programrésznél is szerepel. Ott ugyanez a célunk: a pontszámhoz tartozó számláló kiolvasása a listából. Csak itt a pontszámot a program határozza meg, mert fel kell sorolni az összeset, nullától tízig mindegyikhez kiírni a darabszámot.

Már csak egy dolgot kell észrevennünk: a pontok nevű listára, amibe kezdetben tettük a billentyűzetről beolvasott adatokat, egyáltalán nincsen szükségünk. Emlékezzünk vissza a megszámlálás tételére: a számláló növelése után a vizsgált adatot eldobhatjuk, felesleges már megtartani. Itt is ugyanezt tehetnénk: a billentyűzetről beolvasott adatot egyből felhasználhatnánk valamelyik számláló növeléséhez.

A legjobb megoldás, amely már a billentyűzetről beolvasás közben megnöveli a számlálókat, így fest:

# pontok beolvasása és válogatás
db = [0] * 11
be = input("Pont? ")
while be != "":
    pont = int(be)
    db[pont] += 1   # indirekt adatelérés
    be = input("Pont? ")

# eredmény
for pont in range(0, 10+1):
    print(f"{pont:2} p, {db[pont]:2} db")

Miért jobb ez az új verzió? Egyrészt mert sokkal rövidebb, egyszerűbb. Másrészt pedig mert sokkal kevesebb memóriát foglal futás közben. Bárhány dolgozatot is kell feldolgozni, a program által használt lista mindig csak 11 elemű; és ez teljesen független a feldolgozandó adatok mennyiségétől.

A ládarendezés (leszámláló rendezés) nem hasonlítja össze az egyes elemeket egymással, hanem nagyságuk szerint csoportosítja őket. Lássuk a legegyszerűbb esetet, rendezzünk egy listát egész számokkal!

A rendezendő lista:

Ebben a listában 0 és 9 között vannak számok. Fogunk egy másik listát, amelyben leszámláljuk, hogy melyikből hány darab szerepel:

A számlálás eredménye:

Ebből az információból egy új lista állítható elő, amelyik rendezett lesz. Nem kell hozzá mást tenni, mint 1 db 0-st, 3 db 4-est, 1 db 5-öst, 1 db 6-ost, 2 db 8-ast és 1 db 9-est tenni bele:

A rendezett lista:

Lássunk egy újabb példát!

A rendezendő lista:

A ládarendezéshez használható adatszerkezet az előzőek alapján könnyen kigondolható. Megint egy olyan listára lesz szükségünk, amelyik számlálókat tartalmaz: az eredeti számokhoz kell ezeket hozzárendelnünk, hogy meg tudjuk mondani, melyikből hány darab szerepelt. Ha találunk egy 4-est, akkor a 4-esekhez tartozó számlálót növeljük. Ha 8-as jön, akkor a 8-asokhoz tartozó számlálót.

A ládarendezés akkor tud jól működni, ha kevésféle szám szerepel a sorbarendezendő tömbben, hiszen annyi számláló kell, ahányféle szám van ott. Ha az eredeti lista nullától kezdődően tartalmaz kicsi egész számokat, akkor könnyű a dolgunk, hiszen a listák 0-tól indexelődnek. Ha nagyobb számok vannak benne, akkor viszont így a számlálók listájának az „alját” nem fogjuk használni semmire:

Melyik részét használjuk a listának?

A fenti listának a hasznos része a 6-tól 9-ig terjedő szakasz. Legjobb ötlet ezért, ha megnézzük, hogy melyik a legkisebb és a legnagyobb szám a listában, és ehhez a tartományhoz hozunk létre számlálókat. Közben pedig reménykedünk abban, hogy nem túl nagy a tartomány, nem túl kevésféle szám van benne, mert akkor nagyon sok üres, nem használt számlálónk lesz, mint amilyen most a 7-es is. (Ez egyszerűen a ládarendezésnek egy tulajdonsága, amit ismerni kell – tudjuk, mikor érdemes használni és mikor nem.)

A javított adatszerkezetünk:

Ezek szerint egy adott számhoz tartozó számlálót a db[szám - legkisebb] indexeléssel fogjuk tudni elérni.

A minimum és a maximum megkeresését mi is lekódolhatjuk, de egyszerűbb a min() és a max() függvényt használni. A számlálók listájának mérete legnagyobb - legkisebb + 1, mert a tartomány mindkét vége előfordul.

eredeti = [61, 73, 16, 51, 62, 51, 71, 14, 13, 13, 55, 13, 7, 45, 61]

legkisebb = min(eredeti)    # 7
legnagyobb = max(eredeti)       # 73
darab = [0] * (legnagyobb - legkisebb + 1)
for szam in eredeti:            # 61, 73, 16, ...
    darab[szam - legkisebb] += 1

rendezett = []
for szam in range(legkisebb, legnagyobb + 1):
    hanyszor = darab[szam - legkisebb]
    rendezett.extend([szam] * hanyszor)

print(rendezett)

[7, 13, 13, 13, 14, 16, 45, 51, 51, 55, 61, 61, 62, 71, 73]

A kód többi része az adatszerkezet megértése után magától értetődő. Az .extend() függvény egyébként a lista .append() függvényéhez hasonló, de nem csak egyetlen új elemet fűz hozzá egy listához, hanem egy másik lista összes elemét. Például a számlálás után tudjuk, hogy 3 darab 13-as szám volt az eredeti listában, ezért a rendezett listát kiegészítjük (extend) [13] * 3-mal, azaz [13, 13, 13]-mal.

A szita: többszörösök kihúzása

Eratoszthenész szitája prímszámokat keres. A módszer a következő. Felírjuk a számokat valameddig. 2 prímszám, ezt megjegyezzük. Kihúzzuk a többszöröseit, mivel azok nem prímszámok. Ezután 3 a következő, ami még nincs kihúzva. Az is prímszám, mivel nem találtunk ezidáig osztót hozzá: a nála kisebb összes szám többszöröseit kihúztuk, nála nagyobb osztója pedig nem lehet. A többszörösei viszont nem prímek: kihúzzuk az összes 3-mal oszthatót. 4-et már kihúztuk (2×2). 5 a következő prím, kihúzzuk n×5-öt stb.

start

Írjuk ki ezek alapján a prímszámokat 999-ig! Az algoritmus adott, az adattárolás módját kell csak meghatározi: hogyan tárolható el az, hogy ki lett-e húzva már egy szám, vagy nem? Minden számhoz tartozóan egy igaz/hamis értéket kell tárolni.

Az adatszerkezet

Egy tömbre, azaz fix méretű listára van szükség. A lista elemei itt logikai értékek, nem pedig számok. A listát pedig mindig magával a számmal indexeljük; prim[2] pl. azt tárolja, hogy a 2 prímszám-e. Az első két elemet így ugyan nem használjuk, de a program egyszerűbb, mert az index megegyezik magával a számmal. Az 1000 méretű listában így 999-ig lehet megkeresni a prímeket.

Az algoritmus futása után tehát a listánk így néz ki:

Az első két helyen (0, 1 indexű elemek) az igaz érték változatlan maradt; a 4, 6, 8, 9, … helyekre pedig az algoritmus hamis értékeket tett, mert nem prímszámok. Lényegében a lista első két elemét nem használjuk semmire; azért, hogy az index mindig pontosan megegyezzen a vizsgált számmal: lista[szám]. Eltolhatnánk ezt 2-vel, hogy ne vesszen kárba ez a két listaelem, de az 1000 elemhez képest nincs ennek jelentősége. Ezért inkább elpazaroljuk azokat, hogy egyszerűbb legyen a programunk.

# 1000 elemű, True-kból álló lista
prim = [True] * 1000

# Prímek keresése
for sz in range(2, 1000):
    if prim[sz]:
        for t in range(sz * 2, 1000, sz):
            prim[t] = False

# Kiírás
for sz in range(2, 1000):
    if prim[sz]:
        print(sz, end=" ")
print()

        t = sz * 2
        while t < 1000:
            prim[t] = False
            t += sz

Feladat: két kockával dobás összegét vizsgáljuk. Melyik összeg, milyen gyakran fordul elő?

A következő programban azt fogjuk megvizsgálni, hogy két dobókockával dobva, a két kockán látható számok összegének milyen eloszlása van. Az egy kockával dobással ellentétben ennél nem egyenletesen jön ki mindegyik összeg. A kockadobások szimulálásához véletlenszámokat fogunk használni.

A programok lényege, hogy determinisztikusak. Kérdés: akkor honnan lesznek véletlenszámaink?

import random

if random.randint(0, 1) == 0:
    print("fej")
else:
    print("írás")

import random

for i in range(10):
    print(random.randint(1, 6), end=" ")

import random

random.seed(12345)
i = 0
while i < 10:
    print(random.randint(1, 6), end=" ")
    i += 1

Térjünk vissza a feladathoz, a kockadobások összegzéséhez! Azt kell vizsgálnunk, két kockával dobva milyen gyakorisággal állnak elő a lehetséges összegek.

Ezt szeretnénk eltárolni

A kockadobások lehetséges összegei 1+1 = 2 és 6+6 = 12 között lesznek. Minden összeghez rendelünk egy számlálót; a dobás után az adott számlálóhoz húzunk egy strigulát.

Így jelenik meg a programban

Az összegek közül a legkisebb az 2, a legnagyobb a 12. Ezért a gyakoriságokat tároló lista 12-2+1 = 11 elemű kell legyen. Ennek a listának az indexei a 0…10 tartományban lesznek, ezért a dobások összegéből 2-t le kell vonni: 2…12 - 2 = 0…10, úgy kapjuk az adott dobás gyakoriságát tároló listaelem indexét.

import random

dobas = [0] * (12-2+1)

for i in range(1000):
    kocka1 = random.randint(1, 6)
    kocka2 = random.randint(1, 6)
    osszeg = kocka1 + kocka2
    dobas[osszeg - 2] += 1  # 2-12 → 0-10

for osszeg in range(2, 12+1):
    print(f"k1+k2 = {osszeg}, {dobas[osszeg-2]} alkalom")

import random

dobas = [0] * (12-2+1)

for i in range(1000):
    kocka1 = random.randint(1, 6)
    kocka2 = random.randint(1, 6)
    osszeg = kocka1 + kocka2
    dobas[osszeg - 2] += 1

for osszeg in range(2, 12+1):
    x = "X" * (dobas[osszeg-2] // 10)
    print(f"{osszeg:2} {x}")

2    XX
3    XXXXX
4    XXXXXXX
5    XXXXXXXXXX
6    XXXXXXXXXXXXX
7    XXXXXXXXXXXXXXXXXX
8    XXXXXXXXXXXXXX
9    XXXXXXXXXXXX
10   XXXXXXX
11   XXXXX
12   XX

Referenciák

Futtassuk le az alábbi programokat! Mit fognak kiírni?

a = 3
b = a

a += 1

print("a =", a)
print("b =", b)

a = [1, 2, 3]
b = a

a.append(4)

print("a =", a)
print("b =", b)

a = 4
b = 3

a = [1, 2, 3, 4]
b = [1, 2, 3, 4]

Említettük a múltkori előadáson, hogy értékadással a lista nem másolható le. Elevenítsük fel ezt a problémát!

Csak a hivatkozás másolódik

a = [1, 2, 3]
b = a       # !

b.append(4)
print(a)    # [1, 2, 3, 4]

Ebben a kódban létrehozunk egy listát. A b = a értékadásnál nem jön létre új lista, hanem csak egy hivatkozást állítunk be. Vagyis innentől kezdve egy listánk van, és ahhoz két név tartozik. Akár az a, akár a b nevet használjuk, ugyanarról a listáról beszélünk. Ha az egyiket mósodítjuk, akkor a másik is látszólag módosul, de ez azért van, mert valójában nincs „egyik” és „másik”: egyetlen egy listánk van.

A lista másolódik

x = [1, 2, 3]
y = list(x) # !

y.append(4)
print(x)    # [1, 2, 3]

Itt viszont két listánk lesz. Az első a szokásos módon létrejön, az x változónéven keresztül érhető el. Az y változót pedig úgy inicializáljuk, hogy meghívjuk a list() függvényt: ez új listát hoz létre, amelybe átmásolja a paraméterként kapott listában található elemeket. A lényeg, hogy így létrejön egy másik lista. Tehát most két változónk van, de listából is kettő van. Ha az y változón keresztül látott listát módosítjuk, akkor az x-en keresztül látott nem módosul, mert az az eredetitől független.

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

Amikor egy változónak értéket adunk, akkor egy referenciát állítunk be egy meglévő objektumra. Maga az értékadás igazából nem hoz létre objektumot, csak nevet adunk egy objektumnak (name binding). Ez könnyen látható a b = a esetben: ott egy újabb változó jön létre, amely ugyanannak az objektumnak a referenciáját tárolja. De ez történik még az a = [1, 2, 3] sorban is. Ott az [1, 2, 3] kifejezés az, ami a listát létrehozta, utána az értékadás már csak a meglévő listára állít be referenciát.

Mi történik olyankor, amikor számokkal dolgozunk? Az a = 3 és b = a után ugyan egy objektumunk van, két referenciával. A b += 1 viszont valójában csak a b = b + 1 rövidítése – amiből a legfontosabb a b = rész, vagyis az értékadás. A b-nek itt értéket adunk, vagyis másik objektumra állítjuk át (a létrejövő egész szám objektumra, a 4-re), és mindennek semmi köze sem az a változóhoz, sem a 3 objektumhoz.

A fentiek miatt van az is, hogy a Python nyelvben a változóknak nincsen típusa: valójában a változó által hivatkozott objektum az, aminek típusa van. Ennek ellenére szoktunk pongyolán a „változó típusáról” beszélni, de a Python nyelvben mindig a változó által hivatkozott objektum típusát értjük ezalatt.

Az is operátor referenciákat hasonlít össze. Vagy másképp fogalmazva, az is operátorral referencia szerint hasonlíthatunk össze két objektumot. Nem azt vizsgáljuk vele, mint az == operátorral, hogy ugyanolyan értékű, tartalmú objektumokról van-e szó. Hanem azt, hogy az operátor két oldalán álló objektum ugyanaz-e, azonosak-e: tehát valójában egyetlen objektumról van-e szó. Azt is szoktuk mondani, hogy az is operátor az objektumok identitását hasonlítja össze. (Ennek tagadására használható az is not operátor: a is not b, ami értelemszerűen csak a not a is b rövidítése.)

Ugyanaz a lista

a = [1, 2, 3]
b = a
print("a == b:", a == b)
print("a is b:", a is b) # !

b.append(4)
print(a)

a == b: True
a is b: True
[1, 2, 3, 4]

Ugyanolyan lista

x = [1, 2, 3]
y = [1, 2, 3]
print("x == y:", x == y)
print("x is y:", x is y) # !

y.append(4)
print(x)

x == y: True
x is y: False
[1, 2, 3]

A fenti kódrészletek erre mutatnak példát. Az első esetben egy listánk van, amelyre a és b változók is referenciák az a = b értékadás miatt. Ilyenkor természetesen a == b igaz lesz, hiszen ugyanazokat a számokat látjuk. De a is b hasonlóképp igaz, mert ugyanarról az egyetlen egy listáról van szó, csak két nevet adtunk neki. Így amikor b-hez adunk hozzá elemet, akkor a is változni fog.

A második esetben két különálló listánk van. Kétszer értékeltük ki az [1, 2, 3] kifejezést, tehát két lista jött létre, amelyek egymástól függetlenek. (Ugyanezt a hatást értük volna el az y = list(x) sorral.) Bár ilyenkor x == y továbbra is igaz – ugyanaz a tartalom –, mégis az x is y kifejezés hamisat ad, mert a két lista identitása nem egyezik meg. Különállóak, így amikor y-hoz új elemet adunk hozzá, x nem változik.

Változók és listák: referenciákat tárolnak

A Python szemléletében még a számok is objektumok. És valójában ha egy változónak számot adunk értékül, akkor is csak egy referenciát állítunk be egy bizonyos szám objektumra, ami ugyanúgy létrejön valamikor, ahogy egy listát is létrehozunk. Maga a lista is csak referenciákat tartalmaz.

a = "almafa"

b = a

c = 2

d = [c, a, 5]

Vigyázat!

a = 1000
b = 500 + 500
print("a == b:", a == b)
print("a is b:", a is b)

a == b: True
a is b: False

Számok és sztringek esetén is létrejöhetnek különböző objektumok ugyanazzal az értékkel! Mindkét változónak ugyanazt az értéket adtuk: az egyik 1000, a másik 500+500, ami szintén 1000. De két objektum jött létre! Az összeadás után nem kereste meg a gép, hogy létezik-e már 1000 értékű, int típusú objektum valahol, hanem létrehozott egy újat. Emiatt bár a == b igaz, a is b nem: két különálló objektumról van szó. Nagyon fontos: számokat és sztringeket nem szabad az is operátorral vizsgálni egyenlőségre, hanem mindig az == operátort kell használni erre a célra!

Listák két dimenzióban

Moziban szeretnénk a foglaltságot nyilvántartani:

Moziban szeretnénk a foglaltságot nyilvántartani. A teremben sorok vannak, a sorokban pedig székek. Minden szék foglalt lehet, vagy szabad. Egy konkrét szék foglaltságát legegyszerűbb bool típusú értékkel reprezentálni. Foglalt-e, igen vagy nem: true, ha foglalt, és false, ha szabad.

foglalt = [
    [ False, False, False, False ],
    [ False, False, False, False ],
    [ False, False, False, False ],
    [ False, False, True,  False ],
    [ False, True,  True,  False ],
]

foglalt[2][1] = True
if foglalt[2][3]: # A Python-ban nullától, a moziban egytől sorszámozunk!
    print("3. sor 4. szék foglalt")

Táblázat két dimenzióban: listák listájával.

foglalt[sor][oszlop] = ...

Két dimenzióban táblázatot egyszerűen listák listájával tudunk létrehozni. A foglalt változó által hivatkozott lista így az egyes sorokat tartalmazza. Az egyes sorok azon belül pedig logikai értékeket tárolnak: True, ha foglalt az adott szék, amúgy False.

Egy konkrét széket így két egymás utáni indexeléssel érünk el. Az első indexelés a sorok listájából kiválaszt egyetlen egy sort. Ez is egy lista, úgyhogy itt jönnie kell egy második indexelésnek: az pedig a sorból kiválasztja az adott széket.

Egyéb példák, ahol 2D listát használhatunk:

Amőba, vagy tic-tac-toe játék pályája

Mátrix számokkal

Láttuk, hogy eleve feltöltött, adott méretű listát a [kezdetiérték] * méret kifejezéssel tudunk létrehozni. Ez az egyelemű listát fűzi össze annyiszor, amennyivel szoroztuk, így alakul ki a sokelemű lista. Kézenfekvőnek tűnik ezután, hogy a mozi foglaltsági táblázatát a [[False] * székek_száma] * sorok_száma kifejezéssel hozzuk létre. Itt azonban valami nagyon furcsa dolog történik:

foglalt = [[False] * 4] * 4

for sor in foglalt:
    print(sor)

foglalt[2][1] = True

for sor in foglalt:
    print(sor)

[False, False, False, False]
[False, False, False, False]
[False, False, False, False]
[False, False, False, False]

[False, True, False, False]
[False, True, False, False]
[False, True, False, False]
[False, True, False, False]

Olyan, mintha egyetlen egy szék foglaltra állítása miatt abban az oszlopban az összes szék foglalttá válna. Mitől van ez?

A referenciák és objektumok fogalmának ismeretében könnyű megmagyaráznunk, mi történt. A [False] * 4 kifejezés létrehozott egy olyan listát, amiben négy False érték található; eddig rendben is van a dolog. Utána viszont ezt a listát tettük be négyszer egy másik listába. Vagyis a külső listába négyszer tettük ugyannak az egy listának a referenciáját. Egy objektumunk van, és azt hivatkozzuk meg négyszer. Így nem csoda, hogy valamelyik elemet True-ra állítva úgy tűnik, hogy a „többi lista” is megváltozott. Nincsen többi lista, csak egyetlen egy.

A megoldás: különálló listákat kell létrehozni!

foglalt = []
for _ in range(4):
    foglalt.append([False] * 4)

for sor in foglalt:
    print(sor)

foglalt[2][1] = True
for sor in foglalt:
    print(sor)

[False, False, False, False]
[False, False, False, False]
[False, False, False, False]
[False, False, False, False]


[False, False, False, False]
[False, False, False, False]
[False, True,  False, False]
[False, False, False, False]

A megoldás lényege az, hogy négyszer hozzunk létre ugyanolyan listákat. Így négy különálló, egymástól független listákat kapunk – a sorokat –, és ezeket tesszük be a kezdetben üres, sorokat tároló foglalt nevű listába. Ha négyszer értékeljük ki a [False] * 4 kifejezést, akkor négy különálló, független listánk lesz!

Miért ilyen furcsa a ciklusváltozó neve a fenti kódban? Az alulvonás karakter _ ugyanolyan szerepű a kódban, mint bármelyik betű: lehet azonosító része. Azaz nevezhetünk el így változót is. Alulvonásnak szokás elnevezni ciklusváltozókat olyankor, amikor az értékére nincs szükségünk. A fenti kódban a range()-től származó egész számok pont ilyenek: nem használjuk semmire, csak kellett egy ciklus, ami minden létrehozandó sorra lefut.

Jó tanács: A referenciákkal kapcsolatos problémák megértéséhez mindig készítsünk rajzot!