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)
-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 čtecena, spusť tuhle metodu.@cena.setterříká: když někdo docenazapisuje, 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")
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.cenabez závorek. - Skutečná hodnota leží v atributu
_cena. Jménocenauž patří property. - Řádek
self.cena = cenav__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.
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
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)
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)
2.5 8000
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
Třída má @property def obsah(self) a žádný setter. Co udělá o.obsah = 5?
Bez setteru je property jen pro čtení a zápis skončí výjimkou.
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ápis | Význam |
|---|---|
cena | veřejné, na tomhle můžou ostatní stavět |
_cena | interní, zvenku nesahej, může se to kdykoli změnit |
__cena | Python 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)))
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)
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)
[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)
počítám... 6 6 6 počítám... 10
Pokladna
Napiš třídu Pokladna.
prijmi(castka)přidá tržbu. Kladná čísla jsou v pořádku, jinakValueError.vrat(castka)vrátí peníze zákazníkovi. Částka musí být kladná a nesmí překročit stav, jinakValueError.- Property
stavje jen pro čtení a vrací aktuální částku. - Property
historieje 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ň
Co přesně chrání property pohyby, která vrací self._pohyby jako seznam?
Volající dostane odkaz na tentýž seznam a může do něj přidávat. Proto se vrací kopie nebo n-tice.
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)
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)
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)
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í.