पायथन प्रोग्रामिंगच्या विशाल जगात, अशा वैशिष्ट्यांचा एक संच आहे जो सहसा नवशिक्यांकडे लक्ष देत नाही, तरीही भाषेच्या इकोसिस्टममध्ये महत्त्वपूर्ण महत्त्व आहे.
जादूच्या पद्धती या पूर्व पद्धतींचा संच आहेdefiPython मधील nites जे विशेष वाक्यरचना वैशिष्ट्ये प्रदान करतात. सुरुवातीला आणि शेवटी त्यांच्या दुहेरी डॅशद्वारे ते सहजपणे ओळखले जातात, जसे __init__, __call__, __len__ … इ.
जादूच्या पद्धती सानुकूल वस्तूंना अंगभूत पायथन प्रकारांप्रमाणे वागण्याची परवानगी देतात.
या लेखात, आम्ही शक्तिशाली डंडर फंक्शन्सवर लक्ष केंद्रित करू. आम्ही त्यांचा उद्देश शोधू आणि त्यांच्या वापरावर चर्चा करू.
तुम्ही पायथनचे नवशिक्या असाल किंवा अनुभवी प्रोग्रामर असाल, हा लेख तुम्हाला डंडर फंक्शन्सची सर्वसमावेशक माहिती प्रदान करण्याचा उद्देश आहे, ज्यामुळे तुमचा पायथन कोडिंग अनुभव अधिक कार्यक्षम आणि आनंददायक होईल.
लक्षात ठेवा, पायथनची जादू केवळ त्याच्या साधेपणात आणि अष्टपैलुपणामध्येच नाही तर डंडर फंक्शन्स सारख्या शक्तिशाली वैशिष्ट्यांमध्ये देखील आहे.
कदाचित सर्वांचे सर्वात मूलभूत डंडर फंक्शन. ही जादूची पद्धत आहे जी जेव्हाही आपण नवीन ऑब्जेक्ट तयार करतो (किंवा नावाप्रमाणे, इनिशियलाइज करतो) तेव्हा पायथन आपोआप कॉल करतो.__init__
वर्ग पिझ्झा:
def __init__(स्वतः, आकार, टॉपिंग्ज):
self.size = आकार
self.toppings = toppings
# आता पिझ्झा बनवू
my_pizza = पिझ्झा('मोठा', ['पेपेरोनी', 'मशरूम'])
print(my_pizza.size) # हे प्रिंट करेल: मोठे
print(my_pizza.toppings) # हे प्रिंट करेल: ['पेपेरोनी', 'मशरूम']
या उदाहरणात पिझ्झा नावाचा वर्ग तयार केला आहे. आम्ही आमचे __init__ फंक्शन सेट अप करतो जेणेकरुन सुरुवातीच्या वेळी निर्दिष्ट करावयाचे पॅरामीटर्स समाविष्ट केले जातील आणि त्यांना आमच्या कस्टम ऑब्जेक्टसाठी गुणधर्म म्हणून सेट करा.
येथे, ते वर्गाचे उदाहरण दर्शवण्यासाठी वापरले जाते. म्हणून जेव्हा आपण self.size = आकार लिहितो, तेव्हा आपण म्हणतो, "अरे, या पिझ्झा ऑब्जेक्टला विशेषता आकार आहे size, आणि मी ऑब्जेक्ट तयार केल्यावर मी दिलेला कोणताही आकार असावा असे मला वाटते”.
ही पायथनची जादूची पद्धत आहे जी आम्हाला याची परवानगी देते defiआमच्या सानुकूल आयटमचे वर्णन करा.
जेव्हा तुम्ही एखादी वस्तू मुद्रित करता किंवा ती वापरून स्ट्रिंगमध्ये रूपांतरित करता str(), Python तुमच्याकडे आहे का ते तपासा defiमी एक पद्धत शोधून काढली आहे __str__ त्या ऑब्जेक्टच्या वर्गासाठी.
तसे असल्यास, ऑब्जेक्टला स्ट्रिंगमध्ये रूपांतरित करण्यासाठी ती पद्धत वापरा.
फंक्शन समाविष्ट करण्यासाठी आम्ही आमचे पिझ्झाचे उदाहरण वाढवू शकतो __str__ खालीलप्रमाणे:
वर्ग पिझ्झा: def __init__(self, size, toppings): self.size = आकार self.toppings = toppings def __str__(self): {', '.join(self.toppings) सह f"A {self.size} पिझ्झा परत करा )}" my_pizza = Pizza('large', ['pepperoni', 'mshrooms']) print(my_pizza) # हे प्रिंट करेल: पेपरोनी, मशरूमसह मोठा पिझ्झा
__repr____str__ फंक्शन हे ऑब्जेक्टच्या गुणधर्मांचे वर्णन करण्याचा अनौपचारिक मार्ग आहे. दुसरीकडे, सानुकूल ऑब्जेक्टचे अधिक औपचारिक, तपशीलवार आणि अस्पष्ट वर्णन देण्यासाठी __repr__ वापरला जातो.
फोन केला तर repr() एखाद्या ऑब्जेक्टवर किंवा तुम्ही फक्त कन्सोलमध्ये ऑब्जेक्टचे नाव टाइप करा, पायथन पद्धत शोधेल __repr__.
Se __str__ ते नाही definite, Python वापरेल __repr__ ऑब्जेक्ट मुद्रित करण्याचा किंवा स्ट्रिंगमध्ये रूपांतरित करण्याचा प्रयत्न करताना बॅकअप म्हणून. त्यामुळे अनेकदा एक चांगली कल्पना आहे defiकिमान पूर्ण करा __repr__, तुम्ही नाही केले तरीही defiबाहेर येतो __str__.
आम्ही कसे करू शकतो ते येथे आहे defiसमाप्त __repr__ आमच्या पिझ्झा उदाहरणासाठी:
वर्ग पिझ्झा:
def __init__(स्वतः, आकार, टॉपिंग्ज):
self.size = आकार
self.toppings = toppings
def __repr__(स्वतः):
परत करा f"Pizza('{self.size}', {self.toppings})"
my_pizza = पिझ्झा('मोठा', ['पेपेरोनी', 'मशरूम'])
print(repr(my_pizza)) # हे प्रिंट करेल: पिझ्झा('मोठा', ['पेपेरोनी', 'मशरूम'])
__repr__ तुम्हाला एक स्ट्रिंग देते जी तुम्ही पिझ्झा ऑब्जेक्ट पुन्हा तयार करण्यासाठी पायथन कमांड म्हणून चालवू शकता __str__ तुम्हाला अधिक मानवी वर्णन देते. मला आशा आहे की हे तुम्हाला या डंडर पद्धती थोडे चांगले चघळण्यास मदत करेल!
पायथनमध्ये, ऑपरेटर वापरून संख्या जोडणे शक्य आहे हे आपल्या सर्वांना माहीत आहे +सारखे 3 + 5.
पण काही सानुकूल ऑब्जेक्टची उदाहरणे जोडायची असतील तर?
डंडर फंक्शन __add__ ते आम्हाला तेच करण्यास अनुमती देते. ते आम्हाला क्षमता देते defiऑपरेटरच्या वर्तनावर मात करा + आमच्या वैयक्तिकृत आयटमवर.
सुसंगततेच्या हितासाठी, आपल्याला हवे आहे असे गृहीत धरू defiचे वर्तन पूर्ण करा + आमच्या पिझ्झाच्या उदाहरणावर. आपण असे म्हणूया की जेव्हाही आपण दोन किंवा अधिक पिझ्झा एकत्र जोडतो, तेव्हा ते आपोआप त्यांचे सर्व टॉपिंग एकत्र करेल. ते कसे दिसू शकते ते येथे आहे:
वर्ग पिझ्झा:
def __init__(स्वतः, आकार, टॉपिंग्ज):
self.size = आकार
self.toppings = toppings
def __add__(स्वतः, इतर):
उदाहरण नसल्यास (इतर, पिझ्झा):
TypeError raise ("तुम्ही फक्त दुसरा पिझ्झा जोडू शकता!")
new_toppings = self.toppings + other.toppings
रिटर्न पिझ्झा (स्व. आकार, नवीन_टॉपिंग)
# दोन पिझ्झा बनवू
pizza1 = पिझ्झा('मोठा', ['पेपेरोनी', 'मशरूम'])
pizza2 = पिझ्झा('मोठा', ['ऑलिव्ह', 'अननस'])
# आणि आता त्यांना "add" करूया
combined_pizza = pizza1 + pizza2
print(combined_pizza.toppings) # हे मुद्रित करेल: ['पेपेरोनी', 'मशरूम', 'ऑलिव्ह', 'अननस']
त्याचप्रमाणे डंडर __add__, आम्ही देखील करू शकतो defiइतर अंकगणित कार्ये पूर्ण करा जसे की __sub__ (ऑपरेटर वापरून वजाबाकी करून -) आणि __mul__ (ऑपरेटर वापरून गुणाकार करण्यासाठी *).
ही डंडर पद्धत आम्हाला परवानगी देते defiकार्य पूर्ण करा len() आमच्या सानुकूलित आयटमसाठी परत येणे आवश्यक आहे.
पायथन वापरतो len() सूची किंवा स्ट्रिंग सारख्या डेटा संरचनेची लांबी किंवा आकार मिळवण्यासाठी.
आमच्या उदाहरणाच्या संदर्भात, आम्ही असे म्हणू शकतो की पिझ्झाची "लांबी" ही त्यात असलेल्या टॉपिंगची संख्या आहे. आम्ही ते कसे अंमलात आणू शकतो ते येथे आहे:
वर्ग पिझ्झा:
def __init__(स्वतः, आकार, टॉपिंग्ज):
self.size = आकार
self.toppings = toppings
def __len__(स्वतः):
रिटर्न लेन (self.toppings)
# चला पिझ्झा बनवूया
my_pizza = पिझ्झा('मोठा', ['पेपेरोनी', 'मशरूम', 'ऑलिव्ह'])
print(len(my_pizza)) # हे प्रिंट करेल: 3
__len__ पद्धतीमध्ये, आम्ही फक्त सूचीची लांबी परत करतो toppings. आता, len(my_pizza) त्यावर किती टॉपिंग आहेत ते आम्हाला सांगेल my_pizza.
ही डंडर पद्धत ऑब्जेक्ट्सला पुनरावृत्ती करता येण्याजोगी परवानगी देते, म्हणजेच ती फॉर लूपमध्ये वापरली जाऊ शकते.
हे करण्यासाठी, आपण देखील केले पाहिजे defiफंक्शन पूर्ण करा __next__, हे यासाठी वापरले जाते defiवर्तन निश करा जे पुनरावृत्तीमध्ये पुढील मूल्य परत करेल. हे इव्हेंटवर पुनरावृत्ती करण्यायोग्य सिग्नल देखील पाहिजे की अनुक्रमात आणखी कोणतेही घटक नाहीत. आम्ही सामान्यत: अपवाद टाकून हे साध्य करतो StopIteration.
आमच्या पिझ्झाच्या उदाहरणासाठी, आम्हाला टॉपिंग्ज पुन्हा करायच्या आहेत असे समजा. आम्ही आमचा पिझ्झा वर्ग पुनरावृत्ती करण्यायोग्य बनवू शकतो defiएक पद्धत निश्चित करा __iter__:
वर्ग पिझ्झा:
def __init__(स्वतः, आकार, टॉपिंग्ज):
self.size = आकार
self.toppings = toppings
def __iter__(स्वतः):
self.n = 0
स्वत: ला परत करा
def __next__(स्वतः):
जर self.n < len(self.toppings):
परिणाम = self.toppings[self.n]
self.n += 1
परतावा परिणाम
अन्यथा:
StopIteration वाढवा
# चला पिझ्झा बनवूया
my_pizza = पिझ्झा('मोठा', ['पेपेरोनी', 'मशरूम', 'ऑलिव्ह'])
# आणि आता त्यावर पुनरावृत्ती करूया
my_pizza मध्ये टॉपिंगसाठी:
प्रिंट (टॉपिंग)
या प्रकरणात, लूप कॉलसाठी __iter__, जे काउंटर सुरू करते (self.n) आणि पिझ्झा ऑब्जेक्ट स्वतः परत करतो (self).
नंतर, फॉर लूप कॉल __next__ प्रत्येक टॉपिंग आलटून पालटून घेण्यासाठी.
Quando __next__ सर्व मसाले परत केले, StopIteration तो एक अपवाद टाकतो आणि फॉर लूपला आता माहित आहे की आणखी टॉपिंग नाहीत आणि त्यामुळे पुनरावृत्ती प्रक्रिया रद्द होईल.
Ercole Palmeri
नौदल क्षेत्र ही एक खरी जागतिक आर्थिक शक्ती आहे, ज्याने 150 अब्जांच्या बाजारपेठेकडे नेव्हिगेट केले आहे...
गेल्या सोमवारी, फायनान्शिअल टाईम्सने OpenAI सह करार जाहीर केला. FT ने त्याच्या जागतिक दर्जाच्या पत्रकारितेचा परवाना…
लाखो लोक स्ट्रीमिंग सेवांसाठी पैसे देतात, मासिक सदस्यता शुल्क भरतात. असे सामान्य मत आहे की आपण…
Veeam द्वारे Coveware सायबर खंडणी घटना प्रतिसाद सेवा प्रदान करणे सुरू ठेवेल. Coveware फॉरेन्सिक आणि उपाय क्षमता प्रदान करेल…