Osztályok (OOP).

Eddig az adatokat és a velük dolgozó függvényeket külön kezeltük: egy diák nevét, jegyeit külön változókban vagy egy szótárban, az átlagszámítást egy külön függvényben. Az objektumorientált programozás (OOP) összefogja őket: egy egységbe kerül az adat és az, amit vele csinálni lehet.

Valójában eddig is objektumokkal dolgoztál: az "alma" a str osztály egy példánya, ezért van upper() metódusa; a [3, 1, 2] a list osztályé, ezért van append()-je. Most saját osztályt írunk.

szo = "alma"
lista = [3, 1, 2]
print(type(szo), szo.upper())
print(type(lista))
lista.append(4)
print(lista)

class Kutya:
    def __init__(self, nev, kor):
        self.nev = nev
        self.kor = kor

    def bemutatkozik(self):
        return f"{self.nev} vagyok, {self.kor} éves."


bodri = Kutya("Bodri", 3)
morzsa = Kutya("Morzsa", 7)
print(bodri.nev)
print(morzsa.bemutatkozik())
bodri.kor = bodri.kor + 1
print(bodri.bemutatkozik())

• class Kutya:osztálydefiníció; a név PascalCase
• __init__a konstruktor (pontosabban inicializáló): a példány létrehozásakor fut le, és beállítja az adatait
• selfaz éppen kezelt objektum – mindig az első paraméter
• self.nev = nevattribútum létrehozása a példányban
• Kutya("Bodri", 3)példányosítás: új objektum

Kövesd Lépésenként. A Kutya("Bodri", 3) hívásakor a Python létrehoz egy üres objektumot, majd meghívja rá az __init__-et: a self ez az új objektum, a nev és a kor a kapott argumentumok. A self.nev = nev sor az objektumba „írja” az adatot. A Memóriában két külön Kutya objektum doboz jelenik meg, saját attribútumokkal, és a bodri meg a morzsa név nyíllal mutat rájuk.

Az objektum attribútumainak pillanatnyi értéke az objektum állapota. A metódusok olvassák és módosítják ezt az állapotot – és vigyáznak rá, hogy érvényes maradjon. Egy bankszámla egyenlege például ne lehessen negatív, és negatív összeget se lehessen befizetni:

class BankSzamla:
    def __init__(self, tulajdonos, egyenleg=0):
        self.tulajdonos = tulajdonos
        self.egyenleg = egyenleg

    def befizet(self, osszeg):
        if osszeg <= 0:
            return False
        self.egyenleg += osszeg
        return True

    def kivesz(self, osszeg):
        if osszeg <= 0 or osszeg > self.egyenleg:
            return False
        self.egyenleg -= osszeg
        return True

    def atutal(self, cel, osszeg):
        if self.kivesz(osszeg):
            cel.befizet(osszeg)
            return True
        return False


anna = BankSzamla("Anna", 10000)
bela = BankSzamla("Béla")
print(anna.kivesz(25000))
print(anna.atutal(bela, 3000))
print(anna.befizet(-500))
print(anna.tulajdonos, anna.egyenleg, "|", bela.tulajdonos, bela.egyenleg)

Az atutal metódus egy másik számlaobjektumot kap paraméterként, és annak a metódusát hívja. A lépésenkénti nézetben a self és a cel két különböző objektumra mutat.

class Szamlalo:
    def __init__(self):
        self.ertek = 0

    def novel(self):
        self.ertek += 1

a = Szamlalo()
b = a
c = Szamlalo()
a.novel()
b.novel()
c.novel()
print(a.ertek, b.ertek, c.ertek)

Ha egy saját objektumot kiírunk, alapból valami ilyesmit kapunk: <__main__.Konyv object at 0x7f…>. A speciális metódusokkal (dupla aláhúzásos, angolul „dunder” nevekkel) megmondhatjuk, hogyan viselkedjen az objektumunk a Python beépített műveleteiben:

class Konyv:
    def __init__(self, cim, szerzo, oldal):
        self.cim = cim
        self.szerzo = szerzo
        self.oldal = oldal

    def __str__(self):
        return f"{self.szerzo}: {self.cim} ({self.oldal} oldal)"

    def __repr__(self):
        return f"Konyv({self.cim!r}, {self.szerzo!r}, {self.oldal})"

    def __lt__(self, masik):
        return self.oldal < masik.oldal


polc = [
    Konyv("Egri csillagok", "Gárdonyi Géza", 560),
    Konyv("Pál utcai fiúk", "Molnár Ferenc", 240),
    Konyv("Légy jó mindhalálig", "Móricz Zsigmond", 330),
]
print(polc[0])
print(polc)
for k in sorted(polc):
    print(k)
print("A legrövidebb:", min(polc))

A !r az f-stringben a repr() alakot kéri – így a szövegek idézőjelben jelennek meg, ahogy a kódban írnánk őket.

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

    def __add__(self, masik):
        return Vektor(self.x + masik.x, self.y + masik.y)

    def __eq__(self, masik):
        return self.x == masik.x and self.y == masik.y

    def __str__(self):
        return f"({self.x}, {self.y})"


a = Vektor(1, 2)
b = Vektor(3, 4)
c = a + b
print(c)
print(c == Vektor(4, 6), a == b)

A self.valami attribútumok a példányhoz tartoznak: minden objektumnak saját van belőlük. Az osztály törzsében (a metódusokon kívül) létrehozott változó viszont az osztályhoz tartozik, és minden példány közösen látja. Jó például állandókhoz és az összes példányra vonatkozó adatokhoz (hány objektum készült).

class Termek:
    AFA = 0.27
    darab = 0

    def __init__(self, nev, netto):
        self.nev = nev
        self.netto = netto
        Termek.darab += 1

    def brutto(self):
        return round(self.netto * (1 + Termek.AFA))


t1 = Termek("füzet", 400)
t2 = Termek("toll", 250)
print(t1.brutto(), t2.brutto())
print("Létrehozott termékek:", Termek.darab)
print(t1.AFA)

class Gomb:
    kattintas = 0

    def katt(self):
        self.kattintas += 1

a = Gomb()
b = Gomb()
a.katt()
a.katt()
b.katt()
print(a.kattintas, b.kattintas, Gomb.kattintas)

Mi akadályozza meg, hogy valaki egy téglalap oldalát negatívra állítsa (t.a = -5)? A @property dekorátorral egy attribútum olvasását és írását metódusok mögé rejthetjük: kívülről továbbra is t.a-nak látszik, de az értékadáskor lefut az ellenőrzés. Így számított attribútumot is készíthetünk (pl. a terület), amelyet mindig az aktuális oldalakból számolunk.

class Teglalap:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    @property
    def a(self):
        return self._a

    @a.setter
    def a(self, ertek):
        if ertek <= 0:
            raise ValueError("Az oldal hossza pozitív szám legyen!")
        self._a = ertek

    @property
    def b(self):
        return self._b

    @b.setter
    def b(self, ertek):
        if ertek <= 0:
            raise ValueError("Az oldal hossza pozitív szám legyen!")
        self._b = ertek

    @property
    def terulet(self):
        return self.a * self.b


t = Teglalap(3, 4)
print(t.terulet)
t.a = 10
print(t.terulet)
t.b = 0

Figyeld meg: a konstruktor is a self.a = a formát használja, így már a létrehozáskor lefut az ellenőrzés (ha közvetlenül a „belső” _a-ba írna, megkerülné azt). A _a előtti aláhúzás megállapodás: „belső használatra, kívülről ne nyúlj hozzá”. A hibaüzenet pedig azt mondja, ami a szabály: pozitív legyen – a nulla sem megengedett.

Az öröklődéssel egy meglévő osztályból (szülő, ősosztály) újat készítünk (gyerek, leszármazott). A gyerek mindent megkap, amit a szülő tud, ehhez hozzáadhat új attribútumokat és metódusokat, és felülírhatja (override) a szülő metódusait. A szülő metódusát a super()-rel érjük el – leggyakrabban a konstruktorban.

class Allat:
    def __init__(self, nev):
        self.nev = nev

    def hang(self):
        return "…"

    def bemutatkozik(self):
        return f"{self.nev} vagyok, és ezt mondom: {self.hang()}"


class Kutya(Allat):
    def hang(self):
        return "Vau!"


class Madar(Allat):
    def __init__(self, nev, szarnyfesztav):
        super().__init__(nev)
        self.szarnyfesztav = szarnyfesztav

    def hang(self):
        return "Csip-csirip!"

    def repul(self):
        return f"{self.nev} repül ({self.szarnyfesztav} cm-es szárnyakkal)."


allatok = [Kutya("Bodri"), Madar("Csőrike", 25), Allat("Valaki")]
for a in allatok:
    print(a.bemutatkozik())
print(allatok[1].repul())
print(isinstance(allatok[0], Kutya), isinstance(allatok[0], Allat))

Figyeld meg: a bemutatkozik() metódust csak az Allat-ban írtuk meg, mégis minden állat a saját hangját mondja, mert a self.hang() mindig az objektum tényleges osztályának metódusát hívja. Ezt nevezzük többalakúságnak (polimorfizmus): ugyanaz a hívás a különböző típusú objektumoknál különbözőképpen viselkedik. A Madar konstruktora a super().__init__(nev) hívással a szülőre bízza a név beállítását, és csak a saját új attribútumáról gondoskodik.