Lidsky řečeno
Dataclass je předtištěný formulář. Napíšeš jen, které kolonky existují, a nemusíš pokaždé kreslit tabulku, nadpisy a řádky. Enum je rozbalovací nabídka místo volného políčka: nikdo tam nenapíše „zaplaceno“, „Zaplaceno“ a „zaplcaeno“, protože si vybírá jen z toho, co nabídka obsahuje.
Třída, která jen nese data
Hodně tříd nedělá nic jiného, než že drží pár údajů pohromadě. Aby se s nimi dalo rozumně pracovat, potřebují __init__, __repr__ a __eq__. Každé jméno pak napíšeš několikrát.
class Kniha:
def __init__(self, nazev, autor, rok):
self.nazev = nazev
self.autor = autor
self.rok = rok
def __repr__(self):
return f"Kniha(nazev={self.nazev!r}, autor={self.autor!r}, rok={self.rok!r})"
def __eq__(self, other):
if not isinstance(other, Kniha):
return NotImplemented
return (self.nazev, self.autor, self.rok) == (other.nazev, other.autor, other.rok)
print(Kniha("Babička", "Božena Němcová", 1855))
Kniha(nazev='Babička', autor='Božena Němcová', rok=1855)
Přidáš čtvrtý údaj a musíš ho doplnit na čtyři místa. Na jedno zapomeneš a porovnávání začne tiše lhát. Dekorátor @dataclass tohle všechno vygeneruje z jednoho seznamu polí.
from dataclasses import dataclass
@dataclass
class Kniha:
nazev: str
autor: str
rok: int
a = Kniha("Babička", "Božena Němcová", 1855)
b = Kniha(nazev="Babička", autor="Božena Němcová", rok=1855)
print(a)
print(a == b)
print(a.rok)
Kniha(nazev='Babička', autor='Božena Němcová', rok=1855) True 1855
Zápis nazev: str je typová anotace, kterou znáš z funkcí. Tady má navíc funkci: právě podle ní dataclass pozná, že jde o pole. Kontrolu typů ale nedělá. Anotace je pro lidi a nástroje, Python za běhu spolkne cokoli.
from dataclasses import dataclass
@dataclass
class Bod:
x: float
y: float
print(Bod("ahoj", None))
Bod(x='ahoj', y=None)
Je to pořád normální třída. Můžeš do ní psát metody i property.
from dataclasses import dataclass
@dataclass
class Polozka:
nazev: str
cena: int
kusu: int = 1
@property
def celkem(self):
return self.cena * self.kusu
def popis(self):
return f"{self.kusu}x {self.nazev} = {self.celkem} Kč"
print(Polozka("Káva", 65, 2).popis())
print(Polozka("Dort", 120).popis())
2x Káva = 130 Kč 1x Dort = 120 Kč
Výchozí hodnoty a past se seznamem
Výchozí hodnotu napíšeš za rovnítko. Pole s výchozí hodnotou musí stát až za poli bez ní, stejně jako u parametrů funkce.
from dataclasses import dataclass
@dataclass
class Polozka:
kusu: int = 1
nazev: str
Seznam jako výchozí hodnotu dataclass odmítne rovnou. Všechny objekty by totiž sdílely jeden a tentýž seznam, a to je chyba, kterou znáš z výchozích parametrů funkcí.
from dataclasses import dataclass
@dataclass
class Kosik:
polozky: list = []
Správná cesta je field(default_factory=list). Továrna je cokoli, co se dá zavolat a vyrobí novou hodnotu. Volá se zvlášť pro každý nový objekt.
from dataclasses import dataclass, field
@dataclass
class Kosik:
zakaznik: str
polozky: list[str] = field(default_factory=list)
a = Kosik("Eva")
b = Kosik("Jan")
a.polozky.append("káva")
print(a)
print(b)
Kosik(zakaznik='Eva', polozky=['káva']) Kosik(zakaznik='Jan', polozky=[])
Funkce field umí víc. repr=False pole skryje z výpisu, což se hodí na hesla a tokeny. compare=False ho vynechá z porovnávání. init=False ho vyřadí z konstruktoru.
Když potřebuješ po vytvoření něco ověřit nebo dopočítat, napiš metodu __post_init__. Vygenerovaný __init__ ji zavolá na konci.
from dataclasses import dataclass, field
@dataclass
class Uzivatel:
email: str
heslo: str = field(repr=False)
domena: str = field(init=False)
def __post_init__(self):
self.email = self.email.strip().lower()
if "@" not in self.email:
raise ValueError("Tohle není e-mail.")
self.domena = self.email.split("@")[1]
print(Uzivatel(" Eva@Example.COM ", "tajne123"))
Uzivatel(email='eva@example.com', domena='example.com')
Knihovní záznam
Vytvoř dataclass Vypujcka s poli kniha (text), ctenar (text), dny (celé číslo, výchozí 30) a poznamky (seznam textů, výchozí prázdný a pro každou výpůjčku vlastní). Přidej metodu prodluz(o_kolik), která zvýší dny.
from dataclasses import dataclass, field
class Vypujcka:
pass # doplň
Neměnné objekty a další volby
S frozen=True nejde po vytvoření pole změnit. Takový objekt se chová jako hodnota, podobně jako číslo nebo text. Bonus: dostane hash, takže může být v množině nebo sloužit jako klíč slovníku.
from dataclasses import dataclass
@dataclass(frozen=True)
class Souradnice:
sirka: float
delka: float
praha = Souradnice(50.08, 14.43)
navstivena = {praha, Souradnice(50.08, 14.43)}
print(len(navstivena))
praha.sirka = 0
1
Změněnou verzi vyrobíš funkcí replace, která vrátí nový objekt. asdict převede objekt na slovník, což se hodí třeba pro JSON. order=True přidá porovnávání < podle polí v pořadí, jak jsou napsaná.
from dataclasses import dataclass, replace, asdict
import json
@dataclass(frozen=True, order=True)
class Verze:
hlavni: int
vedlejsi: int = 0
stara = Verze(1, 9)
nova = replace(stara, vedlejsi=10)
print(stara, nova)
print(stara < nova)
print(max(stara, nova, Verze(0, 99)))
print(json.dumps(asdict(nova)))
Verze(hlavni=1, vedlejsi=9) Verze(hlavni=1, vedlejsi=10)
True
Verze(hlavni=1, vedlejsi=10)
{"hlavni": 1, "vedlejsi": 10}Volba kw_only=True vynutí pojmenované argumenty. Hodí se u objektů s mnoha poli, kde Objednavka(5, 2, True, False) nikdo nerozluští. slots=True ušetří paměť, když máš objektů statisíce.
from dataclasses import dataclass
@dataclass(kw_only=True, slots=True)
class Nastaveni:
port: int = 8080
ladeni: bool = False
print(Nastaveni(port=9000))
print(Nastaveni(9000))
Nastaveni(port=9000, ladeni=False)
Časový interval
Vytvoř neměnnou dataclass Interval s poli zacatek a konec (celá čísla, třeba hodiny). Když je konec menší než zacatek, vyhoď při vytvoření ValueError. Přidej property delka a metodu prekryva(jiny). Ta vrátí True, když se dva intervaly překrývají. Intervaly, které se jen dotýkají (10 až 12 a 12 až 14), se nepřekrývají.
from dataclasses import dataclass
@dataclass
class Interval:
zacatek: int
konec: int
Proč polozky: list = [] v dataclass skončí chybou?
Výchozí hodnota se vyhodnotí jednou, při definici třídy. default_factory vyrobí pro každý objekt nový seznam.
enum: konečný seznam možností
Stav objednávky můžeš držet v textu. Překlep ale nikdo nezachytí a podmínka prostě neplatí.
stav = "zaplacena"
if stav == "zaplaceno":
print("Expedujeme.")
else:
print("Čekáme na platbu.")
Čekáme na platbu.
Výčet (enumeration, Enum) pojmenuje všechny povolené hodnoty na jednom místě. Překlep se změní v hlasitou chybu.
from enum import Enum
class Stav(Enum):
NOVA = "nova"
ZAPLACENA = "zaplacena"
ODESLANA = "odeslana"
stav = Stav.ZAPLACENA
print(stav)
print(stav.name)
print(stav.value)
print(stav is Stav.ZAPLACENA)
print([s.name for s in Stav])
print(Stav.ZAPLACENO)
Stav.ZAPLACENA ZAPLACENA zaplacena True ['NOVA', 'ZAPLACENA', 'ODESLANA']
Každý člen existuje jen jednou, takže se porovnává přes is. Z textu načteného ze souboru nebo databáze získáš člena voláním třídy, podle jména pak přes hranaté závorky. Neznámá hodnota skončí ValueError, takže špatná data neprojdou dál.
from enum import Enum, auto, StrEnum
class Stav(Enum):
NOVA = "nova"
ZAPLACENA = "zaplacena"
print(Stav("nova"))
print(Stav["ZAPLACENA"])
try:
Stav("smazana")
except ValueError as e:
print(e)
class Barva(Enum):
CERVENA = auto()
ZELENA = auto()
print(Barva.ZELENA.value)
class Format(StrEnum):
CSV = auto()
JSON = auto()
print(Format.CSV.value)
print(f"soubor.{Format.JSON}")
print(Format.CSV == "csv")
Stav.NOVA Stav.ZAPLACENA 'smazana' is not a valid Stav 2 csv soubor.json True
auto() hodnotu vymyslí za tebe. V obyčejném Enum čísluje od jedné. StrEnum z ní udělá jméno malými písmeny a člen se chová jako text, což se hodí pro JSON a API.
Výčet může mít metody a dataclass ho může mít jako pole. Spolu tvoří malý, ale spolehlivý model. Přechody mezi stavy se dají popsat prostým slovníkem.
from dataclasses import dataclass, field
from enum import Enum, auto
class Stav(Enum):
NOVA = auto()
ZAPLACENA = auto()
ODESLANA = auto()
ZRUSENA = auto()
def je_konecny(self):
return not PRECHODY[self]
PRECHODY = {
Stav.NOVA: {Stav.ZAPLACENA, Stav.ZRUSENA},
Stav.ZAPLACENA: {Stav.ODESLANA, Stav.ZRUSENA},
Stav.ODESLANA: set(),
Stav.ZRUSENA: set(),
}
@dataclass
class Objednavka:
cislo: int
stav: Stav = Stav.NOVA
historie: list[Stav] = field(default_factory=list)
def prejdi(self, novy):
if novy not in PRECHODY[self.stav]:
raise ValueError(f"{self.stav.name} nejde změnit na {novy.name}")
self.historie.append(self.stav)
self.stav = novy
o = Objednavka(1001)
o.prejdi(Stav.ZAPLACENA)
o.prejdi(Stav.ODESLANA)
print(o.stav.name, o.stav.je_konecny())
print([s.name for s in o.historie])
try:
o.prejdi(Stav.ZRUSENA)
except ValueError as e:
print(e)
ODESLANA True ['NOVA', 'ZAPLACENA'] ODESLANA nejde změnit na ZRUSENA
Co dělat dál
Vytvoř výčet Priorita se členy NIZKA = 1, STREDNI = 2, VYSOKA = 3. Vytvoř dataclass Ukol s poli nazev, priorita (výchozí Priorita.STREDNI) a hotovo (výchozí False). Funkce dalsi_ukol(ukoly) vrátí nehotový úkol s nejvyšší prioritou. Při shodě vrátí ten, který je v seznamu dřív. Když nic nezbývá, vrátí None.
from dataclasses import dataclass
from enum import Enum
# doplň Priorita, Ukol a dalsi_ukol
Co vypíše print(Stav("nova").name) pro class Stav(Enum): NOVA = "nova"?
Stav("nova") najde člena podle hodnoty a .name vrátí jeho jméno. Samotný print(člen) by vypsal Stav.NOVA.
Pod kapotou · co dataclass vlastně vyrobí
@dataclass není metatřída. Projde __annotations__, sestaví zdrojový text metod a zkompiluje je přes exec, takže __init__ je běžná funkce, prakticky stejně rychlá jako ručně psaná. Cenu platíš jednou, při importu. Třídě přidá __dataclass_fields__ a __match_args__, proto fungují vzory case Bod(x, y). Výchozí kombinace eq=True, frozen=False nastaví __hash__ = None, s frozen=True se hash počítá z polí s compare=True.
Ve verzi 3.12 je __eq__ definované jako porovnání n-tic polí a jen pro stejnou třídu. N-tice používají zkratku přes identitu, takže stejný objekt nan je „roven sám sobě“. Na tomhle detailu nestav, generovaný kód se mezi verzemi Pythonu mění.
from dataclasses import dataclass, field, fields, InitVar, KW_ONLY
@dataclass
class Mereni:
hodnota: float
class Jine(Mereni):
pass
nan = float("nan")
print(nan == nan)
print(Mereni(nan) == Mereni(nan))
print(Mereni(1) == Jine(1))
@dataclass
class Spojeni:
host: str
heslo: InitVar[str]
_: KW_ONLY
port: int = 443
token: str = field(init=False, repr=False)
def __post_init__(self, heslo):
self.token = heslo[::-1]
s = Spojeni("db", "tajne", port=5432)
print(s, s.token)
print([f.name for f in fields(s)])
print(Spojeni.__match_args__)
False
True
False
Spojeni(host='db', port=5432) enjat
['host', 'port', 'token']
('host', 'heslo')__match_args__ obsahuje i heslo, které jako atribut neexistuje, takže poziční vzor case Spojeni(h, p) se nikdy nechytí.
Detekce měnitelných výchozích hodnot se od 3.11 opírá o nehashovatelnost, takže odmítne i instanci jiné dataclass s eq=True. frozen je mělké: seznam uvnitř zmrazeného objektu změnit jde a hash() na takovém objektu selže. asdict jde rekurzivně a kopíruje přes copy.deepcopy, což je u velkých struktur znát. replace volá __init__ i __post_init__, validace tedy proběhne znovu. V __post_init__ frozen třídy se zapisuje přes object.__setattr__(self, "x", ...).
Pod kapotou · slots=True a nulové super()
slots=True nemůže změnit hotovou třídu, protože __slots__ musí existovat při jejím vzniku. Dataclass proto vyrobí novou třídu. Buňka __class__, kterou používá super() bez argumentů, ale pořád ukazuje na tu původní, a tak volání ve verzi 3.12 selže.
from dataclasses import dataclass
@dataclass(slots=True)
class Zaklad:
x: int = 0
def popis(self):
return "základ"
@dataclass(slots=True)
class Dite(Zaklad):
def popis(self):
return "dítě a " + super().popis()
try:
print(Dite().popis())
except TypeError as e:
print(type(e).__name__, e)
TypeError super(type, obj): obj must be an instance or subtype of type
Obrana je explicitní super(Dite, self) nebo volání Zaklad.popis(self).
Kdy co zvolit:
| Nástroj | Hodí se na |
|---|---|
dataclass | vlastní doménové objekty, bez validace typů, bez závislostí |
typing.NamedTuple | neměnný záznam, který má zůstat n-ticí a jde rozbalit |
typing.TypedDict | data, která jsou slovník (JSON), kontroluje jen typová kontrola |
pydantic | hranice systému: vstup zvenčí, převod a validace za běhu |
Pod kapotou · enum v produkci
Členové jsou singletony vytvořené metatřídou EnumType. Stejná hodnota podruhé nevytvoří člena, ale alias, což @unique zakáže. Ve verzi 3.11 se změnilo formátování: format() a f-string dávají u class X(str, Enum) stejný výsledek jako str(), tedy X.A. Kdo tak skládal URL nebo názvy souborů, dostal po upgradu jiný text. StrEnum a IntEnum jsou na to správná odpověď. Od verze 3.12 test hodnota in TridaEnum přijímá i hodnoty, dřív vyhodil TypeError.
from enum import Enum, StrEnum, IntEnum, auto
class Stary(str, Enum):
A = "a"
class Novy(StrEnum):
A = auto()
print(f"{Stary.A} / {Novy.A}")
print(Stary.A == "a", Novy.A == "a")
print("a" in Novy, "b" in Novy)
class Kod(Enum):
OK = 200
HOTOVO = 200
print(Kod.HOTOVO, Kod.HOTOVO is Kod.OK, len(Kod), len(Kod.__members__))
class Uroven(IntEnum):
NULA = 0
class Prosta(Enum):
NULA = 0
print(bool(Uroven.NULA), bool(Prosta.NULA))
Stary.A / a True True True False Kod.OK True 1 2 False True
Poslední řádek je další rozdíl: člen obyčejného Enum je vždy pravdivý, i když má hodnotu 0, zatímco IntEnum se chová jako číslo.
Tři produkční pravidla. Do databáze ukládej explicitní value, nikdy hodnotu z auto() u číselného výčtu: přidání člena doprostřed přečísluje všechno za ním. pickle ukládá členy podle jména, takže přejmenování rozbije staré soubory. A při rozšiřování výčtu počítej se starými klienty: API, které přidá nový stav, shodí každého, kdo volá Stav(hodnota) bez ošetření. Pro kombinovatelné příznaky existuje enum.Flag.