A fájlt az open() függvénnyel lehet megnyitni. Ennek a két legfontosabb paramétere egy-egy sztring. Az első paramétere a fájl neve, második pedig a használat módja, amelyben betűk kódolják, hogy mit szeretnénk csinálni. Jelenleg egy szövegfájlt (t) nyitunk meg, hogy írjunk bele (w).

A fájl objektumot eltároljuk egy változóban, amely itt f névre hallgat. Ha végeztünk a feladatunkkal, az objektum .close() függvénnyel zárhatjuk be a fájlt. Ez kötelező! Ha nem tesszük meg, akár adatot is veszíthetünk; előfordulhat, hogy a legutóbbi írási műveletek eredménye nem kerül ténylegesen a fájlba.

A fájlba írni annak .write() függvényével tudunk. Ügyelni kell arra, hogy ennek egyetlen egy paramétere lehet csak, amely egy sztring. Nem kaphat több adatot, mint a print() függvény; sőt a sorokat elválasztó \n karaktereket is nekünk kell jeleznünk. Legegyszerűbb ezért egy szöveget tartalmazó fájl előállításakor sztringformázást használni. Ha olvassuk az adatokat a fájlból, akkor a .readline() függvényt használjuk; erről lentebb lesz szó.

Előbb viszont még néhány apróság az open() függvény paraméterezéséről. Először is, ügyelni kell a fájlnevek megadására. Windowson az elérési útban \ az elválasztó: C:\Windows\hatter.bmp, Unixon / van: /usr/bin/firefox. Az open() mindig elfogadja a /-t. Ha a \-hez ragaszkodunk, azt viszont \\-nek kell írni a sztring belsejében, mivel a \ önmagában a speciális karaktereket jelöli (pl. \n).

A második paraméter a megnyitás módját mutatja. Ebből az első betű mindig azt jelöli, hogy a fájlba írni szeretnénk, most hozzuk létre; w = write. Vagy esetleg egy meglévő fájlból olvasnánk: r = read. Az olvasáson (r) és íráson (w) kívül létezik még két további megnyitás mód is:

• hozzáfűzés (a). Ilyenkor a fájlt írásra nyitjuk meg, de a meglévő tartalmát meghagyva. Az írás mutató a fájl végére mutat, vagyis a meglévő tartalomhoz hozzáadva lehet folytatni az írást.
• írás-olvasás (+). Ilyenkor írni és olvasni is lehet. Más betűkkel együtt használjuk: pl. r+ azt jelenti, hogy a fájl tartalma megmarad, de írni is lehet bele.

Az írás vagy olvasás kiválasztása mellett meg kell adnunk azt is, hogy szöveges vagy bináris fájlról beszélünk. A kettő közötti különbség leginkább úgy érthető meg, ha a kettőt egy példán keresztül összehasonlítjuk, ugyanis ugyanaz az adat eltárolható szöveges és bináris fájlban is.

Tegyük fel, hogy adott egy int változónk, legyen a benne tárolt érték 12345. Ha ezt szövegesen írjuk egy fájlba, akkor az 1, 2, 3, 4, 5 karakterek ASCII kódja kerül a fájlba (összesen 5 bájt). Ha binárisan, akkor pedig annyi bájtot írunk ki, ahány bájtot a számítógépünkon az int változók foglalnak; és pontosan azokat a bájtokat, amik a változó memóriaterületén vannak. Ezek lehetnek pl. az 57, 48, 0, 0 bájtok (ilyen sorrendben), mert 57 + 48*256 + 0*65536 + 0*16777216 = 12345.

Lényegében tehát, a szövegfájl „emberi fogyasztásra is alkalmas”, a bináris fájl pedig nyers memóriaképet tárol.

Először is, az előbb ismertetett módon megnyitjuk a fájlt: olvasunk belőle, r = read, és szövegfájlról van szó, t = text. Bezárni is ugyanúgy kell majd a fájlműveletek végén. Másodszor pedig, a fájlból egy sort a .readline() függvénnyel kapunk meg. Ezt fel kell dolgozni, vissza kell nyerni belőle az adatokat, mert az eredeti adatainkat a fájlba íráskor mind sztringgé alakítottuk.

• A kapott sztring az újsor karaktert is tartalmazza. A beolvasott sztring így néz ki: "1 Am Erika\n". Bár a .readline() függvény egy sort olvas, mégis beteszi a sztring végére az elválasztó karaktert. Ennek két oka van: 1) a fájl végén, a legutolsó sorban már lehet, hogy nincs ilyen, és 2) a .readline() függvénynek opcionális paraméterben megadhatjuk azt, hogy maximum hány karaktert olvasson. Ha a sor hosszabb, akkor nem lesz \n a végén.
• Lényeg a lényeg, hogy ezt a karaktert le kell vágnunk, mert nem tartozik a névhez. Legegyszerűbben ez az .rstrip() (right-strip) függvénnyel tehető meg, amely az összes entert eldobná a sztring végéről. Ezután a sztringünk már ilyen: "1 Am Erika".
• Következő lépésként különválasztjuk a helyezést és a nevet egymástól. Ezt a .split() függvénnyel tehetjük meg, amelyik a sztringet a megadott karakterek mentén darabokra töri, és a darabokat visszaadja egy listában. A levágott darabok számát is megadhatjuk paraméterként. Ez fontos is, mert szóköz nem csak a helyezés után van, hanem a névben is. Sőt a név több szóból is állhat (pl. két keresztnév). A darabok nevű lista tartalma ezek után: ["1", "Am Erika"].
• Végül pedig, ügyelnünk kell arra, hogy a helyezést a programunk egész számként kell kezelje, a fájlból visszaolvasva viszont sztringünk van. Ezért az int() konverzióval egész számmá alakítjuk, mielőtt a versenyző objektumba írnánk.

A fájl végére érve egyébként a .readline() függvény üres sztringet ad. Ez nyilvánvalóan különbözik a fájl közepén lévő üres sortól, amit az egyetlen újsort karaktert tartalmazó sztring reprezentál: "\n". Így a kettőt meg tudjuk különböztetni egymástól.

A feladat megoldásának fájlkezelés része viszonylag egyszerű. Szövegfájlról van szó, azaz "rt" módban nyitjuk meg a fájlt. Ezek után végighaladunk rajta soronként. Üres sor esetén kijövünk a ciklusból, hogy kiírjuk az összeget; amúgy pedig hozzáadjuk az osszeg nevű akkumulátorhoz. (A sor végéről lecsapott enterrel itt nem kellett foglalkozni, mivel az int() konverziót az nem zavarja.)

Képzeljük el, hogy a fájl tartalmaz egy hibás sort, amelyben nincs szám, vagy nem szám van benne. Ekkor az int() konverzió hibát dob. Hogy a hibát tudjuk jelezni (és a hibás sort is meg tudjuk mutatni a felhasználónak), a hibát elkapjuk. A normál kiíráshoz, az összeg megjelenítéséhez csak akkor jutunk, ha nem dobódott kivétel. Ez örömteli, mert hibás fájl esetén úgysem lenne értelme a részösszeg kiírásának.

A gond csak ott van, hogy a fájlt be kell zárnunk. Ez kötelező, elmaradhatatlan művelet, mivel a nem bezárt fájl foglalja az operációs rendszer erőforrásait (resource). Ez talán akkor még megengedhető lenne, ha ezzel vége is lenne a programunknak, de ha fut tovább, akkor biztosan helytelen. Mivel a kivétel keletkezése miatt az első f.close()-t is átugrottuk, ezért a hibakezelés helyén meg kell ismételnünk a sort, hogy akár volt hiba, akár nem, a fájlt biztosan bezárjuk.

Kérdés az, hogy nincs-e erre egyszerűbb megoldás. Nem tudjuk-e valahogy azt jelezni a nyelvnek, hogy normál esetben, ha minden rendben volt, akkor is szeretnénk futtatni az f.close() sort; és hiba esetén, vagyis kivétel keletkezése esetén is.

A finally blokk épp erre való: hogy olyan „takarítás” jellegű műveleteket végezzünk el benne, amit mindenképpen, hibától függetlenül el kell végezni.

A bal oldalon látható nyilak mutatják a vezérlési utat hiba esetén. Ha nem sikerül az int(sor) konverzió, akkor előbb a hibaüzenet kiírásához jutunk, onnan pedig a finally blokkba. Ha minden rendben van, akkor a ciklusból a break utasítással jövünk ki; megjelenik az összeg, és onnan pedig megyünk a finally blokkhoz. Akárhogy is, a fájlt mindenképp bezárjuk.

A finally blokkról még két dolgot érdemes tudni. Egyik, hogy ez önmagában is állhat, nem szükséges except blokknak megelőznie. Másik pedig, hogy ez a blokkból kilépés módjától függetlenül le fog futni. Ezekre mutat példát a következő kódrészlet, amelyik ugyanezt a feladatot oldja meg, de paraméterezhető függvény formájában; a paraméter a fájl neve:

def fajlban_szamok_osszege(fajlnev):
    try:
        f = open(fajlnev, "rt")
        osszeg = 0
        for sor in f:
            osszeg += int(sor)
        return osszeg   # !
    finally:
        f.close()

Ez a függvény nem ír semmit a kimenetre (nem dolga). Csak visszaadja az összeget, vagy hiba esetén kivételt dob. Annak ellenére, hogy nincs except blokk, sőt annak ellenére, hogy látszólag az f.close() később van, mint a return osszeg, a fájl mégis bezáródik. A finally blokkba beleértjük még az ilyen esetet is. Ez még akkor is így történik, ha egy except blokkban másik kivételt dobunk.

Valójában már a fájl megnyitása is dobhat kivételt; pl. FileNotFoundError-t akkor, ha nincs is olyan fájl, vagy PermissionError-t akkor, ha ugyan létezik, de nincs rá olvasási jogunk. Ezért a fájl megnyitását ezen try blokkon kívül kell elvégezni, mert ha nem sikerült a megnyitás, akkor a bezárásnak sincs értelme (sőt, akkor az f változó sem jött létre). Vagyis a fenti függvény professzionális megvalósítása ilyen:

def fajlban_szamok_osszege(fajlnev):
    osszeg = 0
    f = open(fajlnev, "rt")
    try:
        for sor in f:
            osszeg += int(sor)
    finally:
        f.close()
    return osszeg

Látszik, hogy most tényleg csak a fájlból olvasós rész van a hibakezelésbe zárva; azok az utasítások, amiket akkor használunk, amikor a fájl nyitva is van.

Hogyan kell ezt használni? Nagyon egyszerű. A fájl megnyitását, az open(fajlnev, "rt") kifejezést egy with ... as f blokkba kell tenni. Ennek hatására a megnyitott fájlt reprezentáló objektum az f változóba kerül. A with blokk belsejében ezt ugyanúgy használhatjuk, ahogy eddig. A fájl bezárását végző f.close() sort teljesen el is kell hagynunk; ahogy kiléptünk a with blokkból, az automatikusan megtörténik.

Milyen vezérlési utak vannak, milyen hibalehetőségek esetén mi történik? Először is, ha minden rendben van, akkor lefut a with blokk, bezáródik a fájl és visszatérünk a függvényből. Másodszor, ha valamelyik int() konverzió hibát dobott, akkor azt a kivételt nem kapjuk el; viszont a with blokk miatt a függvény elhagyása előtt az f.close() még meghívódik automatikusan. Harmadszor pedig, ha esetleg már a fájl megnyitása sem sikerül (vagyis ha az open() dobja a kivételt), akkor már a with blokkba se megyünk be – viszont akkor bezárni sem kell a fájlt, mert meg sem nyílt.

A működés hátterében két függvényhívás áll. A fájl osztálynak van ugyanis egy __enter__ és egy __exit__ nevű függvénye, amelyek meghívódnak a with blokkba belépéskor és a blokkból kilépéskor. Más osztályok is támogatnak ilyen működést. Tipikusan azok, amelyekhez valamilyen erőforrás tartozik, pl. megnyitott hálózati kapcsolat, képernyőn megjelenített ablak és így tovább. Ez a témakör ebben a félévben csak említésként szerepel; __enter__ és __exit__ függvényeket nem kell tudni írni, csak a with blokkot használni.

A "t"-vel, szöveges módban megnyitott fájl olvasásakor és írásakor az újsor konverziót a fájlkezelő függvények automatikusan elvégzik. Vagyis Unixon pl. a \n sortörést változatlanul kiírják a fájlba, Windowson viszont az f.write("\n") hatására nem egy, hanem két bájt kerül a fájlba. Az automatizmus miatt ezzel nekünk nem kell foglalkozni, csak annyiban, hogy "t" módban kell megnyitni a fájlt, ha szöveges formátumot szeretnénk.

A szövegfájlokat általában lineárisan kezeljük, nem ugrunk benne ide-oda fájlműveletek közben. Bár elvileg lehetséges, de nehéz megvalósítani az adott sorra ugrást: ki kellene számolnunk a bájtban megadott pozíciót. Azt meg nem ismerjük, amíg nem olvastuk be a sorokat, mert minden sor különböző hosszúságú lehet.

A fenti apróságtól eltekintve a szövegfájlok sokkal inkább hordozhatóak, hiszen a bennük tárolt adatok nem függenek a számábrázolás módjától, amit az adott géptípus hardvere határoz meg. Ez az oka annak, hogy az utóbbi években egyre inkább terjednek a szöveg alapú formátumok:

• szöveges dokumentumok: HTML, RTF.
• adatok, adatbázisok: JSON, XML.

A szabványos kimeneti és bemeneti csatornákat (adatfolyamokat, stream) is fájlként látjuk. A normál print(…) függvény nagyjából egyenértékű egy sys.stdout.write(…) hívással, az input(…) pedig egy sys.stdin.readline() hívással. Az stdin neve szabványos bemenet (standard input), az stdout-é szabványos kimenet (standard output). Ezek általában a billentyűzet és a konzol ablak; az operációs rendszer építi rá azokra ezt az absztrakciót, hogy fájlként is tudjuk kezelni őket.

Létezik egy második kimenet is, a sys.stderr, ez az ún. szabványos hibakimenet. A szabványos hibakimenet (stderr) a normál kimenethez hasonló a programunk számára. A kettő közötti különbség az, hogy a normál kimenetre a program által előállított eredményt, kimeneti adatot szokás írni, a hibakimenetre pedig a hibaüzeneteket. Így elkerülhető, hogy a kettő egymással keveredjen, ha a kimeneti adatokat egy fájlba szeretnénk irányítani, vagy egy másik programnak átadni.

Itt lényegében egy hibakódot tudunk visszaadni. A kódokat mi magunk adjuk meg, kicsi egész számoknak kell lennie (legfeljebb 7 bites). A 0 jelenti azt, hogy nincs hiba, bármi más pedig szokásjog alapján hibát jelez. A 0 értékű hibakódot, vagyis a program sikeres futását egyébként nem kötelező sys.exit(0)-val jelezni. Ha azt lehagyjuk (ahogy eddig is tettük, minden egyes programunkkal az eddigi heteken), akkor az sikeres futást jelez.

Vegyük észre, hogy a sys.exit() függvény hívásával azonnal befejeződik a programunk! Vagyis bármi is van alatta, bármilyen függvényhívás mélyén voltunk, a programunk nem folytatódik tovább. Erre utal a függvény neve is egyébként, ezért lett ez exit().

Példa az argumentumokra és a main() visszatérési értékére:

import sys

if len(sys.argv)-1 != 2:
    print(f"{sys.argv[0]}: két számot adj meg!")
    sys.exit(1)

try:
    osszeg = int(sys.argv[1]) + int(sys.argv[2])
except ValueError:
    print("A paraméterek nem egész számok!")
    sys.exit(2)

print(f"Az összegük: {osszeg}")

Hasonlítsuk össze a két fenti kódot! Ugyanazt csinálja mind a kettő, mégis a jobb oldalon látható egy sokkal jobb megoldás.

Mi is történt a bal oldalon? Négy állapota van egy közlekedési lámpának: piros, piros és sárga együtt, zöld, aztán sárga. Ezeket az állapotokat számokkal helyettesítettük: a négy állapotnak négy int típusú érték felel meg, 1, 2, 3 és 4. Na de melyik mit jelent? Ki fog erre emlékezni? A 4 volt a zöld? Vagy a 2? Miért a 3, miért nem 1?

A jobb oldalon létrehoztunk négy változót. Ezek nem változók, konstansnak tekintjük őket; egyszer kaptak egy értéket, amit aztán később soha nem írunk felül. A 4 változót PIROS, PIROSSARGA, ZOLD, SARGA néven nevezzük el, és ezeknek adjuk értékül azokat a számokat, amikkel a négy különböző állapotot, fázist reprezentáljuk. Ezek után bárhol használhatjuk ezeket a neveket: lampa = PIROS, if lampa == ZOLD, gondolkodás nélkül tudjuk, miről van szó.

A konstansok nevét egyébként illik csupa nagybetűvel írni, de ha már felsorolásról van szó, lássunk egy még jobb megoldást!

Legjobb ötlet, ha a konstansokat csoportosítjuk egy osztály segítségével. Ezt a fenti szintaxissal lehet elvégezni. Így az osztály egy névteret (namespace) ad a konstansaink számára; nem csak simán megjelennek azok a globális névtérben, hanem az osztály kifejezi az összetartozásukat is. Innentől kezdve osztályneve.konstansneve formában érjük el az egyes értékeket. Mivel ezeket az osztály neve már csoportosítja, ilyenkor nem szokás már csupa nagybetűvel írni őket.

Létezik egy enum nevű modul (import enum), amelyik plusz támogatást nyújt a felsorolt típusokhoz. Ezt a félévben nem fogjuk használni, csak megemlítjük, hogy van ilyen. A neve a felsorolások angol nevéből jön (enum – enumeration).

Új játék: az inicializálása

class Jatek:
    def __init__(self, kor_nev, iksz_nev):
        self.palya = []
        for _ in range(3):
            self.palya.append([Babu.ures] * 3)
        # ...

Az új játék létrehozásakor beállítjuk az adattagokat a szokásos módon. Utána pedig létrehozunk egy kétdimenziós listát: 3×3-as listát. Vagyis egy olyan 3 elemű listát, ami maga is 3 elemű listákat tartalmaz. Emlékezzünk vissza, erre nem alkalmas a [[0]*3]*3 alakú kifejezés, mert az ugyanazon egyetlen listához kötne 3 referenciát. Helyette mindhárom sort külön létre kell hoznunk.

A pálya kirajzolása

def jatek_kirajzol(j):
    babu_kep = {
        Babu.ures: '.',
        Babu.kor: 'o',
        Babu.iksz: 'x',
    }
    
    print("+---+")
    for y in range(3):
        print("|", end="")
        for x in range(3):
            print(babu_kep[j.palya[y][x]], end="")
        print("|")
    print("+---+")

Kirajzolás közben az egyes lehetséges cella értékekhez hozzá kell rendelni a megfelelő karaktert. Itt ehhez egy dict típusú tárolót, egy szótárat (dictionary) használunk. Ez úgy használható, mint egy lista, csak indexelni bármivel tudjuk, nem csak számokkal; jelen esetben a cellaértékekkel. Később lesz a dict-ről részletesebben szó. Most elég annyit tudni róla, hogy kapcsos zárójelekkel lehet létrehozni: { név: érték }, felsorolva az egyes neveket (name), amikkel indexelni szeretnénk azt, és elérni az értékeket (value). Ezek után pedig az indexelő operátorral érjük el azokat, pl. babu_kep[Babu.kor] == 'o'.

Ez lenne az a függvény, amit lecserélhetnénk abban az esetben, ha más megjelenítést használnánk. Például Pygame alapú grafikát, vagy esetleg színes konzolos megjelenítést.

A következő játékos lépése

def jatek_lep(j, p):
    j.palya[p.y][p.x] = j.kovetkezo
    j.kovetkezo = ki_a_kovetkezo(j.kovetkezo)

Ha a körrel játszó játékos jön, kört teszünk az adott pozícióra. Ha az iksszel játszó, akkor ikszet. Itt kihasználjuk, hogy ugyanaz a felsorolt típus reprezentálja a játékost, és az általa használt bábut. Hogy ki a következő játékos, azt pedig a ki_a_kovetkezo() függvény. Ezek olyan egyszerűek, hogy már nem is részletezzük.

Mit tartalmaz ez a fájl, miért így találtuk ki?

• Egyrészt egy bevezető sort: Tictactoe v1.
• Utána a két játékos neve jön.
• Ez folytatódik annak rögzítésével, hogy hol tart a játszma, ki lép következőnek.
• Végül pedig a játékállás.

Jegyezzünk meg pár érdekességet!

Miért jó a bevezető sor? Egyrészt ebből látszik, hogy a fájl milyen adatokat tartalmaz, tehát ha esetleg megnyitjuk jegyzettömbben, vagy más fájlkezelő programban, akkor lehet sejtésünk, mire való. Másrészt ez kaphat egy verziószámot is. Ha később továbbfejlesztjük a programot, és változik a formátum, akkor ebből kiderül, mikori program készítette a fájlt. Így némi többletmunkával megoldhatjuk, hogy az új program felismerje a régebbi formátumokat, kompatibilis legyen azokkal is.

A pálya állapotának rögzítésekor a felsorolt típus értékét írjuk ki, az egész számot, amivel reprezentáljuk azt. Csak arra kell majd vigyáznunk, hogy ezeket az értékeket ne változtassuk meg. Persze ezt megoldhatnánk úgy is, hogy a fájlban is pont, o és x karaktereket használunk a cellák jelölésére, ahogy a fenti egyszerű megjelenítésben tettük.

Végül pedig, a következőnek lépő játékos rögzítése tulajdonképp felesleges (ami a nevek után található egész szám). Ha kevesebb x van a pályán, akkor az x-szel játszó játékos jön, amúgy pedig a körrel játszó. Ezt tulajdonképp ki lehet találni a játékállás vizsgálatával. De inkább eltároljuk, mert egyszerűbb lesz tőle a programunk, az az egy karakter pedig már igazán nem számít.

Az állás betöltése (szintén csak a lényegi rész):

verzio = f.readline()   # itt ellenőrizhetnénk
j.kor_nev = f.readline().rstrip("\n")
j.iksz_nev = f.readline().rstrip("\n")
j.kovetkezo = int(f.readline())
for y in range(3):
    sor = f.readline().split(" ")
    for x in range(3):
        j.palya[y][x] = int(sor[x])

Itt talán csak a pályát beolvasó rész az, amiről érdemes külön beszélni. Ebben ugyanúgy soronként haladunk, mint ahogy a pálya kirajzolásával is. Azért jó, hogy a pálya minden sorát a fájlban is külön sorba tettük, mert így a visszaolvasó ciklusunk is soronként, egyszerű f.readline() függvényhívásokkal tud haladni. A sorokban lévő számokat szóközzel választjuk el, tehát egy .split(" ") darabokra tördeli azt; végül mindegyiket int-té kell alakítani.

A beolvasás közben rengeteg hiba történhet. Mi történik akkor, ha hibás a fájl, és túl hosszú nevet olvasnánk be? Túlindexelődik a lista. Mi történik akkor, ha a felsorolt típusok értékei helyett egy olyan szám jelenik meg, amilyen értéket az adott típus nem vehet föl? Például a Babu típus üres, kör, iksz értékeit a 0, 1 és 2 számok ábrázolják a memóriában. Mi történik, ha az egyik cella helyén 97214 van a fájlban? Erre is helytelenül fog működni a továbbiakban a programunk. Ezért az összes beolvasott adatot ellenőrizni kellene. Ezek most az egyszerűsített példánkban elmaradtak.

Egy közepes projekt néhány tízezer sorból áll, egy nagy projekt több százezer, millió sorból.

Ha a projekt egyetlen, nagy forrásállományban lenne megírva:

• akkor áttekinthetetlen lenne,
• a szerkesztő programok nehezen/lassan kezelnék,
• nehézkes lenne többen egyszerre dolgozni rajta,
• egy-egy újrafordítás akár órákat vehetne igénybe.

Ha szerkezeti egységekre bontjuk a programot:

• ezek önállóan kezelhetőek, a program ezek összeépítéséből keletkezik,
• egy csapat különböző tagjai egymástól függetlenül dolgozhatnak,
• az egyedi fordítások gyorsan lezajlanak.

Ez az egyedül fejlesztett programoknál is nagyon hasznos: az egyes modulok újra felhasználhatóak más projektekben. Érdemes a funkcionális egységeket általános módon megírni, hogy minél könnyebben fel lehessen használni őket más feladatok megoldásában.

A programot logikusan több modulra lehet bontani. Az első a fő programmodul. Ez tartalmazza a main() függvényt, amely a programot vezérli. A másik modul a játékhoz tartozó programrészekből áll össze: ez definiálja a pálya típust, és pl. a játékszabályt, a játék működését leíró függvényeket. A harmadik modul az, amelyik a megjelenítésért, a felhasználóval való kommunikációért felel: a pálya kirajzolásáért és a pozíció beolvasásáért.

Az egyes modulok nagyjából önállóak. A megjelenítésért felelős modul lecserélhető lenne egy olyan változatra, amely nem konzollal dolgozik (print(), input()), hanem színes, grafikus megjelenítést használ, és a pozíciót egérkattintásból nyeri. A megjelenítésért és a játékszabályokért felelős modul nem kommunikál egymással; a fő programmodul dolga az, hogy a két almodul által adott programrészekből, azok függvényeinek hívásából egy működő, egész programot állítson össze.

Az assert nyelvi elem utasításként használandó. Ez megállítja a program futását, ha a megadott feltételek nem teljesülnek. Például akkor, ha a legnagyobb közös osztót meghatározó függvényünk nem pozitív számokat kap.

Az ilyen jellegű hibák kapcsán eszünkbe juthatnak a kivételek is. Valóban, ez a függvény kivételt is dobhatna akkor, ha nullának vagy negatív számoknak a legnagyobb közös osztóit keressük.

Kivételeket akkor szoktunk használni, amikor a programot a futás közben előálló hibákra szeretnénk felkészíteni – olyan körülményekre, amik előfordulhatnak üzemeltetés közben. Az assert annyiban különbözik ettől, hogy azzal programozói hibákat próbálunk megfogni. Ha kivételt dobunk hiba esetén, az az jelenti, hogy az adott eset előfordulhat, a hibát kezelni kell. Ha assert-et használunk, azzal pedig azt, hogy ha az adott eset előfordult, akkor a programkódot javítani kell, mert hibás.