Program és külvilág. Karbantartható programok

A program és a külvilág

A fájlok kezelése az open függvény által visszaadott, IOBase típusú objektum segítségével lehetséges (input/output base). Nézzük a legegyszerűbb esetet!

f = open("hello.txt", "wt")  # megnyitás

f.write("Helló, világ!\n")
for i in range(1, 10 + 1):
    f.write(f"{i} ")

f.close()                     # bezárás

Helló, világ!
1 2 3 4 5 6 7 8 9 10

• Megnyitás módja: írás (w) vagy olvasás (r).
• A fájl típusa: szöveges (t) / bináris (b).

Tegyük fel, hogy adott egy szövegfájl, benne egy futóverseny eredményeivel. Minden sor egy helyezést tartalmaz, azon kívül pedig a nevet.

Az alábbi kód az első sor beolvasását mutatja.

Egy sor beolvasása részleteiben:

1  Am Erika
2  Dil Emma
3  Break Elek
...
10 M. Ágnes
11 Ó Pál
...

f = open("verseny.txt", "rt")

sor = f.readline()          # "1 Am Erika\n"

sor = sor.rstrip("\n")
darabok = sor.split(" ", 1) # ["1", "Am Erika"]
v = Versenyzo()
v.helyezes = int(darabok[0])
v.nev = darabok[1]

f.close()

Általában a fájlban több adatsor van:

for sor in f:               # iterálható, sorokat ad
    sor = sor.rstrip("\n")
    ... sor feldolgozása ...

Ha a fájlból több egyforma adatsort szeretnénk beolvasni (egészen addig, amíg a végére nem érünk), akkor legegyszerűbb, ha iterálunk rajta. A for ciklus ugyanis működik fájlokon is; a fájl sorait kapjuk meg általa a ciklusváltozóban. Persze ezek a sorok ugyanúgy tartalmazzák az enter karaktert, amit le kell vágni.

Ez a módszer csak akkor tud működni, ha soronként kell haladnunk.

Feladat: Egy fájl egész számokat tartalmaz. Adjuk össze ezeket!

78
345
99
37
1268
77
85

    try:
        f = open("szamok.txt", "rt")
        osszeg = 0
        while True:
            sor = f.readline() # "", ha vége
            if sor == "":
                break           ───┐
┌───        osszeg += int(sor)     │
│       f.close()               ◂──┘
│       print("Az összeg:", osszeg)
│   except ValueError as e:
└──▸    f.close()
        print("Hibás bemenet:", sor)

Szerencsére van ilyen. Az opcionális finally blokk egy try–except hibakezelő blokkot zárhat le. Ide olyan programrészt írhatunk, amelyik lefut mindkét esetben: ha volt hiba, akkor is, és ha nem volt, akkor is.

    try:
        f = open("szamok.txt", "rt")
        osszeg = 0
        while True:
            sor = f.readline()
            if sor == "":
                break               ───┐
┌───        osszeg += int(sor)         │
│       print("Az összeg:", osszeg) ◂──┘
│                                   ───┐
│   except ValueError as e:            │
└──▸    print("Hibás bemenet:", sor)   │
┌───                                   │
│   finally:                           │
└──▸    f.close()                   ◂──┘

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

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

Észrevehetjük, hogy a fájl megnyitása és bezárása egy keretet kell adjon a fájlkezelésnek. Biztos ott kell lennie a blokk elején a megnyitásnak, és biztosan ott kell lennie a végén a bezárásnak is.

Az ilyen helyzetek kezelésére találták ki a with kulcsszót, az ún. context manager-t. Egy with blokk megadásával a fájl bezárását és a hibakezelést automatikussá tehetjük, anélkül hogy külön try–except, vagy try–finally blokkot kellene írnunk.

A with blokk bevezetésével az alábbi formát ölti a függvényünk:

def fajlban_szamok_osszege(fajlnev):
    osszeg = 0
    with open(fajlnev, "rt") as f:
        for sor in f:
            osszeg += int(sor)
    return osszeg

Miért jó ez?

• Nem kell f.close() – automatikus.
• Nem kell try–finally sem.

A szövegfájlok azokat a karaktereket tartalmazzák, amelyeket a print() a képernyőre is írna. Azt gondolnánk, hogy a szövegfájlok könnyedén átvihetők egyik számítógépről / operációs rendszerről a másikra, azonban lehetnek apró különbségek. Ha a fentebbi, helló világos programot lefuttatjuk Windowson és valamilyen Unix operációs rendszeren, akkor két különböző fájlt kapunk. Egyes rendszerek máshogy jelzik a szövegfájlokban a sorok végét (\n). Windowson két bájt, CR LF (0x0D 0x0A), Unixokon csak LF (0x0A).

Unixokon (pl. Linux):

48 65 6C 6C   6F 2C 20 76   69 6C 61 67   21 0A 30 0A   Hello, vilag!.0.
31 0A 32 0A   33 0A 34 0A   35 0A 36 0A   37 0A 38 0A   1.2.3.4.5.6.7.8.
39 0A 31 30   0A 31 31 0A   31 32 0A 31   33 0A 31 34   9.10.11.12.13.14
0A 31 35 0A   31 36 0A 31   37 0A 31 38   0A 31 39 0A   .15.16.17.18.19.

Windowson:

48 65 6C 6C   6F 2C 20 76   69 6C 61 67   21 0D 0A 30   Hello, vilag!..0
0D 0A 31 0D   0A 32 0D 0A   33 0D 0A 34   0D 0A 35 0D   ..1..2..3..4..5.
0A 36 0D 0A   37 0D 0A 38   0D 0A 39 0D   0A 31 30 0D   .6..7..8..9..10.
0A 31 31 0D   0A 31 32 0D   0A 31 33 0D   0A 31 34 0D   .11..12..13..14.
0A 31 35 0D   0A 31 36 0D   0A 31 37 0D   0A 31 38 0D   .15..16..17..18.
0A 31 39 0D   0A                                        .19..

Szöveges módban nyitott fájlnál ezt elfedi nekünk a nyelv. Kezelés: f = open(név, "...t"), f.write("sztring\n"), f.readline().

A bináris fájlok azok, amelyek nem szöveget tartalmaznak. Ezekbe bájtokat írunk; legtöbbször bájtról bájtra kiírunk valamilyen memóriaterületet. Ilyeneket általában a Python bytes osztályának segítségével kezelünk.

Bináris fájl írása (egyetlen egy int):

i = 123456
f = open("file.dat", "wb")
f.write(i.to_bytes(4, byteorder='little'))
f.close()

A keletkező fájl tartalma (bájtok):

40 E2 01 00

A bináris fájlba jelen példában egy 4 bájtos integert írtunk bele, little endian bájtsorrendben – azaz előbb a kicsi helyiértékek vannak, utána a nagyok (lásd a Hardver alapok tárgyon tanultakat). Így jelentek meg a fájlban a 40 E2 01 00 bájtok, mert 123456 tízes számrendszerben felírva 0x0001E240.

A fájl olvasása:

f = open("file.dat", "rb")
bytearr = f.read(4)
i = int.from_bytes(bytearr, byteorder='little')
f.close()
print(i)    # 123456

A fentihez hasonló módon bináris módban nyitjuk meg a fájlt: b = binary. Innen tudja a Python, hogy most karakterkódolásokkal, sorvégek jelölésével nem kell foglalkoznia: nyers adatot fogunk olvasni, bájtról bájtra azt szeretnénk látni, amit eltároltunk.

A beolvasás a .read() függvénnyel történik. Ennek most pontosan megmondjuk, hogy hány bájtra vagyunk kíváncsiak, mivel itt nincsenek határolók, mint egy szövegfájlban. A beolvasás által egy bytes típusú objektumot kapunk. Jelen példában ezt alakítjuk vissza int típusú adattá.

Bináris fájlokat használunk akkor, ha 1) tömör, kicsi fájlt szeretnénk létrehozni (pl. ha számokat kell tárolni, akkor ez kisebb fájlt eredményez), illetve ha 2) nagy mennyiségű adatot kell gyorsan kezelni (mivel szövegfájloknál a szöveggé alakítás jelentős időbe telik).

import sys

sys.stdout.write("Írj be egy sort: ")   # print()
sys.stdout.flush()

line = sys.stdin.readline()             # input()
text = line.rstrip("\n")

if text != "":
    sys.stdout.write(f"|{text}|\n")
else:
    sys.stderr.write("Hiba: nem írtál be semmit!\n")

• sys.stdin – szabványos bemenet (standard input)
• sys.stdout – szabványos kimenet (standard output)
• sys.stderr – szabványos hibakimenet (standard error)

A Python programjaink parancssorból is indíthatóak. Ehhez a python3 nevű programnak paraméterként át kell adnunk a forrásfájl (valami.py) nevét:

Futtatás parancssorból:

C:\> type program.py
# Üdvözlet
print("Helló, világ!")

C:\> python3 program.py
Helló, világ!

A program bemenete és kimenete fájlból/fájlba átirányítható. Például, ha a kimenetét a képernyő helyett egy fájlba szeretnénk átirányítani:

Átirányítás fájlba:

C:\> python3 program.py >udvozlet.txt

C:\> type udvozlet.txt
Helló, világ!

A bemenet átirányítása ugyanígy történik, csak másik irányú kacsacsőrrel, pl. <bemenet.txt. Ilyenkor a program nem tudja, hogy át van irányítva; mindkét esetben a program a szabványos bemenetére és a szabványos kimenetére ír, és az operációs rendszer a háttérben megoldja, hogy a képernyő vagy billentyűzet helyett egy fájlt lásson. Erről operációs rendszerek tárgyon lesz szó részletesebben.

Az elindított programoknak is lehet paramétereket adni:

C:\> notepad.exe szoveg.txt_

A Python programunk a sys.argv listában kapja meg ezeket. A paraméterek eléréséhez importálnunk kell a sys modult. Ezután érjük el az argv nevű listát, amelyik az egyes paramétereket tartalmazza. Ennek tradicionálisan lett ez a neve; arg, mert az argumentumok vannak benne, és v, mert vektor (emlékezzünk vissza, így is szokás a tömböket nevezni).

Például:

C:\> teszt.py  elso  "masodik szo"
       ↑        ↑        ↑
    argv[0]   argv[1]  argv[2]

import sys

print(sys.argv)  # ["teszt.py", "elso", "masodik szo"]

A sys.argv[] lista különlegessége, hogy a nulladik eleme, azaz argv[0] a program nevét tartalmazza. A tényleges paraméterek csak ezután jönnek. Ez okozza azt, hogy az első tényleges paraméter (a fenti példában az "elso") nem a lista nulladik, hanem első indexű helyén van. A paraméterek számába a program saját neve is beleszámít, ezért a fenti példában len(argv) értéke nem kettő, hanem három. Ha a programban a kapott parancssori paraméterek számát ellenőrizni szeretnénk, ezt figyelembe kell venni.

A programot befejezve vissza tudunk adni egy egész számot. Ezt átveszi az operációs rendszer, és átadja a programnak, amely elindította a mienket.

Visszatérés hibakóddal:

import sys

if len(sys.argv) - 1 != 2:
    print("Két paraméter kell!")
    sys.exit(1)     # hibakód

#
# a program tényleges feladatai ...
#

sys.exit(0)         # vagy egyszerűen semmi

Mire jó ez?

rm szoveg.txt || echo "Nem sikerült törölni a fájlt!"

A visszatérési értékek lehetővé teszik, hogy a parancssorban összekössük az egymás után futó programokat aszerint, hogy sikeres volt-e a végrehajtásuk. A Unix parancssorában például az || operátor csak akkor hajtja végre a második parancsot, ha az első sikertelen volt. Jelen példában ez azt jelenti, hogy ha az rm program 0-tól különböző kóddal tért vissza a maga main() függvényéből, akkor hajtódik csak végre az echo program, amelyik a hibaüzenetet kiírja. Amúgy ez elmarad, mert ha sikeres volt a törlés, nincs szükség hibaüzenetre.

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}")

Fontos emlékezni arra, hogy a sys.argv sztringeket tartalmaz. Ha számokat veszünk át paraméterként, azt is sztringként kapjuk! Ilyenkor int() konverzióra van szükség.

Nagyobb program tervezése

Felsorolt típus

Olyan típus, amelynek értékkészlete egy nevekkel megadott, véges értékhalmaz.

Kártya színe

♠ ♣ ♥ ♦

Tic-tac-toe

Közlekedési lámpa

lampa = 1

if lampa == 3:
    print("Mehet az autó!")


# Mit jelent a 3?
# Mit jelent az 1?

PIROS = 1
PIROSSARGA = 2
ZOLD = 3
SARGA = 4

lampa = PIROS
if lampa == ZOLD:
    print("Mehet az autó!")

class Lampa:
    piros = 1
    pirossarga = 2
    zold = 3
    sarga = 4

lampa = Lampa.piros
if lampa == Lampa.zold:
    print("Mehet az autó!")

Tic-tac-toe játék

• Tároljuk a pályát
• Tároljuk a játékosok neveit
• Új játékot kezdünk
• Kirajzoljuk a pályát
• Lépünk egy játékossal
• Ellenőrizzük, nyerésre áll-e valamelyik játékos

Teendők a program megírásához

• Definiáljunk típusokat
• Írjuk meg a játékot vezérlő függvényeket
• Definiáljunk fájlformátumot
• Mentsük, töltsük vissza az állást

A pálya egy cellája

A pálya egy cellája csak ezt a három értéket veheti fel. Ezért ezt egy felsorolt típussal ábrázoljuk (Babu), amelyekből a pályához majd 3×3-as, kétdimenziós tömböt építünk (egymásba ágyazott listákkal).

class Babu:
    ures = 0
    kor = 1
    iksz = 2

Melyik játékos következik?

Leírjuk a fenti típussal.

A két játékos felváltva léphet. A programnak erre is emlékeznie kell majd. Ugyan a két állapot megtévesztő, a logikai típus, bool eszünkbe juthat miatta, de ez rossz döntés lenne. A „melyik játékos következik?” nem eldöntendő kérdés, értelmetlen „igen” vagy „nem” választ adni rá. A „körrel játszó” és az „x-szel játszó” a helyes válaszok. Bár igaz az, hogy mindkét játékos a saját bábujával lép, de ez a két dolog mégsem ugyanaz: nincs olyan, hogy az üres cellával lépő játékos következik. Ezért ezt reprezentálhatnánk egy külön típussal is, de egyszerűbb, ha a bábu típust használjuk újra.

A felsorolt típus felesleges tánclépésnek tűnik, mert tudjuk, hogy a bábukat, játékosokat végeredményben egész számok fogják reprezentálni. De mégis érdemes megtenni, mert később olvashatóbb lesz tőle a programunk, és a programkód jelentését függetleníteni tudjuk attól, hogy valójában melyik szám reprezentálja melyik bábut. Gondoljunk egy szövegre és a karakterkódokra: az "alma" sztring a memóriában a 97, 108, 109, 97 számokkal reprezentálódik. De ez mindegy, mert amíg a karaktereket látjuk, lényegtelen, hogy a hozzájuk tartozó kód micsoda.

A játék adatszerkezet

A játék állásához, állapotához rögzíteni kell a pálya állapotát, a következő körben lépő játékost, és a játékosok neveit.

Az összetartozó adatokhoz létrehozunk egy osztályt:

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

A játékállást kezelő függvények

Miért jó ez? Azért, mert az egyes függvényeink rengeteg paraméterrel rendelkeznének, ha ez nem lenne. Így viszont egyetlen paramétere lesz mindegyiknek: a játék objektum, amelyben minden lényeges információ megtalálható.

j1 = Jatek("Aladár", "Kriszta")
jatek_lep(j1, Pozicio(1, 1))
jatek_lep(j1, Pozicio(2, 2))
jatek_kirajzol(j1)

Figyelem: emlékezzünk vissza, hogy mi volt a helyzet a paraméterátadásokkal, és a paraméterként átadott objektumok módosításával. Egy függvény nem tudja módosítani a neki átadott változót, mert csak a változóban tárolt referenciát tudja módosítani. Jelen példában a Jatek osztály konstruktora létrehoz egy új objektumot, és ahhoz a j1 változóban tárolt referenciát kötjük az értékadással. Hiába próbálnánk jatek_uj(j1)-et írni, az nem működne. A lépést végző függvény viszont egy meglévő objektum referenciáját kapja; nem a j1 változót fogja módosítani, hanem a j1 referencia által mutatott objektumot.

Vegyük észre azt is, hogy a jatek_lep() függvény nem kapja paraméterként, hogy melyik játékos következik, csak a pozíciót, hogy hova lépett. Hogy ki jön, az eltárolódik a játék objektumban: j1.kovetkezo. Nyilvánvaló, hogy a jatek_lep() függvény ezt is frissíti majd, így alakul ki az, hogy az (1;1) pozícióba kör kerül, a (2;2) pozícióba pedig iksz.

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

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("+---+")

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

A Jatek struktúrát kigondolva a dolgunk egyszerű: az abban lévő adatokat mentjük egy fájlba. Például így:

Tictactoe v1
Aladár
Kriszta
1
0 0 0
0 1 0
1 0 2

A játék mentése (lényegi rész, a többi letölthető):

f.write("Tictactoe v1\n")
f.write(j.kor_nev + "\n")
f.write(j.iksz_nev + "\n")
f.write(str(j.kovetkezo) + "\n")    # "1\n"
for y in range(3):
    for x in range(3):
        f.write(str(j.palya[y][x]) + " ")   # "2 "
    f.write("\n")

Ahogy a képernyőre írásnál is tennénk, itt is ügyelünk arra, hogy a számok kiírása után tegyünk elválasztó karaktert: szóközt vagy entert. Ez teszi lehetővé, hogy a számot vissza tudjuk majd olvasni a szövegfájlból. Mert pl. "1 0 2" ez három kiírt szám, ugyanakkor viszont "102" ez csak egy, amit aztán nehezebb visszaolvasni.

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])

Többmodulos programok

def main():
    j1 = Jatek("Aladár", "Kriszta")

    ………

    while ………:
        jatek_kirajzol(j1)
        p = pozicio_beolvas()
        if jatek_lep(j1, p):
            nyert = True
            break

    ………

    jatek_ment(j1, "tictactoe.txt")
    jatek_betolt(j1, "tictactoe.txt")

A program egyes részfeladatait, függvényeit az őket tartalmazó modul szerint különválasztjuk az egyes forrásfájlokba. Így jön létre a jatekallas.py, a megjelenites.py, amelyek lentebb láthatóak. Ezen felül lesz egy main.py fájlunk is, a főprogrammal.

class Babu: ………
class Jatek: ………
class Pozicio: ………

def harmas(): ………
def nyert_e(): ………
def mivel_jatszik(): ………
def kovetkezo(): ………
def lep(): ………
def ment(): ………
def betolt(): ………

def jatek_kirajzol(): ………
def pozicio_beolvas(): ………

import jatekallas
import megjelenites


def main():
    j1 = jatekallas.Jatek("Aladár", "Kriszta")
    
    # 9 lépéssel megtelik a pálya
    for i in range(9):
        megjelenites.jatek_kirajzol(j1)
        p = megjelenites.pozicio_beolvas()
        if jatekallas.jatek_lep(j1, p):
            nyert = True
            break
    else:
        nyert = False
    
    ………

Ezeket a modulokat a félév elején megismert import kulcsszóval tudjuk majd felhasználni a másik modulban. Mivel innentől kezdve az egyes függvényeket a modul nevével együtt kell hivatkoznunk, pl. jatekallas.lep(), ezért a nevek prefixelése feleslegessé válik. Például a fájlba mentő függvény jatek_ment() helyett egyszerűen lehet ment(), és azt a főprogramból jatekallas.ment() néven tudjuk majd elérni. Látszik a fenti példán, hogy mindez igaz a függvényekre is, pl. megjelenites.pozicio_beolvas(), és az osztályokra is: jatekallas.Jatek.

A modul neve egyébként meg kell egyezzen a fájl nevével. Ha import jatekallas-t írunk a kódban, akkor a Python a jatekallas.py fájlt fogja keresni.

Az egyes modulok egymást is elérik; például a megjelenítésért felelős modul is import jatekallas sorral indít, mert neki is tudnia kell, hogy mi az a Babu, és mi az a Jatek.

Programok életciklusa

1. Specifikáció
   • Elvárások, képességek (feature)
   • Mit fog tudni a program
2. Fejlesztés
   • fejlesztői eszközök, technológiák megválasztása,
   • a rendszer magas szintű megtervezése:
     • modulok és kapcsolatuk,
     • be-, és kimeneti formátumok,
   • algoritmusok, adatszerkezetek megtervezése,
   • implementáció elkészítése (kód dokumentálása párhuzamosan),
   • tesztelés, hibajavítás,
   • dokumentáció elkészítése.
3. Támogatás, továbbfejlesztés

A dokumentáció szintjei:

1. Fejlesztői (programozói) dokumentáció
   • adatszerkezetek dokumentációja,
   • algoritmusok dokumentációja,
   • a kód szerkezeti áttekintése,
   • a kód részletes dokumentációja.
2. A forráskód
   • kommentezés, ha szükséges
3. Felhasználói dokumentáció
   • a program használatának a leírása
4. Tesztelési dokumentáció
   • a tesztelés körülményeit, eredményeit írja le

def prim(szam):
    """Megmondja, hogy egy szám prímszám-e."""
    for oszto in range(2, szam):
        if szam % oszto == 0:
            return False
    return True

A Docstring-eket több eszköz is kezeli:

• A beépített help() függvény.
• PyDoc és hasonló programok

Feladatunk megkeresni egy szöveg első szavának utolsó karakterét.

Milyen a jó komment?

i = 0
while szoveg[i] != " ":
    i += 1
# lecsökkentjük i-t
i -= 1

Biztosan nem ilyen. Ez semmivel nem mond többet, mint az általa magyarázott sor. Mindenki tudja, hogy a -= 1 utasítás lecsökkenti a változóban tárolt értéket. Ha kitöröljük ezt a kommentet, nem lesz kevesebb információ a kódban, ezért nincs semmilyen haszna. Sőt valójában negatív a haszna, konkrétan árt: hosszabb lett tőle a kód.

i = 0
while szoveg[i] != " ":
    i += 1
# visszalépünk az utolsó karakterre
i -= 1

Ez már sokkal jobb. Ez kifejezi a szándékát annak a sornak: nem csak azt tudjuk, hogy mit csinál az a sor, hanem már azt is, hogy miért! De tudunk ennél jobbat is...

i = 0
while szoveg[i] != " ":
    i += 1
utolso = i-1

Nem kell a komment! A kódban a változó neve elmondja, hogy mi volt a célja az előző ciklusnak, és mi a célja a -1-nek: megtalálni az utolsó karaktert a szóköz előtt, amelynek az indexe ezentúl az utolso nevű változó tárolja. Ez a kód többi részére is jó hatással lesz: nem a semmitmondó i néven kell elérjük ezt az információt.

utolso = szoveg.find(" ") - 1

Ez pedig a legjobb: a ciklust is megmagyarázza, hogy a szóköz megkeresése volt annak a célja. Azzal, hogy a részműveletet külön függvénybe tettük (történetesen most volt olyan a sztring osztályban is), elértük, hogy el tudtuk nevezni azt is.

Szintaktikai hiba

Nyelvtanilag hibás kód – le sem fut.
Pl. for x range(10)

Szemantikai hiba – bug

Nyelvileg helyes, de logikailag hibás program.

• Hibás algoritmus, hibás kódolás…
• Lista negatív indexelés…

Futási idejű hibák: hibás bemenet

A program jó, de a külső körülmények nem.

• Felhasználó rossz adatot gépel
• Hibás a beolvasott fájl

A tesztelés sokkal fontosabb és nehezebb lépés, mint gondolnánk!

• Egy egyszerű programot könnyű letesztelni.
• Egy komplex rendszer összes funkcióját leellenőrizni minden lehetséges bemenet és belső állapot esetén szinte lehetetlen.

A kis részektől a nagy felé haladva érdemes tesztelni.

• Minden függvényt külön is tesztelni kell.
• Minden lehetséges ágat (elágazások, ciklusok) ki kell próbálni.

„Trace”-elés

if DEBUG:
    print(x, file=sys.stderr)

A tesztelt program extra kimenete: a változó értéke mindig megjelenik a képernyőn, ha elér erre a pontra.

Nyomkövetővel (debugger)

• Változó értékének megfigyelése (watch)
• Töréspont (breakpoint)
• Lépésenkénti végrehajtás

assert: programozói hibák megtalálására való.

def lnko(a, b):
    assert a > 0 and b > 0
    ...

Automatikus tesztek:

tabla = halmaz_letrehoz()

halmaz_betesz(tabla, "alma")
halmaz_betesz(tabla, "körte")
assert(halmaz_benne_van(tabla, "alma"))
assert(halmaz_benne_van(tabla, "körte"))

halmaz_kivesz(tabla, "alma")
assert(not halmaz_benne_van(tabla, "alma"))
assert(halmaz_benne_van(tabla, "körte"))

Ha jól körülhatárolt a feladat, akkor valószínűleg könnyű automatikus teszteket is írni hozzá. Például veszünk egy halmazt. Betesszük az alma és a körte sztringeket. Ezek után a benne van-e? kérdésre igazzal kell válaszolnia mindkettőre. Aztán kivesszük az almát, így arra a szóra már hamis kell legyen a válasz. Viszont nem tűnhetett el a körte, mert azt nem szedtük ki stb.

Bár úgy tűnik, a tesztek írásával csak megy az idő, valójában viszont az a tapasztalat, hogy gyorsítják, hatékonyabbá teszik a fejlesztést! Ha vannak tesztek, jobban letisztázódik, mi a konkrét feladat, mik az elvárások. Ha tudjuk a programot automatikusan tesztelni (és ez egy kattintásunkba telik!), akkor bátran módosíthatjuk bármelyik részüket – ha elrontottunk valamit, a tesztek jelezni fogják.

Gyakran a program és a tesztek írását konkrétan megfordítják: előbb írják meg a teszteket, és csak azután a programot. Ez az ún. TDD, test driven development. Ez a szoftverfejlesztési metodika azt javasolja, hogy neki se álljunk a program megírásának előzetesen megírt tesztek nélkül.

Ha vannak tesztjeink, hibák felfedezésekor bővíthetjük is azokat. Ha minden megtalált hibánál így teszünk, azzal biztosítjuk az is, hogy a hiba soha többé ne jöhessen elő újra. Mert azt a hibát onnantól kezdve mindig meg fogják fogni a tesztek. Minderről későbbi programozás tárgyakon lesz szó részletesen.

Az előadáson megismertek alapján:

• Tudni kell szöveges és bináris fájlokat kezelni.
• Ismerni kell a try/except/finally szerkezetet szintaktikáját és használatát.
• Tudni kell használni a context manager (with) szerkezetet.
• Ismerni kell a sys modul által biztosított szabványos adatfolyamokat és a parancssori argumentumok használatát.
• Tisztában kell lenni a többszörös összetétellel.
• Ismerni kell a felsoroló típus megvalósítási lehetőségeit Python nyelven
• Tudni kell többmodulos programokat fejleszteni.
• Tisztában kell lenni az assert használatával.