0 dní v řadě · 0 bodů

Objekty · 24 min

Metody, atributy třídy, classmethod a staticmethod

Co patří objektu a co celé třídě. Sdílené hodnoty a jejich pasti, náhradní konstruktory přes classmethod a kdy se hodí staticmethod.

Hloubka
Úkoly
Lidsky řečeno

V bytovém domě má každý byt vlastní nábytek. Domovní řád ale visí na chodbě a platí pro všechny. Když si nájemník doma pověsí vlastní verzi, platí jen u něj a ta na chodbě se nezmění. Nábytek jsou atributy instance, řád na chodbě je atribut třídy.

Společná hodnota: atribut třídy

E-shop prodává zboží se stejnou sazbou DPH. Ukládat ji do každého výrobku zvlášť by bylo zbytečné a při změně bys musel projít všechny. Proměnná zapsaná přímo v těle třídy, mimo metody, patří celé třídě.

class Produkt:
    sazba_dph = 21  # one value for the whole class

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

    def cena_s_dph(self):
        return self.cena * (100 + self.sazba_dph) / 100

hrnek = Produkt("Hrnek", 100)
konvice = Produkt("Konvice", 400)

print(hrnek.cena_s_dph(), konvice.cena_s_dph())
print(Produkt.sazba_dph, hrnek.sazba_dph)
print(vars(hrnek))

Produkt.sazba_dph = 25
print(hrnek.cena_s_dph(), konvice.cena_s_dph())
Výstup
121.0 484.0
21 21
{'nazev': 'Hrnek', 'cena': 100}
125.0 500.0

vars(hrnek) ukazuje, že hrnek žádnou sazbu nemá. Přesto hrnek.sazba_dph funguje, protože Python hledá v tomhle pořadí:

text
hrnek.sazba_dph
  1. má ten atribut přímo objekt hrnek?   ne
  2. má ho jeho třída Produkt?            ano, 21

Tím se vysvětluje i to, proč jde metoda volat přes objekt: metody jsou taky uložené ve třídě.

Čtení tedy dojde až ke třídě. Zápis přes objekt ale ke třídě nikdy nedojde. Vytvoří nový atribut přímo na objektu a ten třídní zastíní.

class Produkt:
    sazba_dph = 21

    def __init__(self, nazev):
        self.nazev = nazev

mouka = Produkt("Mouka")
hrnek = Produkt("Hrnek")

mouka.sazba_dph = 12      # only flour gets its own value
Produkt.sazba_dph = 25

print(mouka.sazba_dph, hrnek.sazba_dph, Produkt.sazba_dph)

del mouka.sazba_dph       # the class value shows through again
print(mouka.sazba_dph)
Výstup
12 25 25
25

Někdy je to přesně to, co chceš: třída nese rozumnou výchozí hodnotu a výjimečný objekt si ji přepíše. Často je to ale nechtěná chyba.

Úkol

Číslované vstupenky

Třída Vstupenka počítá vydané kusy v atributu třídy vydano. Doplň __init__ tak, aby každá nová vstupenka zvýšila vydano o 1 a do svého atributu cislo si uložila své pořadí. První vstupenka má číslo 1, druhá 2 a tak dál.

class Vstupenka:
    vydano = 0

    def __init__(self, jmeno):
        self.jmeno = jmeno
        # doplň
Výstup
Kvíz

Třída má barva = "bílá". Spustíš a.barva = "černá". Co vrátí b.barva u jiné instance?

Metody, které spolupracují

Běžná metoda dostává self, takže vidí data objektu i ostatní metody. Dobře napsaná třída má malé metody, které se navzájem používají.

class Objednavka:
    def __init__(self):
        self.radky = []

    def pridej(self, nazev, cena, kusy=1):
        self.radky.append((nazev, cena, kusy))
        return self

    def celkem(self):
        return sum(cena * kusy for _, cena, kusy in self.radky)

    def souhrn(self):
        return f"{len(self.radky)} položky za {self.celkem()} Kč"

objednavka = Objednavka().pridej("Káva", 59, 2).pridej("Dort", 95)
print(objednavka.souhrn())
Výstup
2 položky za 213 Kč

Protože pridej vrací self, dají se volání řetězit za sebou. Je to pohodlné, ale standardní knihovna se tomu u metod měnících objekt spíš vyhýbá: seznam.sort() vrací None, aby nikdo nečekal, že dostane nový seznam. Rozhodni se podle toho, co je v tvém kódu srozumitelnější, a drž se toho.

classmethod: další způsob, jak vyrobit objekt

Výrobky chodí z dodavatelova souboru jako text Hrnek;250. __init__ je ale jen jeden a rozebírání textu do něj nepatří. Pomůže metoda, která nepracuje s konkrétním výrobkem, ale s celou třídou. Označíš ji @classmethod a místo self dostane cls, tedy samotnou třídu.

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

    @classmethod
    def z_radku(cls, radek):
        nazev, cena = radek.split(";")
        return cls(nazev.strip(), int(cena))

    @classmethod
    def darek(cls, nazev):
        return cls(nazev, 0)

class Zbozi(Produkt):
    pass

hrnek = Produkt.z_radku("Hrnek; 250")
print(hrnek.nazev, hrnek.cena)
print(Produkt.darek("Samolepka").cena)

print(type(hrnek).__name__)
print(type(Zbozi.z_radku("Konvice;400")).__name__)
Výstup
Hrnek 250
0
Produkt
Zbozi

Řádek @classmethod je dekorátor, který změní chování funkce pod ním. Jak dekorátory fungují, vysvětlí lekce Dekorátory. cls(...) je totéž jako Produkt(...), jen je to pružnější. class Zbozi(Produkt) znamená, že Zbozi přebírá všechno z Produkt, podrobně v další lekci. Díky cls vrací Zbozi.z_radku opravdu Zbozi. Kdybys napsal natvrdo Produkt(...), dostal bys špatný typ.

Takovým metodám se říká náhradní konstruktory a znáš je i ze standardní knihovny.

from datetime import date

print(dict.fromkeys(["a", "b"], 0))
print(date.fromisoformat("2026-11-18").month)
print(int.from_bytes(b"\x01\x00", "big"))
Výstup
{'a': 0, 'b': 0}
11
256

staticmethod: funkce bydlící ve třídě

Někdy funkce s třídou věcně souvisí, ale nepotřebuje ani objekt, ani třídu. @staticmethod nepřidá žádný automatický první argument.

class Produkt:
    def __init__(self, kod, cena):
        if not self.je_platny_kod(kod):
            raise ValueError(f"Neplatný kód: {kod}")
        self.kod = kod
        self.cena = cena

    @staticmethod
    def je_platny_kod(kod):
        return len(kod) == 6 and kod[:2].isalpha() and kod[2:].isdigit()

print(Produkt.je_platny_kod("AB1234"))
print(Produkt.je_platny_kod("1234AB"))
print(Produkt("XY0001", 90).kod)
Výstup
True
False
XY0001

V Pythonu, kde funkce nemusí být ve třídě, je to nejméně potřebný ze tří druhů. Obyčejná funkce v modulu bývá stejně dobrá a často lepší. Statická metoda dává smysl, když má být pomůcka vidět přímo u třídy nebo ji má jít v potomkovi nahradit.

Jak si vybrat:

text
Potřebuje data konkrétního objektu?       běžná metoda      def m(self)
Potřebuje třídu, třeba aby vyrobila
objekt nebo četla její nastavení?         @classmethod      def m(cls)
Nepotřebuje ani jedno, ale patří sem?     @staticmethod     def m()
Nepotřebuje ani jedno a nepatří sem?      funkce v modulu
Úkol

Teplota ze dvou stupnic

Doplň do třídy Teplota statickou metodu f_na_c(f), která převede Fahrenheity na Celsia podle vzorce (f - 32) * 5 / 9, a třídní metodu z_fahrenheita(f), která vrátí novou instanci. Použij cls, aby fungovala i pro potomky.

class Teplota:
    def __init__(self, stupne):
        self.stupne = stupne

    # doplň obě metody
Výstup
Kvíz

Co dostane jako první argument metoda označená @classmethod, když ji zavoláš přes instanci, tedy objekt.metoda()?

Kvíz

Máš funkci, která jen převádí koruny na haléře a s žádnou třídou nesouvisí. Kam patří?

Pod kapotou · deskriptory, rozsah těla třídy a sdílený stav

Všechny tři druhy metod stojí na deskriptorovém protokolu. Ve vars(Trida) leží různé objekty a jejich __get__ rozhoduje, co dostaneš při čtení přes tečku. Funkce se váže k instanci, classmethod ke třídě a staticmethod vrací původní funkci.

class Ukazka:
    def bezna(self):
        return self

    @classmethod
    def tridni(cls):
        return cls

    @staticmethod
    def staticka():
        return "nic"

for jmeno in ("bezna", "tridni", "staticka"):
    ulozeno = type(vars(Ukazka)[jmeno]).__name__
    pres_tridu = type(getattr(Ukazka, jmeno)).__name__
    pres_objekt = type(getattr(Ukazka(), jmeno)).__name__
    print(f"{jmeno:9} {ulozeno:13} {pres_tridu:9} {pres_objekt}")

class Rozsah:
    zaklad = 2
    prvni = [i for i in range(zaklad)]  # outermost iterable sees the class scope
    try:
        druhy = [zaklad * i for i in range(3)]
    except NameError:
        druhy = "NameError"

print(Rozsah.prvni, Rozsah.druhy)
Výstup
bezna     function      function  method
tridni    classmethod   method    method
staticka  staticmethod  function  function
[0, 1] NameError

Přesné pořadí vyhledávání je: datový deskriptor na typu (třeba property), potom __dict__ instance, potom nedatový deskriptor nebo prostý atribut typu. Proto jde metodu na instanci zastínit, ale property ne. Podrobnosti rozebírá lekce Deskriptory a metatřídy.

Tělo třídy se provede jednou při definici, typicky při importu. Volání jako nacteno = nacti_konfiguraci() v těle tedy poběží při importu modulu, což zpomaluje start a komplikuje testy. Comprehension v těle třídy nevidí jména třídy, s výjimkou nejvnějšího iterovatelného výrazu. Platí to i po PEP 709, který v 3.12 vkládá comprehensions přímo do volajícího kódu: viditelnost jmen zůstala stejná.

Typy. Náhradní konstruktor anotuj def z_radku(cls, radek: str) -> Self (typing.Self, PEP 673, od 3.11). Sdílené hodnoty označ ClassVar[int]. V dataclass je to zásadní, protože bez ClassVar se anotovaný atribut stane polem instance. Řetězení @classmethod s @property bylo od 3.11 zastaralé a v 3.13 zmizelo.

Sdílený stav v produkci. Trida.pocet += 1 není atomické, je to čtení, sečtení a zápis, takže mezi vlákny potřebuje zámek. Počítadla a registry na třídě jsou globální stav: přežívají mezi testy a dělají výsledek závislý na pořadí. Změna atributu třídy za běhu navíc zneplatní interní cache vyhledávání typu a specializované instrukce, takže do horké smyčky nepatří. Naopak neměnný atribut třídy jako výchozí hodnota (timeout = 30), kterou přepíše potomek nebo instance, je levný a užitečný vzor.