पाइथन र उन्नत विधिहरू, राम्रो प्रोग्रामिङको लागि डन्डर प्रकार्यहरू

पाइथन एक उत्कृष्ट प्रोग्रामिङ भाषा हो, र यसको प्रमाण अनुसार GitHub, २०२२ मा दोस्रो सबैभन्दा लोकप्रिय भाषा पनि हो।

पाइथनको सबैभन्दा रोचक फाइदाहरू प्रोग्रामरहरूको ठूलो समुदाय हो।

यस्तो देखिन्छ कि पाइथनसँग कुनै पनि प्रयोग केसको लागि प्याकेज छ।

पाइथन प्रोग्रामिङको विशाल संसारमा, त्यहाँ सुविधाहरूको सेट छ जुन प्रायः शुरुवातकर्ताहरूले बेवास्ता गर्छन्, तर भाषाको इकोसिस्टममा महत्त्वपूर्ण महत्त्व छ।

जादुई विधिहरू पूर्व विधिहरूको सेट होdefiPython मा nited जसले विशेष सिन्ट्याक्टिक कार्यक्षमता प्रदान गर्दछ। तिनीहरू सजिलै सुरु र अन्त्यमा तिनीहरूको डबल ड्यासहरू द्वारा चिन्न सकिन्छ, जस्तै __init__, __call__, __len__ … आदि

जादुई विधिहरू

जादुई विधिहरूले अनुकूलन वस्तुहरूलाई बिल्ट-इन पाइथन प्रकारहरू जस्तै व्यवहार गर्न अनुमति दिन्छ।

यस लेखमा, हामी शक्तिशाली डन्डर प्रकार्यहरूमा ध्यान केन्द्रित गर्नेछौं। हामी तिनीहरूको उद्देश्य अन्वेषण गर्नेछौं र तिनीहरूको प्रयोगको बारेमा छलफल गर्नेछौं।

चाहे तपाईं पाइथन नौसिखिया वा अनुभवी प्रोग्रामर हुनुहुन्छ, यो लेखले तपाईंलाई डन्डर प्रकार्यहरूको विस्तृत बुझाइ प्रदान गर्ने लक्ष्य राख्छ, तपाईंको पाइथन कोडिङ अनुभवलाई अझ प्रभावकारी र रमाइलो बनाउँछ।

याद गर्नुहोस्, पाइथनको जादू यसको सरलता र बहुमुखी प्रतिभामा मात्र होइन, तर डन्डर प्रकार्यहरू जस्ता शक्तिशाली सुविधाहरूमा पनि छ।

__यसमा__

सायद सबैको सबैभन्दा आधारभूत डन्डर प्रकार्य। यो जादुई विधि हो जुन पाइथनले स्वचालित रूपमा कल गर्छ जब हामी नयाँ वस्तु सिर्जना गर्छौं (वा नामले सुझाव दिन्छ, प्रारम्भिक)।__init__

वर्ग पिज्जा:
    def __init__ (स्व, आकार, toppings):
        self.size = आकार
        self.toppings = toppings

# अब पिज्जा बनाउनुहोस्
my_pizza = पिज्जा ('ठूलो', ['पेपेरोनी', 'मशरूम'])

print(my_pizza.size) # यसले छाप्नेछ: ठूलो
print(my_pizza.toppings) # यसले प्रिन्ट गर्नेछ: ['पेपेरोनी', 'मशरूम']

यस उदाहरणमा, पिज्जा भनिने वर्ग सिर्जना गरिएको छ। हामीले हाम्रो __init__ प्रकार्यलाई प्रारम्भिक समयमा निर्दिष्ट गर्न प्यारामिटरहरू समावेश गर्न सेट अप गर्यौं, र तिनीहरूलाई हाम्रो अनुकूलन वस्तुको लागि गुणहरूको रूपमा सेट गर्नुहोस्।

यहाँ, यो वर्गको उदाहरण प्रतिनिधित्व गर्न प्रयोग गरिन्छ। त्यसोभए जब हामी self.size = साइज लेख्छौं, हामी भन्छौं, "हे, यो पिज्जा वस्तुको विशेषता आकार छ size, र मैले वस्तु सिर्जना गर्दा उपलब्ध गराएको जुनसुकै साइज होस् भन्ने म चाहन्छु।"

__str__ र __repr__

__Str__

यो पाइथनको जादुई विधि हो जसले हामीलाई अनुमति दिन्छ defiहाम्रो अनुकूलित वस्तुको लागि विवरण।

जब तपाइँ कुनै वस्तु प्रिन्ट गर्नुहुन्छ वा यसलाई प्रयोग गरेर स्ट्रिङमा रूपान्तरण गर्नुहुन्छ str(), Python छ भने जाँच गर्नुहोस् defiएउटा विधि ल्यायो __str__ त्यो वस्तुको वर्गको लागि।

यदि त्यसो हो भने, वस्तुलाई स्ट्रिङमा रूपान्तरण गर्न त्यो विधि प्रयोग गर्नुहोस्।

हामी एक प्रकार्य समावेश गर्न हाम्रो पिज्जा उदाहरण विस्तार गर्न सक्छौं __str__ निम्न अनुसार:

वर्ग पिज्जा: def __init__(self, size, toppings): self.size = साइज self.toppings = toppings def __str__(self): रिटर्न f"A {self.size} पिज्जा {', '.join(self.toppings) सँग )}" my_pizza = पिज्जा('ठूलो', ['पेपेरोनी', 'मशरूम']) प्रिन्ट(my_pizza) # यो प्रिन्ट हुनेछ: पेपरोनी, च्याउ सहितको ठूलो पिज्जा

__repr__

__str__ प्रकार्य वस्तुको गुणहरू वर्णन गर्ने अनौपचारिक तरिका हो। अर्कोतर्फ, __repr__ लाई अनुकूलन वस्तुको थप औपचारिक, विस्तृत र अस्पष्ट विवरण प्रदान गर्न प्रयोग गरिन्छ।

बोलाएमा repr() कुनै वस्तुमा वा तपाईंले कन्सोलमा वस्तुको नाम मात्र टाइप गर्नुहुन्छ, पाइथनले विधि खोज्नेछ __repr__.

Se __str__ यो होइन definite, Python प्रयोग गर्नेछ __repr__ ब्याकअपको रूपमा वस्तु प्रिन्ट गर्न वा यसलाई स्ट्रिङमा रूपान्तरण गर्ने प्रयास गर्दा। त्यसैले यो अक्सर एक राम्रो विचार हो defiकम्तिमा अन्त्य __repr__, यदि तपाइँ छैन भने पनि defiसमाप्त हुन्छ __str__.

हामी कसरी गर्न सक्छौं यहाँ छ defiसमाप्त __repr__ हाम्रो पिज्जा उदाहरण को लागी:

वर्ग पिज्जा:
    def __init__ (स्व, आकार, toppings):
        self.size = आकार
        self.toppings = toppings

    def __repr__ (आत्म):
        f"पिज्जा('{self.size}', {self.toppings})" फर्काउनुहोस्

my_pizza = पिज्जा ('ठूलो', ['पेपेरोनी', 'मशरूम'])
print(repr(my_pizza)) # यसले छाप्नेछ: पिज्जा('ठूलो', ['पेपेरोनी', 'मशरूम'])

__repr__ तपाईँलाई एउटा स्ट्रिङ दिन्छ जुन तपाईँले पिज्जा वस्तु पुन: सिर्जना गर्न पाइथन आदेशको रूपमा चलाउन सक्नुहुन्छ, जबकि __str__ तपाईंलाई थप मानव विवरण दिन्छ। मलाई आशा छ कि यसले तपाईंलाई यी डन्डर विधिहरू अलि राम्रो चबाउन मद्दत गर्दछ!

__थप्नुहोस्__

पाइथनमा, हामी सबैलाई थाहा छ कि अपरेटर प्रयोग गरेर नम्बरहरू थप्न सम्भव छ +जस्तै 3 + 5.

तर के हुन्छ यदि हामी केहि अनुकूलन वस्तुको उदाहरणहरू थप्न चाहन्छौं?

डन्डर प्रकार्य __add__ यसले हामीलाई त्यसो गर्न अनुमति दिन्छ। यसले हामीलाई मौका दिन्छ defiअपरेटरको व्यवहारलाई परिष्कृत गर्नुहोस् + हाम्रो व्यक्तिगत वस्तुहरूमा।

स्थिरताको हितमा, हामी चाहन्छौं कि मानौं defiनाइट को व्यवहार + हाम्रो पिज्जा उदाहरण मा। मानौं कि जब हामी दुई वा बढी पिज्जाहरू सँगै थप्छौं, यसले स्वचालित रूपमा तिनीहरूका सबै टपिङहरू जोड्नेछ। यो कस्तो देखिन सक्छ यहाँ छ:

वर्ग पिज्जा:
    def __init__ (स्व, आकार, toppings):
        self.size = आकार
        self.toppings = toppings

    def __add__(स्व, अन्य):
        यदि होइन भने उदाहरण (अन्य, पिज्जा):
            उठाउनुहोस् TypeError ("तपाईले अर्को पिज्जा मात्र थप्न सक्नुहुन्छ!")
        new_toppings = self.toppings + other.toppings
        फिर्ता पिज्जा (self.size, new_toppings)

# दुई पिज्जा बनाऔं
pizza1 = पिज्जा ('ठूलो', ['पेपेरोनी', 'मशरूम'])
pizza2 = पिज्जा ('ठूलो', ['जैतून', 'अनानास'])

# र अब तिनीहरूलाई "थप्नुहोस्" गरौं
combined_pizza = pizza1 + pizza2

print(combined_pizza.toppings) # यसले छाप्नेछ: ['पेपेरोनी', 'मशरूम', 'जैतून', 'अनानास']

त्यस्तै डन्डरमा __add__, हामी पनि सक्छौं definite अन्य अंकगणितीय कार्यहरू जस्तै __sub__ (अपरेटर प्रयोग गरेर घटाउ -) छ __mul__ (अपरेटर प्रयोग गरेर गुणनका लागि *).

__len__

यो डन्डर विधिले हामीलाई अनुमति दिन्छ definish के प्रकार्य len() हाम्रो अनुकूलित वस्तुहरूको लागि फिर्ता गर्नुपर्छ।

पाइथन प्रयोग गर्दछ len() सूची वा स्ट्रिङ जस्ता डेटा संरचनाको लम्बाइ वा आकार प्राप्त गर्न।

हाम्रो उदाहरणको सन्दर्भमा, हामी भन्न सक्छौं कि पिज्जाको "लम्बाइ" भनेको यसमा रहेको टपिङहरूको संख्या हो। यहाँ हामीले यसलाई कसरी कार्यान्वयन गर्न सक्छौं:

वर्ग पिज्जा:
    def __init__ (स्व, आकार, toppings):
        self.size = आकार
        self.toppings = toppings

    def __len__ (आत्म):
        फिर्ता लेन (self.toppings)

# पिज्जा बनाऔं
my_pizza = पिज्जा ('ठूलो', ['पेपेरोनी', 'मशरूम', 'जैतून'])

print(len(my_pizza)) # यसले प्रिन्ट गर्नेछ: ३

__len__ विधिमा, हामी सूचीको लम्बाइ मात्र फर्काउँछौं toppings। अब, len(my_pizza) यसले हामीलाई बताउनेछ कि यसमा कति टपिङहरू छन् my_pizza.

__ प्रक्रिया __

यो डन्डर विधिले वस्तुहरूलाई पुनरावृत्ति गर्न अनुमति दिन्छ, अर्थात् यसलाई लुपको लागि प्रयोग गर्न सकिन्छ।

यो गर्न, हामीले पनि गर्नुपर्छ defiसमारोह समाप्त गर्नुहोस् __next__, यो लागि प्रयोग गरिन्छ defiव्यवहार अन्त्य गर्नुहोस् जुन पुनरावृत्तिमा अर्को मान फिर्ता गर्नुपर्छ। यसबाहेक, यसले घटनामा पुनरावृत्तिमा पनि सङ्केत गर्नुपर्छ कि अनुक्रममा कुनै थप तत्वहरू छैनन्। हामी सामान्यतया अपवाद उठाएर यो प्राप्त गर्छौं StopIteration.

हाम्रो पिज्जा उदाहरणको लागि, मानौं कि हामी टपिङहरू दोहोर्याउन चाहन्छौं। हामीले हाम्रो पिज्जा कक्षालाई पुनरावृत्ति गर्न सक्छौं defiविधि दिँदै __iter__:

वर्ग पिज्जा:
    def __init__ (स्व, आकार, toppings):
        self.size = आकार
        self.toppings = toppings

    def __iter__(स्व):
        self.n = 0
        आफै फिर्ता

    def __next__(self):
        यदि self.n < len(self.toppings):
            परिणाम = self.toppings[self.n]
            self.n += 1
            परिणाम फिर्ता
        अर्को:
            StopIteration बढाउनुहोस्

# पिज्जा बनाऔं
my_pizza = पिज्जा ('ठूलो', ['पेपेरोनी', 'मशरूम', 'जैतून'])

# र अब यसलाई दोहोर्याउनुहोस्
my_pizza मा टपिङ को लागी:
    प्रिन्ट (टपिङ)

यस अवस्थामा, पाश कलहरूको लागि __iter__, जसले काउन्टर प्रारम्भ गर्दछ (self.n) र पिज्जा वस्तु आफै फर्काउँछ (self).

त्यसपछि, लूप कलहरूको लागि __next__ पालोमा प्रत्येक टपिङ प्राप्त गर्न।

जब __next__ सबै मसला फिर्ता गरे, StopIteration यसले एक अपवाद फ्याँक्छ र लूपको लागि अब थाहा छ कि त्यहाँ कुनै थप टपिङहरू छैनन् र त्यसले पुनरावृत्ति प्रक्रियालाई रद्द गर्नेछ।

Ercole Palmeri