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())
121.0 484.0
21 21
{'nazev': 'Hrnek', 'cena': 100}
125.0 500.0vars(hrnek) ukazuje, že hrnek žádnou sazbu nemá. Přesto hrnek.sazba_dph funguje, protože Python hledá v tomhle pořadí:
hrnek.sazba_dph
1. má ten atribut přímo objekt hrnek? ne
2. má ho jeho třída Produkt? ano, 21Tí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)
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.
Čí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ň
Třída má barva = "bílá". Spustíš a.barva = "černá". Co vrátí b.barva u jiné instance?
Přiřazení přes instanci mění jen tu instanci. Třída i ostatní objekty zůstávají, jak byly.
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())
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__)
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"))
{'a': 0, 'b': 0}
11
256staticmethod: 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)
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:
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 moduluTeplota 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
Co dostane jako první argument metoda označená @classmethod, když ji zavoláš přes instanci, tedy objekt.metoda()?
@classmethod předává vždy třídu, ať ji voláš přes třídu, nebo přes objekt. U potomka je to potomek.
Máš funkci, která jen převádí koruny na haléře a s žádnou třídou nesouvisí. Kam patří?
Python tě nenutí balit všechno do tříd. Třída bez stavu a bez chování je jen složitější modul.
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)
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.