0 dní v řadě · 0 bodů

Objekty · 24 min

dataclasses a enum

Třídy na data bez opisování __init__ a __eq__ a výčty, které nahradí textové konstanty a překlepy chytí hned.

Hloubka
Úkoly
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))
Výstup
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)
Výstup
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))
Výstup
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())
Výstup
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
Výstup

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 = []
Výstup

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)
Výstup
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"))
Výstup
Uzivatel(email='eva@example.com', domena='example.com')
Úkol

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ň
Výstup

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
Výstup
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)))
Výstup
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))
Výstup
Nastaveni(port=9000, ladeni=False)
Úkol

Č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
Výstup
Kvíz

Proč polozky: list = [] v dataclass skončí chybou?

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.")
Výstup
Č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)
Výstup
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")
Výstup
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)
Výstup
ODESLANA True
['NOVA', 'ZAPLACENA']
ODESLANA nejde změnit na ZRUSENA
Úkol

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
Výstup
Kvíz

Co vypíše print(Stav("nova").name) pro class Stav(Enum): NOVA = "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__)
Výstup
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)
Výstup
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ástrojHodí se na
dataclassvlastní doménové objekty, bez validace typů, bez závislostí
typing.NamedTupleneměnný záznam, který má zůstat n-ticí a jde rozbalit
typing.TypedDictdata, která jsou slovník (JSON), kontroluje jen typová kontrola
pydantichranice 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))
Výstup
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.