Összetett adatok: osztályok

Pót ZH – 11. héten

• Azoknak, akiknek NZH < 20 pont
• Időpont: nov. 13. hétfő, 18:15 HSZK, QB.310 / QB.311 (EET számítógépes laborjai)
• Első közelítésben MM és INFO szakon egyszerre
• Szervezés: minden ugyanúgy
• Jelentkezni a portálon

Megajánlott jegy

• Pontszámítás: követelmények menüpont!
• Az első megírt nagy ZH számít, vagyis pót ZH-n megajánlott jegyért javítani nem lehet

Típus: értékkészlet és hozzá tartozó műveletek.

Egyszerű, beépített típusok:

• Számok: int, float, pl. 5, 3.14
• Logikai: bool, csak True és False
• Üres: NoneType, csak None
• Szövegek: str, pl. "helló"

Mint láttuk az előző előadáson, a Pythonban ez a határ nem éles; például az egyszerű egész számok is objektumok.

Összetett, származtatott típusok:

• Lista: (általában) egyforma típusú elemek sorszámozott tárolója
• Osztály: összetartozó adatok, egy dolog tulajdonságai – erről lesz most szó.

A type() függvénnyel lekérdezhető egy érték típusa:

print(type(5))
print(type("alma"))
print(type([1, 2, 3]))

<class 'int'>
<class 'str'>
<class 'list'>

Emlékezzünk vissza: minden értéknek van egy típusa, amely meghatározza az értékkészletet (ábrázolható értékek halmaza), és a műveleteket (pl. számnál összeadás, sztringnél összefűzés, listánál elem kiválasztása). Ugyanez igaz a változókra is, bár ott valójában nem a változó az, aminek típusa van, hanem a változó egy referenciát tartalmaz egy értékre (objektumra), és annak van típusa.

Egy érték típusa lekérdezhető a type() függvénnyel. Ez a függvény egy másik értéket ad: egy olyan objektumot, amely az adott típust reprezentálja. Például a type(5) kifejezés értéke int, ahol az int egy globálisan (minden függvényből) látható érték. Ugyanígy, type("alma") értéke str.

A típusokat létező objektumok reprezentálják, így:

print(type(5) is int)
print(type(5) is str)

True
False

Rövidebben:

print(isinstance(5, int))
print(isinstance(5, str))

True
False

Mivel minden típust reprezentáló objektumból egyetlen egy van, ezért az is és az is not operátorral meg tudjuk vizsgálni annak identitását. Így végeredményben egy érték típusát könnyen ellenőrizhetjük: a type(5) is int értéke igaz, type(5) is str értéke hamis, mert az 5 egy egész szám, nem pedig egy sztring. A type(érték) is típusneve kifejezést rövidíteni is lehet, az isinstance() függvénnyel: isinstance(érték, típus) akkor igaz, ha az első paraméter típusa megegyezik a második paraméterként megadott típussal. Az „instance” szó példányt jelent: tulajdonképpen azt nézzük meg a fenti példányban, hogy az 5, mint érték, az int típus egy példánya-e (int típusú objektum-e), vagy nem.

Megjegyzés: az isinstance(x, y) valójában nem teljesen ugyanaz, mint a type(x) is y, mert altípusok (subtype) esetén is igazat ad. De ez a második félév témája, ebben a félévben erről egyáltalán nem lesz szó.

Mire jó a típus vizsgálata? Például esetszétválasztást tudunk csinálni, eltérő típusú értékekre másképp megoldani valamilyen feladatot.

Feladat: írjunk függvényt, amelyik kiírja a paraméterként kapott adatot! Lista esetén legyenek vesszővel elválasztva az elemek, de szögletes zárójel nélkül!

print(5)
print([1, 2, 3])

5
1, 2, 3

Esetszétválasztás típus szerint:

def kiir(mit):
    if type(mit) is list:   # lista?
        print(*mit, sep=", ")
    else:                   # nem lista
        print(mit)
    
def main():
    kiir(5)
    kiir([1, 2, 3])

print(1, 2, 3)

lista = [1, 2, 3]
print(*lista)

Osztályok

Racionális számok

Tegyük fel, hogy egy olyan programot kell készítenünk, amely racionális számokkal dolgozik. Hogy ezeket pontosan tudjuk tárolni, a lebegőpontos tárolás ötletét elvetjük: mindig külön tároljuk a számlálót és a nevezőt, két egész típusú változóban. Ahogy írjuk a programot, azonban egyre bonyolultabb kifejezéseink lesznek; egyre nehezebb lesz követni, hogy melyik törtes műveletet mely változókon kell elvégezni. Pl. az alábbi művelet:

┌ a   c ┐   ┌ e   g ┐   ad+cb   eh+gf   (ad+cb)(eh+gf)
│ ─ + ─ │ · │ ─ + ─ │ = ───── · ───── = ──────────────
└ b   d ┘   └ f   h ┘     bd     fh         bdfh

Kódban ez így nézne ki:

i = (a*d+c*b)*(e*h+g*f)
j = b*d*f*h

Még ha be is vezetünk valami konvenciót a jelölésre (pl. asz és an az a tört számlálója és nevezője), akkor is elég reménytelennek tűnik a helyzet. Két tört számlálója és nevezője – ez se sokkal jobb:

asz = 2     # a számlálója és nevezője
an = 5
bsz = 4     # b számlálója és nevezője
bn = 9

Mi hiányzik nekünk? Az adat absztrakciója! Az hiányzik, hogy az adattípusokból ugyanúgy tudjunk építkezni, ahogyan az algoritmusoknál a függvényekkel is tettük. Legyen olyan nyelvi elem, amely segítségével több összetartozó adatot egységként kezelhetünk, és néven is nevezhetjük az így kialakult adatcsomagot. Ja, és persze ez a nyelvi elem nem a lista! Egy törtnek nem „nulladik” és „első” eleme van, hanem számlálója és nevezője. Szeretnénk, ha név szerint lehetne ezekre hivatkozni.

Az osztályok fogalma

Az osztályok arra jók, hogy egy új típust hozzunk vele létre. Ez a típus egyedi lesz, saját névvel fog rendelkezni a programban. Az osztályok segítségével összetett dolgokat (pl. racionális számokat) tudunk egyszerűbb, meglévő típusokkal (két egész szám, számláló és nevező) reprezentálni. Másképp megközelítve, egy bizonyos dolog (racionális szám) több tulajdonságát (számlálója, nevezője) tudjuk összefogni, egységként kezelni.

• Összetartozó adatok egységként
• Absztrakt fogalom reprezentációja egyszerűbb típusokkal
• Új típus létrehozása

A törteket egységként kezelve, osztállyal:

class Tort:
    # ... erről lesz szó ma, hogy ide mit írunk

a = Tort(2, 5)
b = Tort(4, 9)
x = a + b
print("a+b =", x)

A fenti kódot tesszük majd működőképessé az óra végére. Látszik, hogy ebben az a és a b változó egy-egy tört, amelyek magukba foglalják a számlálót és a nevezőt is.

A Pythonban lehetséges még az is, hogy a saját típusainkra megadjuk, mit csináljanak az egyes beépített operátorok. Tehát pl. meg tudjuk oldani azt, hogy a törtjeinkre az összeadás elvégezze a közös nevezőre hozást, és a többi szükséges műveletet. Ez nem tartozik szorosan az osztályok témájához, de ha már tudja a nyelv, ezen a példán bemutatjuk ezt is.

Tekintsünk előbb egy egyszerűbb példát: egy pontot a síkon, amelynek helyét az x és y koordinátái határozzák meg.

class Pont:
    pass
    # ide majd írunk mást is

p1 = Pont()
p2 = Pont()
print(p1 is p2)   # False

Az osztály definícióját a class szóval kell bevezetni. A neve lehet bármi, ami még nem foglalt. A definíció belsejébe majd írunk egyéb dolgokat, egyelőre most ez maradjon üres (pass).

Az osztályból létrehozott példányokat objektumnak nevezzük. A példányosítás úgy történik, hogy az osztály nevét függvényként használjuk: Pont(). Ezt konstruktornak is szokták nevezni, mert létrehozott egy új objektumot. Az objektum referenciáját az értékadással eltároljuk egy változóban. Újabb Pont() hívással újabb pontot hozunk létre. A p1 is p2 kifejezés értéke hamis, mert egymástól független objektumokról van szó, kétszer hívtuk a Pont() konstruktort.

A változók és típusok elnevezésénél egyébként érdemes figyelni a következetességre, mert az megkönnyíti a programok írását és megértését. Sok helyen szabályokat is alkotnak erre, amelyeket egy adott cégnél vagy programozói közösségnél szigorúan betartanak. Egyik ilyen elterjedt szokás az, hogy a saját típusok neveit nagybetűvel kezdik, a változókat pedig kicsivel. Ezért lett a pont osztály neve a fenti példákban a nagybetűs Pont, az egyes példányok neve pedig a kisbetűs p1 és p2.

Az attribútumok elérése

p = Pont()

p.x = 3  # az x koordinátája legyen 3
p.y = 6

print(f"p pont: ({p.x};{p.y})")

p pont: (3;6)

Az üresen létrehozott objektum kezdetben semmilyen adatot nem tartalmaz még. De létrehozhatunk benne attribútumokat, más néven mezőket vagy adattagokat (attribute, field, data member). Ezeket a . mezőkiválasztó operátorral (pont operátorral, angolul: dot operator) érjük el. Például p.x jelentése: a p pont x koordinátája. Ennek értéket adhatunk, eltárolva a vízszintes koordinátát. Ugyanígy, a p.y-nak értéket adva eltárolhatjuk a pont függőleges koordinátáját is.

Az így létrehozott adattagok ugyanúgy viselkednek, mint bármelyik másik változó: értéket kaphatnak, kifejezésekben szerepelhetnek, és így tovább. Ha olyan adattagot próbálunk meg kiolvasni, ami még nem létezik (pl. p.abc), akkor AttributeError típusú hibát fogunk kapni.

Értékadás: referenciát másol

p1 = Pont()
p2 = p1
p1.x = 3
print(p2.x) # 3

A Pont típusú objektumot a Pont() konstruktor hozza létre. És mint azt láttuk a múltkori előadáson, az értékadás referenciát állít be. Ez azt jelenti, hogy most egy pontunk van, két referenciával. Ha módosítjuk p1.x-et, akkor p2.x is módosul, mert a kettő egy és ugyanaz.

Függvény paramétere, visszatérési értéke

def origo_tavolsag(p):
    """Megadja a pont origótól mért távolságát."""
    return math.sqrt(p.x ** 2 + p.y ** 2)

def szakaszfelezo(p1, p2):
    """Megadja a szakaszfelező helyét."""
    f = Pont()
    f.x = (p1.x + p2.x) / 2
    f.y = (p1.y + p2.y) / 2
    return f

Objektum lehet függvény paramétere és visszatérési értéke is. A paraméterátadás szabályai ugyanazok, mint amit eddig is láttuk: a függvény a neki átadott objektumok referenciáját kapja meg. Így bár a paraméterként átvett változó nem változtatható meg, a referencián keresztül látott objektum igen: a függvény a pont x és y koordinátáját akár módosítani is tudná.

class Pont:
    def __init__(self, x, y): # konstruktor
        self.x = x
        self.y = y

def szakaszfelezo(p1, p2):
    """Megadja a szakaszfelező helyét."""
    return Pont((p1.x + p2.x) / 2, (p1.y + p2.y) / 2)

def main():
    p1 = Pont(2, 5)
    p2 = Pont(3, 10)
    f = szakaszfelezo(p1, p2)
    print(f"f pont: ({f.x};{f.y})")   # (2.5;7.5)

main()

A Python nyelv dinamikus, az objektumok attribútumait tekintve is. Mint láttuk, bármikor hozzáadhatunk egy attribútumot, ami addig nem létezett, vagy kitörölhetünk egy attribútumot (ilyen a del operátorral lehetséges). De az ilyesmi nagyon-nagyon ritka.

Az viszont gyakran előfordul, hogy egy objektum adattagjainak értéke csak később derül ki, a létrehozása után. Például egy weboldalon a kapcsolatfelvételi űrlap adatait a billentyűzetről olvassuk be. Vagy ha adatbázisban tároljuk a régebben beküldött üzeneteket, akkor az adatbázisból kikereséskor adunk értéket a mezőknek.

Kapcsolat

Név
       ──────────────
E-mail
       ──────────────
Üzenet


       ──────────────

class Uzenet:
    """Űrlap adatai.
    nev: str, a feladó neve
    email: str, a feladó címe
    uzenet: str, üzenet szövege"""
    def __init__(self):
        self.nev = None
        self.email = None
        self.uzenet = None

def main():
    u1 = Uzenet()
    u1.nev = input("Név: ")
    u1.email = input("E-mail: ")
    u1.uzenet = input("Üzenet: ")

Ilyenkor jobb, ha az adattagokat már előre létrehozzuk – akár úgy is, hogy None értéket adunk nekik –, mert a programunk követhetőbb, áttekinthetőbb lesz. Ha belenézünk az osztályba, egyből látjuk, hogy milyen attribútumai vannak, és nem csak a program többi részét átrágva derül ez ki.

Vannak viszont olyan objektumok, ahol egyszerűen értelmetlen, ha nincs értékük. Ilyen a már említett racionális szám, amit mindjárt kidolgozunk részletesen. De ilyen egy egyszerű int objektum is: mindig tárol valamilyen számot.

Adattagok létrehozása a ProgAlap tárgyban

A ProgAlap tárgyban mindig így kérjük: hozzuk létre a konstruktorban az összes adattagot, akkor is, ha azoknak egyelőre még nincs értéke, csak None!

A törtes példa kidolgozása

Racionális számok

Feladat: hozzunk létre típust, amelyik racionális számot tárol. Írjuk meg az ezeket összeadni, szorozni, kiírni tudó függvényeket!

A törtek osztálya

• Ez új típus! Saját értékkészlet és műveletek.
• Összetartozó adatok is. Ezért ez egy osztály lesz!
  
• A műveletek pedig függvények.

class Tort:
    def __init__(self, szaml, nev):
        self.szaml = szaml
        self.nev = nev

def main():
    x = Tort(4, 5)     # 4/5

Mivel az osztályt több függvény is használja, globálisan definiáljuk.

A print() nem ismeri a tört típust:

x = Tort(2, 3)
print("x =", x)

x = <__main__.Tort object at 0x7fbed3f60a20>

Írjunk függvényt, amelyik sztringgé alakítja!

def tort_sztringkent(t):
    """szaml/nev alakú sztringgé alakítja a törtet."""
    return f"{t.szaml}/{t.nev}"


x = Tort(4, 5)
print("x =", tort_sztringkent(x))     # x = 4/5

Itt a tort_sztringkent() függvényben az f sztringet egyszerűen visszaadtuk azt a hívónak.

Szükségünk lehet a tizedestörtre is:

def tort_valoskent(t):
    """Visszatér a tört lebegőpontos értékével."""
    return t.szaml / t.nev


t1 = Tort(4, 5)
print("t1 =", tort_valoskent(t1))
print("sqrt(t1) =", math.sqrt(tort_valoskent(t1)))

t1 = 0.8
sqrt(t1) = 0.8944271909999159

A függvény egy törtből csinál float típusú lebegőpontos számot. Így már odaadhatnánk azt a math.sin() vagy a math.sqrt() függvénynek. Hogy ezt miért nevezzük lebegőpontosnak, arról később lesz szó.

A nevezők szorzata lehet közös nevező. Két törtet összegző függvény:

a   c   ad+cb
─ + ─ = ─────
b   d     bd

def tort_osszeg(t1, t2):
    """Megadja a két tört összegét."""
    return Tort(
        t1.szaml * t2.nev + t2.szaml * t1.nev,
        t1.nev * t2.nev
    )

z = tort_osszeg(x, y)

A szorzat ugyanígy:

a   c   ac
─ · ─ = ──
b   d   bd

def tort_szorzat(t1, t2):
    """Megadja a két tört szorzatát."""
    return Tort(
        t1.szaml * t2.szaml,
        t1.nev * t2.nev
    )

Próbáljuk ki az eddigi függvényeinket!

x = Tort(1, 2)
y = Tort(1, 4)
print("t1 =", tort_sztringkent(tort_osszeg(x, y)))

A program futási eredménye:

6/8

Ez helyes is, és nem is. Helyes, mert 6/8 az 3/4, és az összeg tényleg annyi. De lehetne jobb is, ha a program egyszerűsíteni is tudna.

Az egyszerűsítéshez meg kell határoznunk a számláló és a nevező legnagyobb közös osztóját. És ezt a konstruktorban kell megtennünk:

class Tort:
    def __init__(self, szaml, nev):
        lnko = math.gcd(szaml, nev)
        self.szaml = szaml // lnko
        self.nev = nev // lnko

Nagyon fontos itt a függvény filozófiája. A két egész szám összerakva nem csak egyszerűen két egész szám együtt, hanem egy tört. Speciálisabb, mint egy sima számpár. Ezért amikor egy törtet „építünk”, azaz létrehozunk két egész számból, akkor el kell végeznünk egy egyszerűsítést rajta. Tehát az egyszerűsítésnek a konstruktorban van a helye. Mivel törtet létrehozni csak a konstruktorral tudunk, minden törtünk egyszerűsítve lesz! A számlálónak és a nevezőnek történő „kézi” értékadást pedig kerülni fogjuk – immutábilisnak tekintjük a tört objektumot.

A math.gcd függvény megkeresi két szám legnagyobb közös osztóját. Ezzel osztva a számlálót és a nevezőt megkapjuk az egyszerűsített törtet. Itt most szándékosan a // operátort használtuk a / helyett: a // egész számot ad, az osztás egészrészét. Így a számlálóba és a nevezőbe nem float, hanem int típusú értékek kerülnek. Mivel pont a legnagyobb közös osztóval osztottunk, biztosak lehetünk benne, hogy amúgy is egész számokat kaptunk, mert nincs maradék.

Alakítsunk egy szaml/nev alakú sztringet törtté:

Írd be a törtet:
6/8_

print("Írj be egy törtet:")
t = sztring_tortte(input())

A sztringek split() függvénye a megadott határolónál darabol:

def sztring_tortte(s):
    """szaml/nev alakú sztringből törtet csinál."""
    elemek = s.split("/")
    szaml = int(elemek[0])
    nev = int(elemek[1])
    return Tort(szaml, nev)

Mi történik, ha nem számot kapunk? Ha „1/2/3” van a sztringben? Ha 0 a nevező?

A programban sok hibalehetőségre fel kell készülnünk. Bármikor előfordulhat, hogy egy törtet véletlenül – programozási hiba miatt, hibás bemenet miatt – 0 értékű nevezővel próbálunk meg inicializálni. Vagy épp olyan sztringből akarunk törtet kiolvasni, amiben nem tört van, vagy nem a megfelelő formátumban.

Mi történjen ilyenkor? A helyes megoldás az, ha kivételt dobunk! Lássuk előbb a sztringet törtté alakító függvényt:

def sztring_tortte(s):
    """szaml/nev alakú sztringből törtet csinál."""
    elemek = s.split("/")
    if len(elemek) != 2:
        raise ValueError("Törthöz száml/nev alakú sztring!")
    szaml = int(elemek[0])
    nev = int(elemek[1])
    return Tort(szaml, nev)

Itt feltörjük a sztringet a / karakterek mentén. Pontosan kettő elemű kell legyen a lista, amit kaptunk, mert pontosan egy számlálónak és egy nevezőnek kell benne lennie. Ha ez nem teljesül, kivételt dobunk. Ezek után számmá alakítjuk mindkét sztringdarabot; ha bármelyikben nem szám volt, az int() függvény kivételt dobott. Ha számok voltak, akkor innentől a további teendőket a tört konstruktora elvégzik.

def sztring_tortte(s):
    """szaml/nev alakú sztringből törtet csinál."""
    elemek = s.split("/", 1)
    szaml = int(elemek[0])
    nev = int(elemek[1])
    return Tort(szaml, nev)

A számláló és a nevező ellenőrzését pedig a konstruktorban végezzük el. Először is, a két kapott paraméter, a számláló és a nevező egész számok kell, hogy legyenek. Másodszor pedig, a számláló nem lehet negatív, és a nevező nem lehet 1-nél kisebb (0 sem lehet). Ha az említett problémák közül bármelyik fennállna, akkor a megfelelő típusú kivételt dobjuk.

class Tort:
    def __init__(self, szaml, nev):
        if type(szaml) is not int or type(nev) is not int:
            raise TypeError("Számláló és nevező int legyen")
        if szaml < 0 or nev < 1:
            raise ValueError("Számláló>=0, nevező>0 kell")
        lnko = math.gcd(szaml, nev)
        self.szaml = szaml // lnko
        self.nev = nev // lnko

Itt most feltételeztük, hogy csak nemnegatív törtekkel dolgozunk. (Ez amúgy már eddig is így volt, különben a közös nevezőre hozásnál figyelni kellene erre külön.)

class Tort:
    def __init__(self, p1=None, p2=None):
        if type(p1) is int and type(p2) is int: # int, int
            szaml = p1
            nev = p2
        elif type(p1) is str and p2 is None: # str
            elemek = p1.split("/", 1)
            szaml = int(elemek[0])
            nev = int(elemek[1])
        elif p1 is None and p2 is None: # 0 param
            szaml = 0
            nev = 1
        else:
            raise TypeError("Tört: rossz konstruktorhívás")

        if szaml < 0 or nev < 1:
            raise ValueError("Számláló>=0, nevező>0 kell")

        lnko = math.gcd(szaml, nev)
        self.szaml = szaml // lnko
        self.nev = nev // lnko

Típus ≈ osztály

• Adatok
• Műveletek

Észrevehetjük, hogy a programunk egy objektuma, annak reprezentációja (adatai, tulajdonságai) és műveletei (milyen függvényekkel használható) mindig összetartoznak. Ezt láttuk már a típus definíciójánál, de ez a helyzet az osztályok esetén is. A két fogalom összemosódik, eltérő programozási nyelvek kapcsán néha kicsit mást jelentenek. Gyakran típus néven a beépített típusokra, osztály néven a programozó által definiált típusokra hivatkozunk. De valójában ez is csak mesterséges megkülönböztetés, történelmi okokból.

Példák:

Az OOP elvek miatt a függvényeket és a metódusokat eltérő szintaxissal kell használni:

# Létrehozás: visszatérési érték
szamok = szamsort_beolvas()

# Módosítás: sokszor tagfüggvény, de lehet globális is
szamok.append(123)
szamsort_duplaz(szamok)

# Miért nem szamok.len()? → Leginkább történelmi baleset
print(len(szamok))

A fenti példához definiált függvények:

def szamsort_beolvas():
    lista = []
    # ...
    return lista

def szamsort_duplaz(lista):
    for i in range(len(lista)):
        lista[i] *= 2

Az eddig megírt kódunk jól működik, de elég körülményes használni. A törtek számok, és a számok összeadását, szorzását stb. leginkább a műveleti jelekkel, operátorokkal szeretnénk elvégezni, nem pedig függvényhívásokkal. Ugyanez a helyzet a kiírásnál: a tört kiírásához sztringgé kell azt alakítani. Tehát ha valahogy meg tudnánk mondani, hogy egy Tort típusú adat hogyan alakítható sztringgé (str típusú adattá), és ezt a Python nyelv tudomására is hoznánk, akkor nem kellene a tort_sztringkent() függvénnyel bíbelődnünk, hanem magától rájönne a gép.

Ezt kell írjuk:

print("összeg =", tort_sztringkent(tort_osszeg(a, b)))

Ez jobban tetszene:

print("összeg =", a + b)

Amit itt el szeretnénk érni, az az, hogy a saját típusunkra operátorokat definiálhassunk: azaz megadhassuk, hogy a meglévő operátorok mit csináljanak a saját típusunkra. Ezt angolul operator overload technikának nevezik. Ezt „túlterhelésnek” szokás fordítani magyarul, sajnos nem a legjobb név.

Pythonban ez lehetséges. Egyes szintaktikai elemek jól meghatározott nevű függvényeket hívnak:

Ezek az ún. speciális metódusok (special methods), de az angol szakirodalomban több másik nevük is van (dunder method, magic method). Ahhoz, hogy működjenek, semmi egyéb teendőnk nincsen, mint definiálni kell a megadott nevű függvényeket. Ha írunk a tört osztályban egy __str__() nevű függvényt, akkor az automatikusan meg fog hívódni, amikor str(t)-t (vagy print(t)-t) írunk. Ha definiálunk __add__() függvényt is, akkor az a + b kifejezés hatására – törtek esetén – az a.__add__(b) függvény fog meghívódni.

Tulajdonképpen a konstruktor, tehát az __init__() függvény is ilyen. Annak speciális szintaxisa az osztályneve(paraméterek...) volt. A fenti táblázat szerint azt szeretnénk, hogy Tort(sztring)-et is lehessen írni a Tort(számláló, nevező) mellett; ezt a paraméterek vizsgálatával kell majd megoldanunk.

Vigyázat: a törtes példa különleges, mert a racionális számoknál pont olyan műveleteink vannak, amelyekhez operátor is van a nyelvben: összeadás, kivonás és így tovább. Ha egy másik példával állnánk szemben, mondjuk Könyv osztállyal, Ember osztállyal, Téglalap osztállyal, akkor azokhoz semmiképpen sem definiálnánk operátorokat. Nincs értelme! Nem lehet két könyvet kivonni egymásból, vagy két téglalapot összeszorozni. Ne erőltessük az ilyesmit! A következő témakör csak a racionális szám miatt érdekes.

A speciális függvényeket az osztály belsejében kell definiálnunk:

class Tort:
    def __init__(self, szaml, nev):
        ...
    
    def __str__(self):      # self
        return f"{self.szaml}/{self.nev}"

    def __float__(self):    # self
        return self.szaml / self.nev

def main():
    x = Tort(1, 2)
    print("x =", x)         # str(x)
    print("sqrt(x) =", math.sqrt(x))    # float(x)

Az összes speciális függvény az __init__-hez hasonlóan működik. Az osztály törzsében kell definiálnunk őket. Innen tudja a Python, hogy milyen típusú objektumokon használható, mert amúgy a nevéből nem derül ki. Ezen felül, mindegyiknek az első paramétere az az objektum, jelen esetben a tört, amelyre meghívták. Ezt az összes függvénynél self-nek hívjuk.

A sztringé és lebegőpontos számmá konvertáló függvények maguktól hívódnak. A kiírás esetén maga a print() függvény hívja majd meg az str(valami)-t, ha látja, hogy nem sztring a paraméter típusa. A math.sqrt()-nél is ez a helyzet: ha nem lebegőpontos típusú a paraméter, akkor megpróbálja float(valami) függvényhívással azzá alakítani; mivel a törtnek most már van __float__() függvénye, ez sikerülni is fog.

A kétoperandusú operátorok paraméterezése:

class Tort:
    def __init__(self, szaml, nev):
        ...
    
    def __add__(self, jobb):
        return Tort(
            self.szaml * jobb.nev + jobb.szaml * self.nev,
            self.nev * jobb.nev
        )

    def __mul__(self, jobb):
        return Tort(
            self.szaml * jobb.szaml,
            self.nev * jobb.nev
        )

Kétoperandusú operátorok esetén megjelenik egy újabb paraméter.

Az a + b kifejezés hatására az a.__add__(b) függvényhívás történik meg. Ez pedig azt jelenti, hogy a self mellett lesz egy további paraméter, a b értéke. Vagyis az operátor bal oldalán álló tört lesz az első, a jobb oldalon álló tört a második paraméter: self = a és jobb = b. A példában ezért kapta a második paraméter a jobb nevet. Angol nyelvű kódban ezt rhs-nek szokás elnevezni (right hand side).

Van sok más speciális függvény még. Például __lt__() felel meg a kisebb operátornak (less than), __ge__() a nagyobb vagy egyenlőnek (greater or equal). Az r betűvel jelölt operátorokkal, pl. az __radd__() függvénnyel azokat az eseteket lehet kezelni, amikor az összeadás bal oldalán nem a saját osztályunk van, mondjuk mint a 4 + Tort(5, 6) kifejezésben. Ugyanígy van __rmul__() is. De ezeket most nem soroljuk fel mind; aki szeretne ebben jobban el mélyedni, érdemes a Python dokumentáció vonatkozó fejezetét tanulmányoznia.

(Többszörösen) összetett adatok

Osztályba egy dolog összetartozó adatait tesszük.

• Különálló, új típus, saját műveletekkel
• Pl. egy könyv adatai: cím, szerző, oldalszám

Listába több egyforma dolog adatait tároljuk.

• Ez csak egy tároló azonos szerepű dolgok számára.
• Pl. könyvek katalógusa

class Konyv:
    def __init__(self, szerzo, cim, kiadaseve): # ...
    def __str__(self): # ...

konyvtar = []
konyvtar.append(Konyv("J. K. Rowling",
                      "Harry Potter és a bölcsek köve",
                      1997))
konyvtar.append(Konyv("J. K. Rowling",
                      "Harry Potter és a Titkok Kamrája",
                      1998))
print(konyvtar[0])
print(konyvtar[1].kiadaseve)
print(konyvtar[1].szerzo[0])

J. K. Rowling: Harry Potter és a bölcsek köve [1997]
1998
J

class ProgAlapEredmeny:
    def __init__(self, neptun):
        self.neptun = neptun
        self.labjelenlet = [None]*28
        self.kzh = [None]*7
        self.nzh = None
        self.pzh = None
        self.ppzh = None
        self.nhfpont = None 
        self.pothfpont = None 

def van_e_alairas(eredmeny):
    return # ...

h1 = ProgAlapEredmeny("B4TM4N")
h1.kzh[0] = 9

class Pont:
    def __init__(self, x=0.0, y=0.0):
        self.x = x
        self.y = y

class Kor:
    def __init__(self, k=None, r=0.0):
        if k is None: k = Pont()
        self.k = k
        self.r = r

class Szakasz:
    def __init__(self, p1=None, p2=None):
        if p1 is None: p1 = Pont()
        if p2 is None: p2 = Pont()
        self.p1 = p1
        self.p2 = p2

print(k1.r)       # a kör sugara
sz1.p1.y = 5.19   # a szakasz kezdőpontjának y koordinátája

Az előzőhöz hasonlóan saját osztályokból is építhethetünk. Az x és y koordinátát tároló pont osztály definiálása után felhasználhatjuk azt a szakasz és a kör osztályban. A kör egy pontot tartalmaz (a középpontja), egy szakasz objektumhoz viszont két pontra is szükség van: a kezdőpontra és végpontra. Az értékek kiválasztásánál itt is kívülről befelé haladunk: sz1.p1.y, azaz az sz1 szakasznak a kezdőpontja, annak is az y koordinátája.

A geometriás példában a függvények None paraméterei szándékosak. Mind a körnek, mind a szakasznak a konstruktorban megadhatók az adatai. De ezek alapértelmezett értéke None lett, és ha ezen keresztül azt látják a függvények, hogy nem kaptak adatot, akkor új Pont objektumot hoznak létre. Erre azért van szükség, mert bár írhatnánk ilyet:

class Kor:
    def __init__(self, k=Pont(), r=0.0):
        self.k = k
        self.r = r

Ez valójában kicsit mást jelentene. Ugyanis a függvényparaméterek alapértelmezett értékei csak egyetlen egyszer jönnek létre, a program indulásakor, és így ugyanaz a pont objektum lenne mindegyik kör középpontja. Viszont a Pont objektumok változtathatóak (ahogy fent is változott a szakasz kezdőpontjának egyik koordinátája), és így váratlan hatással lenne a pont módosítása a többi körben.

Ha a függvény hozza létre, akkor viszont minden egyes függvényhíváskor új pont fog létrejönni:

class Kor:
    def __init__(self, k=None, r=0.0):
        if k is None: k = Pont()
        self.k = k
        self.r = r

Ha a pont nem lenne mutábilis (vagy nem annak kezelnénk), akkor persze meg lehetne osztani az egyforma pont objektumokat a körök között.