మాడ్యూల్ పాఠాలు (2/4)
డేటాక్లాస్: బాయిలర్ప్లేట్ లేని డేటా తరగతులు
@dataclass డెకరేటర్ (dataclasses మాడ్యూల్) స్వయంచాలకంగా ఉత్పత్తి చేస్తుంది
__init__, __repr__, మరియు __eq__ తరగతులకు ** పట్టుకోవడమే ఏకైక పని
డేటా**. తక్కువ బాయిలర్ప్లేట్, స్పష్టమైన కోడ్.
డేటాక్లాస్ లేకుండా (బాయిలర్ప్లేట్)
class Punto:
def __init__(self, x: float, y: float) -> None:
self.x = x
self.y = y
def __repr__(self) -> str:
return f"Punto(x={self.x}, y={self.y})"
def __eq__(self, other) -> bool:
if not isinstance(other, Punto):
return NotImplemented
return (self.x, self.y) == (other.x, other.y)డేటాక్లాస్తో
from dataclasses import dataclass
@dataclass
class Punto:
x: float
y: float
p = Punto(3, 4)
p # Punto(x=3, y=4) ← __repr__ gratis
Punto(3, 4) == Punto(3, 4) # True ← __eq__ gratis
p.x, p.y # 3, 4నమూనా: ఫీల్డ్లను తరగతి ఉల్లేఖనాలు (name: type),
ఐచ్ఛికంగా డిఫాల్ట్ విలువతో. @dataclass మిగిలిన వాటిని ఉత్పత్తి చేస్తుంది.
డిఫాల్ట్ మరియు డిఫాల్ట్_ఫ్యాక్టరీ
from dataclasses import dataclass, field
@dataclass
class Articolo:
nome: str
prezzo: float = 0.0
tag: list[str] = field(default_factory=list)frozen=నిజం: మార్పులేని
@dataclass(frozen=True)
class Coordinata:
lat: float
lon: float
c = Coordinata(45.4, 9.2)
c.lat = 99 # FrozenInstanceError!frozen డేటాక్లాస్లు కూడా హాషబుల్: మీరు వాటిని డిక్ట్ కీలుగా ఉపయోగించవచ్చు
లేదా సెట్ ఎలిమెంట్స్.
ఆర్డర్=నిజం: స్వయంచాలక పోలికలు
@dataclass(order=True)
class Voto:
valore: int
Voto(10) < Voto(20) # True
sorted([Voto(30), Voto(10), Voto(20)])క్రమంలో ఫీల్డ్లను పోల్చడం ద్వారా __lt__, __le__, __gt__, __ge__ ఉత్పత్తి చేస్తుంది
వారు ప్రకటించారు.
సాధారణ పద్ధతులు
డేటాక్లాస్లు సాధారణ తరగతులుగా ఉంటాయి: మీరు పద్ధతులను జోడించవచ్చు.
import math
from dataclasses import dataclass
@dataclass
class Punto:
x: float
y: float
def distanza_dall_origine(self) -> float:
return math.hypot(self.x, self.y)
Punto(3, 4).distanza_dall_origine() # 5.0మార్పులేని మరియు సమర్థవంతమైన డేటాక్లాస్లు
మీరు frozen=True ఆర్గ్యుమెంట్ను డెకరేటర్కి పంపడం ద్వారా డేటాక్లాస్ను మార్చలేనిదిగా చేయవచ్చు: @dataclass(frozen=True). ఇది ఇన్స్టాంటియేషన్ తర్వాత లక్షణాలను మార్చడానికి చేసే ఏదైనా ప్రయత్నంలో ఎర్రర్ను లేవనెత్తుతుంది, సందర్భాలను ఏకకాలిక వాతావరణంలో లేదా నిఘంటువు కీలుగా ఉపయోగించడం కోసం సురక్షితంగా చేస్తుంది.
మీరే ప్రయత్నించండి
`శీర్షిక: str` మరియు `పేజీలు: int` ఫీల్డ్లతో డేటాక్లాస్ `బుక్`ని సృష్టించండి. దీన్ని `l = Book('Moby Dick', 635)` అని తక్షణం చేయండి. మూల్యాంకనం `l == Book('Moby Dick', 635)`.
సూచనను చూపించు
@dataclass ఫీల్డ్ వారీగా పోల్చి __eq__ని ఉత్పత్తి చేస్తుంది.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
వ్యాయామం సమీక్షించండి
ఫీల్డ్ `ఐటెమ్లు: జాబితా[str]` default_factory=listతో డేటాక్లాస్ `Basket`ని సృష్టించండి. తక్షణం `c1 = బాస్కెట్()` మరియు `c2 = బాస్కెట్()`, c1.itemsకు 'మేలా'ని జత చేయండి. అవి ఒకే జాబితా కాదని ధృవీకరించడానికి `(c1.items, c2.items)`ని మూల్యాంకనం చేయండి.
సూచనను చూపించు
ఫీల్డ్(default_factory=list) ప్రతి ఉదాహరణకి కొత్త జాబితాకు హామీ ఇస్తుంది.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది
అదనపు సవాలు
Import `dataclass` from `dataclasses`. Create a dataclass `Point` containing two float coordinates `x` and `y`. Instantiate a point with `x=1.5` and `y=2.5` storing it in `p`. Finally, evaluate `p`.
సూచనను చూపించు
క్లాస్ పాయింట్ పైన @dataclass ఉపయోగించండి మరియు x: float మరియు y: float అని ప్రకటించండి.
3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది