0 dní v řadě · 0 bodů

Objekty · 20 min

property a zapouzdření

Atribut, který hlídá své hodnoty a umí se dopočítat, aniž by se změnil kód, který ho používá. Plus co v Pythonu znamenají podtržítka.

Hloubka
Úkoly
Lidsky řečeno

Na termostatu otočíš kolečkem a máš pocit, že přímo nastavuješ teplotu. Uvnitř ale elektronika kontroluje, jestli po ní nechceš 90 stupňů, a kdyžtak tě nepustí dál. Tobě zůstává jednoduché kolečko, hlídání se děje za ním. property je takové kolečko pro atributy objektu.

Atribut, který může rozbít kdokoli

Do e-shopu sis napsal jednoduchou třídu. Atribut cena může přepsat kdokoli a na cokoli.

class Produkt:
    def __init__(self, nazev, cena):
        self.nazev = nazev
        self.cena = cena

hrnek = Produkt("Hrnek", 190)
hrnek.cena = -50

print(hrnek.cena * 3)
Výstup
-150

Python neprotestuje a chybu objeví až účetní na faktuře se zápornou částkou. Tomu, co musí o objektu platit pořád, se říká invariant. Tady je to „cena není záporná“. Ochraně invariantů a schování vnitřností za jasné rozhraní se říká zapouzdření.

V některých jazycích bys hned napsal metody get_cena() a set_cena(). Fungovalo by to, ale všechna místa v programu, kde už stojí hrnek.cena, bys musel přepsat. Python má lepší cestu.

property: atribut s hlídačem

Dekorátor je řádek se zavináčem nad def, který funkci nějak upraví. Podrobně je rozebírá lekce Dekorátory, teď ti stačí vědět, co dělají tyhle dva:

  • @property říká: když někdo čte cena, spusť tuhle metodu.
  • @cena.setter říká: když někdo do cena zapisuje, spusť tuhle metodu.
class Produkt:
    def __init__(self, nazev, cena):
        self.nazev = nazev
        self.cena = cena

    @property
    def cena(self):
        return self._cena

    @cena.setter
    def cena(self, hodnota):
        if hodnota < 0:
            raise ValueError("Cena nemůže být záporná.")
        self._cena = hodnota

hrnek = Produkt("Hrnek", 190)
print(hrnek.cena)

hrnek.cena = 250
print(hrnek.cena)

hrnek.cena = -50
print("sem se program nedostane")
Výstup
190
250

Tři věci stojí za povšimnutí:

  • Kód, který třídu používá, se vůbec nezměnil. Pořád je to hrnek.cena bez závorek.
  • Skutečná hodnota leží v atributu _cena. Jméno cena už patří property.
  • Řádek self.cena = cena v __init__ jde taky přes setter, takže ani nový objekt nevznikne se špatnou cenou.

Z toho plyne praktické pravidlo: začni obyčejným atributem. Property přidej, až ji budeš potřebovat. Předem psané gettery a settery jsou v Pythonu zbytečná práce.

Úkol

Hlasitost

Třída Reproduktor má property hlasitost. Povolené jsou hodnoty od 0 do 100 včetně, cokoli jiného vyhodí ValueError. Ověření musí platit i pro hodnotu předanou konstruktoru, výchozí hlasitost je 50.

class Reproduktor:
    def __init__(self, hlasitost=50):
        self.hlasitost = hlasitost

    # doplň property hlasitost a její setter
Výstup

Spočítané hodnoty a atributy jen pro čtení

Property bez setteru jde jen číst. Hodí se na údaje, které se dají odvodit z jiných. Neukládáš je, takže nemůžou zastarat.

class Obdelnik:
    def __init__(self, sirka, vyska):
        self.sirka = sirka
        self.vyska = vyska

    @property
    def obsah(self):
        return self.sirka * self.vyska

dlazba = Obdelnik(4, 3)
print(dlazba.obsah)

dlazba.sirka = 10
print(dlazba.obsah)

try:
    dlazba.obsah = 99
except AttributeError as e:
    print("Chyba:", e)
Výstup
12
30
Chyba: property 'obsah' of 'Obdelnik' object has no setter

Setter může spočítanou hodnotu i převádět zpátky. Stejný údaj pak jde číst a zapisovat ve dvou podobách, ale uložený je jen jednou.

class Vzdalenost:
    def __init__(self, metry):
        self.metry = metry

    @property
    def kilometry(self):
        return self.metry / 1000

    @kilometry.setter
    def kilometry(self, hodnota):
        self.metry = hodnota * 1000

trasa = Vzdalenost(2500)
print(trasa.kilometry)

trasa.kilometry = 8
print(trasa.metry)
Výstup
2.5
8000
Úkol

Teploměr ve dvou stupnicích

Třída Teplomer ukládá teplotu jen ve stupních Celsia. Property celsius odmítne hodnotu pod absolutní nulou (-273.15) výjimkou ValueError. Property fahrenheit jde číst i zapisovat, převod je níže. Zápis do fahrenheit musí projít stejnou kontrolou.

class Teplomer:
    def __init__(self, celsius):
        self.celsius = celsius

    # doplň property celsius a fahrenheit
Výstup
Kvíz

Třída má @property def obsah(self) a žádný setter. Co udělá o.obsah = 5?

Co znamenají podtržítka

Python nemá klíčové slovo private. Nic ti doopravdy nezabrání sáhnout objektu dovnitř. Platí domluva vyjádřená jménem:

ZápisVýznam
cenaveřejné, na tomhle můžou ostatní stavět
_cenainterní, zvenku nesahej, může se to kdykoli změnit
__cenaPython jméno uvnitř třídy přejmenuje na _Trida__cena
__cena__speciální jméno Pythonu, vlastní nevymýšlej
class Trezor:
    def __init__(self):
        self._poznamka = "interní"
        self.__kod = 1234

t = Trezor()
print(t._poznamka)
print(hasattr(t, "__kod"))
print(t._Trezor__kod)
print(sorted(vars(t)))
Výstup
interní
False
1234
['_Trezor__kod', '_poznamka']

Dvě podtržítka tedy nejsou zámek. Kód přečteš, když víš, jak se jmenuje. Jejich skutečný účel je jiný: aby si podtřída omylem nepřepsala stejně pojmenovaný atribut rodiče. V běžném kódu stačí jedno podtržítko.

Zapouzdření je víc než gettery

Property na každý atribut není zapouzdření. Podstata je jinde: objekt nabízí operace, které dávají smysl, a sám hlídá, aby po nich zůstal v pořádku. U účtu nechceš, aby někdo přepisoval zůstatek. Chceš vklad a výběr.

class Ucet:
    def __init__(self):
        self._pohyby = []

    @property
    def zustatek(self):
        return sum(self._pohyby)

    @property
    def pohyby(self):
        return tuple(self._pohyby)

    def vloz(self, castka):
        if castka <= 0:
            raise ValueError("Vklad musí být kladný.")
        self._pohyby.append(castka)

    def vyber(self, castka):
        if castka <= 0:
            raise ValueError("Výběr musí být kladný.")
        if castka > self.zustatek:
            raise ValueError("Na účtu není dost peněz.")
        self._pohyby.append(-castka)

ucet = Ucet()
ucet.vloz(1000)
ucet.vyber(300)
print(ucet.zustatek)
print(ucet.pohyby)
Výstup
700
(1000, -300)

Všimni si tuple(...) u pohyby. Kdyby property vracela přímo vnitřní seznam, kdokoli by mohl zavolat ucet.pohyby.append(1_000_000) a celá ochrana by byla k ničemu. Property brání jen přiřazení do atributu, ne změně objektu, který vrátí.

class Spatne:
    def __init__(self):
        self._pohyby = [100]

    @property
    def pohyby(self):
        return self._pohyby

u = Spatne()
u.pohyby.append(1_000_000)
print(u.pohyby)
Výstup
[100, 1000000]

Kdy property nepoužít. Kdo čte objekt.x, čeká rychlou a neškodnou operaci. Dotaz do databáze, stahování z internetu nebo změna stavu patří do metody se závorkami, ať je cena vidět už v kódu.

Když je výpočet drahý, ale výsledek se nemění, pomůže functools.cached_property. Spočítá hodnotu poprvé a pak ji jen vrací. Pozor na to, že o změně vstupů neví nic.

from functools import cached_property

class Report:
    def __init__(self, cisla):
        self.cisla = cisla

    @cached_property
    def soucet(self):
        print("počítám...")
        return sum(self.cisla)

r = Report([1, 2, 3])
print(r.soucet)
print(r.soucet)

r.cisla.append(4)
print(r.soucet)

del r.soucet
print(r.soucet)
Výstup
počítám...
6
6
6
počítám...
10
Úkol

Pokladna

Napiš třídu Pokladna.

  • prijmi(castka) přidá tržbu. Kladná čísla jsou v pořádku, jinak ValueError.
  • vrat(castka) vrátí peníze zákazníkovi. Částka musí být kladná a nesmí překročit stav, jinak ValueError.
  • Property stav je jen pro čtení a vrací aktuální částku.
  • Property historie je jen pro čtení a vrací n-tici všech změn, příjmy kladně a vrácení záporně.
class Pokladna:
    def __init__(self):
        self._zmeny = []

    # doplň
Výstup
Kvíz

Co přesně chrání property pohyby, která vrací self._pohyby jako seznam?

Pod kapotou · property je datový deskriptor

property je obyčejná třída implementující deskriptorový protokol (__get__, __set__, __delete__). Instance leží v __dict__ třídy. Při čtení atributu má datový deskriptor na typu přednost před slovníkem instance, ten má přednost před nedatovým deskriptorem a atributem třídy. Proto ani ručně podstrčená hodnota property nepřebije.

class A:
    @property
    def x(self):
        return "z property"

a = A()
a.__dict__["x"] = "ze slovníku instance"
print(a.x)
print(a.__dict__)
print(type(A.__dict__["x"]).__name__)
print(A.x.fget(a))
print(A.x.fset)
Výstup
z property
{'x': 'ze slovníku instance'}
property
z property
None

@x.setter nemění existující property, vrací její kopii s doplněným fset. Proto se metoda musí jmenovat stejně. Jiné jméno je klasická chyba: x zůstane jen pro čtení a funkční property skončí pod tím druhým jménem. Stejný mechanismus umožňuje v podtřídě přepsat jen část:

class Zaklad:
    @property
    def cena(self):
        return self._cena

    @cena.setter
    def cena(self, hodnota):
        self._cena = hodnota

class Akce(Zaklad):
    @Zaklad.cena.setter
    def cena(self, hodnota):
        Zaklad.cena.fset(self, hodnota * 0.9)

a = Akce()
a.cena = 100
print(a.cena)
Výstup
90.0

Adaptivní interpret ve verzi 3.12 umí čtení property specializovat (LOAD_ATTR_PROPERTY), takže jednoduchý getter není drahý, ale pořád jde o volání funkce napsané v Pythonu. Mechanismus do detailu vysvětluje lekce Deskriptory a metatřídy.

Pod kapotou · AttributeError, který zmizí

Když getter vyhodí AttributeError a třída má __getattr__, Python to pochopí jako „atribut nebyl nalezen“ a zavolá __getattr__ se jménem property. Původní chyba se ztratí a hláška ukazuje jinam. Tohle se v produkci ladí dlouho, typicky u wrapperů kolem konfigurace nebo ORM.

class Konfigurace:
    def __init__(self):
        self.data = {"port": 8080}

    @property
    def port(self):
        return self.dta["port"]

    def __getattr__(self, jmeno):
        raise AttributeError(f"neznámé nastavení: {jmeno}")

try:
    Konfigurace().port
except AttributeError as e:
    print(e)
Výstup
neznámé nastavení: port

Překlep je v self.dta, ale chyba tvrdí, že neexistuje port, který přitom definovaný je. Obrana: v getteru převeď očekávané AttributeError na jinou výjimku a __getattr__ piš co nejužší.

Pod kapotou · cached_property a name mangling

cached_property je nedatový deskriptor (nemá __set__). První čtení spustí funkci a výsledek zapíše do instance.__dict__ pod stejným jménem. Další čtení deskriptor vůbec nepotká, proto je stejně rychlé jako běžný atribut a proto del funguje jako invalidace. Důsledky:

  • Vyžaduje __dict__, takže nefunguje na třídě s __slots__ bez něj.
  • Dokumentace upozorňuje, že narušuje sdílení klíčů slovníků instancí (PEP 412), takže instance můžou zabrat víc paměti.
  • Do verze 3.11 obsahovala zámek sdílený všemi instancemi, který brzdil vlákna. Ve 3.12 je pryč, takže při souběhu se hodnota může spočítat víckrát. Je-li to problém, přidej vlastní zámek.

Name mangling provádí překladač pro každý identifikátor __x v těle třídy, který nekončí dvěma podtržítky, a to i v zápisu other.__x. Do řetězců nesahá: getattr(self, "__x") nic nenajde. Při ladění a serializaci je tohle častý zdroj překvapení.