ప్రత్యేక పద్ధతులు (డండర్)

ప్రత్యేక పద్ధతులు (డండర్ పద్ధతులు ఎందుకంటే అవి ప్రారంభమవుతాయి మరియు ముగుస్తాయి డబుల్ అండర్‌స్కోర్‌తో: __name__) మీ వస్తువులను అనుమతించే హుక్స్ భాషతో ఏకీకరణ: వచన ప్రాతినిధ్యం, ==తో పోలిక, len(), in, ఆపరేటర్లు మొదలైన వాటికి మద్దతు.

మీరు ఇప్పటికే ఒకదాన్ని ఉపయోగించారు: __init__.

__str__ మరియు __repr__

వారు print()తో మరియు REPLలో కనిపించే వాటిని నియంత్రిస్తారు.

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Punto({self.x}, {self.y})"

    def __str__(self):
        return f"({self.x}, {self.y})"

p = Punto(3, 4)
str(p)        # '(3, 4)'        — per umani
repr(p)       # 'Punto(3, 4)'   — per debugger / dev
print(p)      # '(3, 4)'
p             # Punto(3, 4)     in REPL → repr
[p, p]        # [Punto(3, 4), Punto(3, 4)]   — sempre repr nei contenitori

మీరు __repr__ని మాత్రమే నిర్వచిస్తే, పైథాన్ దానిని ఫాల్‌బ్యాక్‌గా కూడా ఉపయోగిస్తుంది __str__.

__eq__: పునర్నిర్వచనం ==

డిఫాల్ట్‌గా a == b ఆబ్జెక్ట్‌ల ఐడెంటిఫైయర్‌లను పోల్చింది (is), కాదు వారి విషయాలు. నిర్మాణాత్మక పోలిక కోసం, __eq__ని నిర్వచించండి:

class Punto:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        if not isinstance(other, Punto):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

Punto(1, 2) == Punto(1, 2)    # True
Punto(1, 2) == Punto(3, 4)    # False

రకాలుగా ఉన్నప్పుడు NotImplemented (ప్రత్యేక కీవర్డ్, False కాదు!) తిరిగి వస్తుంది పోల్చదగినది కాదు అనేది సరైన అభ్యాసం: పైథాన్ దానితో ప్రయత్నిస్తుంది ఇతర ఒపెరాండ్ __eq__.

__len__: len()కి మద్దతు

class Cesto:
    def __init__(self):
        self.frutti = []

    def __len__(self):
        return len(self.frutti)

c = Cesto()
c.frutti.append("mela")
len(c)        # 1
bool(c)       # True (len > 0)

__len__ని నిర్వచించడం ద్వారా, మీరు బూలియన్ని కూడా ఉచితంగా పొందుతారు: ఒక వస్తువు len() == 0తో తప్పుగా మారుతుంది.

ఇతర ఉపయోగకరమైన డండర్లు (అవలోకనం)

• __add__(self, other) → +ని పునర్నిర్వచించింది
• __lt__, __le__, __gt__, __ge__ → పోలిక ఆపరేటర్లు
• __contains__(self, item) → item in selfకి మద్దతు ఇస్తుంది
• __iter__ + __next__ → ఆబ్జెక్ట్‌ను మళ్లించేలా చేస్తుంది
• __getitem__(self, key) → self[key]కి మద్దతు ఇస్తుంది
• __hash__ → డిక్ట్ కీ / సెట్ ఎలిమెంట్‌గా ఉండాలి

మీ వంతు

వ్యాయామం సమీక్షించండి

అదనపు సవాలు