दिलचस्प पोस्ट
छवि फ़ाइल के लिए ब्राउज़ करें और इसे जावा स्विंग का उपयोग करें Getters और setters / accessors क्यों का उपयोग करें? एसक्यूएल – अप्रत्यक्ष विदेशी कुंजी प्रोजेक्ट के रूट फ़ोल्डर के संबंध में हमेशा नोड। जेएस में क्या आवश्यकता होती है? मैं फ़ायरफ़ॉक्स में एक फ़ाइल इनपुट फ़ील्ड कैसे शैली कर सकता हूं? सीएसएस में फोंट कैसे एम्बेड करें? SQL सर्वर: MAX (DATE) के साथ केवल पंक्तियां चुनें प्रश्न पूछें मोंगोडब में कैसे जुड़ें? पायथन में एक थ्रेड में कॉल किए जाने पर sys.exit () क्यों नहीं निकल जाता? मैं एक सर्वरसेकेट को () विधि को कैसे बाधित कर सकता हूं? PHP का उपयोग करते हुए JSON POST पढ़ना पोस्टग्रेस्क्ल GROUP_CONCAT समकक्ष? उद्देश्य-सी ++ कितनी अच्छी तरह समर्थित है? जावा उपलब्ध स्मृति उपलब्ध है स्टैक को संरेखित करने का क्या अर्थ है?

पायथन कक्षाओं में हम __init__ का उपयोग क्यों करते हैं?

कक्षाओं के प्रारंभ को समझने में मुझे परेशानी हो रही है

उनके बारे में क्या बात है और हम कैसे जानते हैं कि उनमें क्या शामिल है? क्या वर्गों में लिखने के लिए अलग-अलग प्रकार की सोच बनाम फ़ंक्शन बनाने की आवश्यकता होती है (मुझे लगा कि मैं सिर्फ फ़ंक्शन बना सकता हूं और फिर उन्हें कक्षा में लपेटता हूं, इसलिए मैं उनका पुनः उपयोग कर सकता हूं। क्या वह काम करेगा?)

यहां एक उदाहरण है:

class crawler: # Initialize the crawler with the name of database def __init__(self,dbname): self.con=sqlite.connect(dbname) def __del__(self): self.con.close() def dbcommit(self): self.con.commit() 

या किसी अन्य कोड का नमूना:

 class bicluster: def __init__(self,vec,left=None,right=None,distance=0.0,id=None): self.left=left self.right=right self.vec=vec self.id=id self.distance=distance 

अन्य लोगों के कोड को पढ़ने की कोशिश करते समय __init__ साथ इतने सारे वर्ग आते हैं, लेकिन मैं उन्हें बनाने में तर्क को समझ नहीं पाया।

Solutions Collecting From Web of "पायथन कक्षाओं में हम __init__ का उपयोग क्यों करते हैं?"

आपने जो लिखा है, आप समझ का एक महत्वपूर्ण हिस्सा नहीं भूल रहे हैं: एक वर्ग और वस्तु के बीच का अंतर __init__ क्लास को इनिशियलाइज़ नहीं करता है, यह एक क्लास या ऑब्जेक्ट का एक उदाहरण आरंभ करता है। प्रत्येक कुत्ते का रंग होता है, लेकिन कुत्ते को एक वर्ग के रूप में नहीं। प्रत्येक कुत्ते में चार या उससे कम पैर हैं, लेकिन कुत्तों का वर्ग नहीं है वर्ग एक वस्तु का एक अवधारणा है जब आप फिडो और स्पॉट देखते हैं, तो आप उनकी समानता, उनके कुत्तेत्व को पहचानते हैं। यही क्लास है

जब आप कहें

 class Dog: def __init__(self, legs, colour): self.legs = legs self.colour = colour fido = Dog(4, "brown") spot = Dog(3, "mostly yellow") 

आप कह रहे हैं, फिदो 4 भूरे रंग के साथ एक भूरे रंग के कुत्ते हैं जबकि स्पॉट एक अपंग का एक सा है और ज्यादातर पीले रंग का है। __init__ फ़ंक्शन को कन्स्ट्रक्टर या प्रारंभकर्ता कहा जाता है, और जब आप एक क्लास का एक नया उदाहरण बनाते हैं तो इसे स्वचालित रूप से कहा जाता है। उस फ़ंक्शन के भीतर, नव निर्मित ऑब्जेक्ट पैरामीटर self को असाइन किया गया है। संकेतन self.legs एक self.legs में ऑब्जेक्ट के legs कहा जाता है। विशेषताओं की तरह वेरिएबल्स हैं, लेकिन वे एक ऑब्जेक्ट की स्थिति, या ऑब्जेक्ट के लिए उपलब्ध विशेष कार्यों (फ़ंक्शन) का वर्णन करते हैं।

हालांकि, ध्यान दें कि आप अपने लिए कुत्ते के लिए colour सेट नहीं करते हैं – यह एक सार अवधारणा है ऐसे गुण हैं जो वर्गों पर समझ में आते हैं। उदाहरण के लिए, population_size एक ऐसा है- यह फ़िडो को गिनने में कोई मतलब नहीं है क्योंकि फ़िडो हमेशा एक है। यह कुत्तों की गणना करने के लिए समझ में आता है हमें कहना है कि दुनिया में 200 मिलियन कुत्ते हैं। यह कुत्ते वर्ग की संपत्ति है फिदो की 200 मिलियन संख्या के साथ कुछ नहीं करना है, न ही स्पॉट भी है इसे "क्लास एट्रिब्यूट" कहा जाता है, जैसा "इंस्टॉलेशन एट्रिब्यूट्स" के विपरीत है जो कि ऊपर colour या legs हैं।

अब, कुछ कम कुत्ते और अधिक प्रोग्रामिंग से संबंधित जैसा कि मैंने नीचे लिखा है, चीजों को जोड़ने के लिए कक्षा समझदार नहीं है – यह किस वर्ग का है? पायथन में वर्ग अलग-अलग आंकड़ों के संग्रह से बना है, जो इसी तरह व्यवहार करते हैं। कुत्तों की कक्षा में फिदो और स्पॉट और 199 99 99 99 99 99 8 अन्य जानवरों के समान हैं, इनमें से सभी लैंपपोस्टों पर पेश आ रहे हैं। चीजों को जोड़ने के लिए कक्षा क्या शामिल है? उनके द्वारा निहित डेटा क्या अलग है? और वे क्या काम करते हैं?

हालांकि, संख्या … ये अधिक रोचक विषय हैं कहो, इंटीजर्स उनमें से बहुत कुछ है, कुत्ते से बहुत अधिक है मुझे पता है कि पायथन पहले से ही पूर्णांक है, लेकिन हम गूंगा खेलते हैं और उन्हें फिर से लागू करते हैं (धोखाधड़ी और पायथन के पूर्णांकों का उपयोग करके)।

तो, इंटीजर्स एक वर्ग हैं उनके पास कुछ डेटा (मान) है, और कुछ व्यवहार ("मुझे इस दूसरे नंबर पर जोड़ें")। चलिए यह दिखाओ:

 class MyInteger: def __init__(self, newvalue) # imagine self as an index card. # under the heading of "value", we will write # the contents of the variable newvalue. self.value = newvalue def add(self, other): # when an integer wants to add itself to another integer, # we'll take their values and add them together, # then make a new integer with the result value. return MyInteger(self.value + other.value) three = MyInteger(3) # three now contains an object of class MyInteger # three.value is now 3 five = MyInteger(5) # five now contains an object of class MyInteger # five.value is now 5 eight = three.add(five) # here, we invoked the three's behaviour of adding another integer # now, eight.value is three.value + five.value = 3 + 5 = 8 print eight.value # ==> 8 

यह थोड़ी नाजुक है (हम मानते हैं कि other एक माय इंटेगर होंगे), लेकिन हम अब उपेक्षा करेंगे। वास्तविक कोड में, हम नहीं करेंगे; हम यह सुनिश्चित करने के लिए इसका परीक्षण करेंगे, और शायद यह भी मजबूर होना चाहिए ("आप पूर्णांक नहीं हैं, गली से, आपके पास 10 नैनोसेकंड हैं, 9 … 8 ….")

हम भी भिन्न परिभाषित कर सकते हैं अंश भी खुद को कैसे जोड़ना जानते हैं

 class MyFraction: def __init__(self, newnumerator, newdenominator) self.numerator = newnumerator self.denominator = newdenominator # because every fraction is described by these two things def add(self, other): newdenominator = self.denominator * other.denominator newnumerator = self.numerator * other.denominator + self.denominator * other.numerator return MyFraction(newnumerator, newdenominator) 

पूर्णांक की तुलना में और भी अधिक अंश हैं (वास्तव में नहीं, लेकिन कंप्यूटर नहीं जानते हैं कि) चलो दो:

 half = MyFraction(1, 2) third = MyFraction(1, 3) five_sixths = half.add(third) print five_sixths.numerator # ==> 5 print five_sixths.denominator # ==> 6 

आप वास्तव में यहाँ कुछ भी नहीं घोषित कर रहे हैं गुण एक नए प्रकार के चर की तरह हैं। सामान्य चर में केवल एक मान है हम कहते हैं कि आप colour = "grey" लिखते हैं। आपके पास एक अन्य वैरिएबल नाम का colour नहीं हो सकता है जो "fuchsia" – कोड में उसी स्थान पर नहीं।

Arrays एक डिग्री करने के लिए कि हल। यदि आप colour = ["grey", "fuchsia"] , तो आपने दो रंगों को चर में रखा है, लेकिन आप उन्हें उनकी स्थिति (0, या 1, इस मामले में) से अलग कर सकते हैं।

विशेषताओं वेरिएबल्स हैं जो ऑब्जेक्ट के लिए बाध्य हैं। सरणियों के समान, हमारे पास अलग-अलग कुत्तों पर बहुत सारे colour वैरिएबल हो सकते हैं। तो, fido.colour एक चर है, लेकिन spot.colour . spot.colour एक और है पहले एक वस्तु वस्तु के लिए चर के साथ बंधी है; दूसरा, spot । अब, जब आप Dog(4, "brown") या three.add(five) कॉल करते हैं, तो हमेशा एक अदृश्य पैरामीटर होगा, जो पैरामीटर सूची के सामने एक अतिरिक्त three.add(five) को निर्दिष्ट किया जाएगा। इसे पारंपरिक रूप से self कहा जाता है, और वस्तु के मूल्य को डॉट के सामने मिल जाएगा। इस प्रकार, कुत्ते के __init__ (कन्स्ट्रक्टर) के भीतर, self जो कुछ नया कुत्ता निकलता है वह हो जाएगा; MyInteger के add भीतर, self three वस्तुओं में वस्तु के लिए बाध्य होगा इस प्रकार, three.value add भीतर self.value के रूप में एक समान वैरिएबल होगा।

यदि मैं कहता हूं the_mangy_one = fido , मैं एक अन्य नाम के साथ the_mangy_one = fido रूप में जाने वाले वस्तु का संदर्भ देना शुरू करूँगा अब से, fido.colour वास्तव में एक ही चर के रूप में the_mangy_one.colour

तो, __init__ अंदर की चीजें आप उन्हें कुत्ते के जन्म प्रमाण पत्र में चीजों को नोट करने के बारे में सोच सकते हैं। colour स्वयं से एक यादृच्छिक चर है, इसमें कुछ भी शामिल हो सकता है कुत्ते की पहचान पत्र पर एक प्रपत्र क्षेत्र की तरह; और __init__ क्लर्क है जो इसे पहली बार भरने के लिए है।

कोई स्पष्ट?

संपादित करें : नीचे टिप्पणी पर विस्तार करना:

आप वस्तुओं की एक सूची का मतलब है, है ना?

सबसे पहले, fido वास्तव में एक वस्तु नहीं है यह एक वेरिएबल है, जो वर्तमान में एक ऑब्जेक्ट है, जैसा कि आप x = 5 कहते हैं, x एक चर है जो वर्तमान में नंबर पांच वाला है। यदि आप बाद में अपना मन बदल लेते हैं, तो आप fido = Cat(4, "pleasing") (जब तक आप एक कक्षा Cat fido ), और तब से वह "बिल्लियों" को शामिल करता है। यदि आप fido = x , तो इसमें नंबर पांच होता है, और जानवरों की एक वस्तु बिल्कुल नहीं।

एक वर्ग स्वयं अपने उदाहरणों को नहीं जानता है, जब तक कि आप उन पर नज़र रखने के लिए विशेष रूप से कोड लिखते हैं। उदाहरण के लिए:

 class Cat: census = [] #define census array def __init__(self, legs, colour): self.colour = colour self.legs = legs Cat.census.append(self) 

यहां, census , Cat क्लास का क्लास-लेवल विशेषता है।

 fluffy = Cat(4, "white") spark = Cat(4, "fiery") Cat.census # ==> [<__main__.Cat instance at 0x108982cb0>, <__main__.Cat instance at 0x108982e18>] # or something like that 

ध्यान दें कि आप [fluffy, sparky] नहीं मिलेगा वे सिर्फ चर नाम हैं यदि आप बिल्लियों को स्वयं के नाम चाहते हैं, तो आपको नाम के लिए एक अलग विशेषता बनाना होगा, और फिर इस नाम को वापस करने के लिए __str__ पद्धति को ओवरराइड करना होगा। इस पद्धति (अर्थात क्लास-बाउंड फंक्शन, जैसे कि add या __init__ ) उद्देश्य को वर्णन करना है कि ऑब्जेक्ट को स्ट्रिंग में कैसे रूपांतरित करना है, जैसे कि जब आप इसे प्रिंट करते हैं।

Amadan से पूरी तरह से स्पष्टीकरण के लिए अपने 5 सेंट योगदान करने के लिए

जहां कक्षाएं एक तरह से "एक प्रकार का" वर्णन करती हैं वस्तुएं उनकी प्रतीतियां हैं: जीवित साँस लेने की चीज। ऑब्जेक्ट-ओरिएंटेड वर्ल्ड में आप ऐसे प्रमुख विचार कर सकते हैं जो आप लगभग सभी का सार कह सकते हैं। वो हैं:

  1. इनकैप्सुलेशन (इस पर विस्तृत नहीं होगा)
  2. विरासत
  3. बहुरूपता

वस्तुएं एक या अधिक विशेषताओं (= विशेषताओं) और व्यवहार (= तरीके) हैं व्यवहार ज्यादातर विशेषताओं पर निर्भर करता है कक्षाएं यह परिभाषित करती हैं कि व्यवहार को सामान्य तरीके से क्या पूरा करना चाहिए, लेकिन जब तक कक्षा को एक वस्तु के रूप में नहीं माना जाता है, तब तक यह संभावना की एक अमूर्त अवधारणा बनी हुई है। मुझे "विरासत" और "बहुरूपता" की सहायता से वर्णन करें।

  class Human: gender nationality favourite_drink core_characteristic favourite_beverage name age def love def drink def laugh def do_your_special_thing class Americans(Humans) def drink(beverage): if beverage != favourite_drink: print "You call that a drink?" else: print "Great!" class French(Humans) def drink(beverage, cheese): if beverage == favourite_drink and cheese == None: print "No cheese?" elif beverage != favourite_drink and cheese == None: print "Révolution!" class Brazilian(Humans) def do_your_special_thing win_every_soccer_world_cup() class Germans(Humans) def drink(beverage): if favourite_drink != beverage: print "I need more beer" else: print "Lecker!" class HighSchoolStudent(Americans): def __init__(self, name, age): self.name = name self.age = age jeff = HighSchoolStudent(name, age): hans = Germans() ronaldo = Brazilian() amelie = French() for friends in [jeff, hans, ronaldo]: friends.laugh() friends.drink("cola") friends.do_your_special_thing() print amelie.love(jeff) >>> True print ronaldo.love(hans) >>> False 

कुछ विशेषताओं मनुष्य को परिभाषित लेकिन हर राष्ट्रीयता कुछ हद तक अलग है। इसलिए "राष्ट्रीय-प्रकार" किस्म के मनुष्य हैं जो एक्स्ट्रा के साथ हैं। "अमेरिकियों" एक प्रकार का "मनुष्य" हैं और मानवीय प्रकार (बेस-क्लास) से कुछ अमूर्त विशेषताओं और व्यवहारों का उत्तराधिकारी हैं: यह विरासत तो सभी मनुष्य हंसी और पी सकते हैं, इसलिए सभी बाल-वर्ग भी कर सकते हैं! विरासत (2)

लेकिन क्योंकि वे एक ही तरह के हैं (प्रकार / आधार-वर्ग: मनुष्य) आप उन्हें कभी-कभी विनिमय कर सकते हैं: अंत में के लिए लूप देखें। लेकिन वे एक व्यक्तिगत विशेषता का पर्दाफाश करेंगे, और पोलीमॉर्फिज़्म (3) के अनुसार।

इसलिए हर इंसान का पसंदीदा है, लेकिन हर राष्ट्रीयता एक विशेष प्रकार की पेय की ओर पेश करती है। अगर आप मनुष्य के प्रकार से राष्ट्रीयता को उप-वर्ग करते हैं, तो आप अपने उत्तराधिकारी के व्यवहार को ओवरराइट कर सकते हैं, जैसा कि मैंने ऊपर drink() तरीका दिखाया है drink() विधि लेकिन यह अभी भी कक्षा स्तर पर है और इस वजह से यह अभी भी एक सामान्यीकरण है।

 hans = German(favourite_drink = "Cola") 

क्लास जर्मन की शुरुआत करता है और मैं शुरुआत में एक "डिफ़ॉल्ट" विशेषता को बदलता हूं। (लेकिन अगर आप हंस। ड्रिंक ('मिल्क') कहते हैं तो वह अभी भी "मुझे अधिक बीयर की आवश्यकता होगी" – एक स्पष्ट बग … या शायद यही कि मैं एक फीचर कहता हूं अगर मैं एक बड़ी कंपनी का कर्मचारी हूं। ;-)! )

एक प्रकार की विशेषता जैसे जर्मन (हंस) प्रायः तत्काल के समय में निर्माता के माध्यम से परिभाषित की जाती है (अजगर में: __init__ ) यह वह बिंदु है जहां आप एक वस्तु बनने के लिए एक वस्तु परिभाषित करते हैं। आप एक विशिष्ट अवधारणा (कक्षा) में सांस जीवन को व्यक्तिगत विशेषताओं के साथ भरकर और एक वस्तु बनने के लिए कह सकते हैं।

लेकिन क्योंकि हर ऑब्जेक्ट एक क्लास का उदाहरण है, वे सभी कुछ बुनियादी विशेषता-प्रकार और कुछ व्यवहार साझा करते हैं। यह वस्तु-उन्मुख अवधारणा का एक बड़ा लाभ है

प्रत्येक ऑब्जेक्ट की उन विशेषताओं को संरक्षित करने के लिए जिन्हें आप उन्हें समझाते हैं – इसका अर्थ है कि आप दो व्यवहार और विशेषता की कोशिश करते हैं और इसे ऑब्जेक्ट के बाहर से हेरफेर करने के लिए कठिन बनाते हैं। वह है एन्कैप्सुलेशन (1)

यह उदाहरण के चर को प्रारंभ करने के लिए है

उदाहरण एक विशिष्ट डेटाबेस नाम के साथ crawler एक उदाहरण बनाएं (ऊपर आपके उदाहरण से)।

कक्षाएं विशेषताओं (राज्य, विशेषता) और विधियों (कार्य, क्षमता) के साथ वस्तुएं होती हैं जो उस ऑब्जेक्ट के लिए विशिष्ट होती हैं (जैसे कि सफेद रंग और मक्खी की शक्ति, क्रमशः बतख के लिए)।

जब आप एक वर्ग का एक उदाहरण बनाते हैं, तो आप इसे कुछ शुरुआती व्यक्तित्व (एक नवजात शिशु के नाम और उसके कपड़े का रंग जैसे राज्य या चरित्र) दे सकते हैं। आप __init__ साथ ऐसा करते हैं

मूल रूप से instance = MyClass(some_individual_traits) स्वचालित रूप से instance = MyClass(some_individual_traits) स्वचालित रूप से सेट करता है जब आप instance = MyClass(some_individual_traits) कॉल करते हैं – instance = MyClass(some_individual_traits)

__init__ फ़ंक्शन कक्षा में सभी सदस्य चर की स्थापना कर रहा है। तो एक बार आपका बिकोलस्टर बनाया गया है, तो आप सदस्य का उपयोग कर सकते हैं और वापस मूल्य प्राप्त कर सकते हैं:

 mycluster = bicluster(...actual values go here...) mycluster.left # returns the value passed in as 'left' 

कुछ जानकारी के लिए पायथन डॉक्स देखें सीखने को जारी रखने के लिए आप ओ ओ अवधारणाओं पर एक पुस्तक चुनना चाहेंगे।

आपकी कार के उदाहरण के साथ: जब आप एक कार लेते हैं, तो आपको यादृच्छिक कार नहीं मिलती, मेरा मतलब है, आप रंग चुनते हैं, ब्रांड, सीटों की संख्या आदि। और कुछ चीज़ें आपके चयन के बिना भी "आरंभ" इसके लिए, पहियों या पंजीकरण संख्या की संख्या की तरह

 class Car: def __init__(self, color, brand, number_of_seats): self.color = color self.brand = brand self.number_of_seats = number_of_seats self.number_of_wheels = 4 self.registration_number = GenerateRegistrationNumber() 

इसलिए, __init__ विधि में आप जिस उदाहरण का निर्माण कर रहे हैं उसके गुण को परिभाषित करते हैं। इसलिए, यदि हम 2 लोगों के लिए नीली रेनॉल्ट कार चाहते हैं, तो हम शुरूआत या Car तरह शुरू करेंगे:

 my_car = Car('blue', 'Renault', 2) 

इस तरह, हम Car वर्ग का एक उदाहरण बना रहे हैं। __init__ वह एक है जो हमारे विशिष्ट विशेषताओं (जैसे color या brand ) को संभाल रहा है और इसकी अन्य विशेषताओं जैसे registration_number उत्पन्न करना है।

  • पायथन में कक्षाओं के बारे में अधिक
  • __init__ विधि के बारे में अधिक

ऐसा लगता है कि आपको पायथन में __init__ का उपयोग करने की आवश्यकता है अगर आप अपने उदाहरणों के अयोग्य गुणों को सही ढंग से प्रारंभ करना चाहते हैं।

निम्न उदाहरण देखें:

 >>> class EvilTest(object): ... attr = [] ... >>> evil_test1 = EvilTest() >>> evil_test2 = EvilTest() >>> evil_test1.attr.append('strange') >>> >>> print "This is evil:", evil_test1.attr, evil_test2.attr This is evil: ['strange'] ['strange'] >>> >>> >>> class GoodTest(object): ... def __init__(self): ... self.attr = [] ... >>> good_test1 = GoodTest() >>> good_test2 = GoodTest() >>> good_test1.attr.append('strange') >>> >>> print "This is good:", good_test1.attr, good_test2.attr This is good: ['strange'] [] 

यह जावा में काफी अलग है, जहां प्रत्येक विशेषता को एक नए मान के साथ स्वतः आरंभ किया जाता है:

 import java.util.ArrayList; import java.lang.String; class SimpleTest { public ArrayList<String> attr = new ArrayList<String>(); } class Main { public static void main(String [] args) { SimpleTest t1 = new SimpleTest(); SimpleTest t2 = new SimpleTest(); t1.attr.add("strange"); System.out.println(t1.attr + " " + t2.attr); } } 

एक उत्पादन का उत्पादन करता है जो हम सहज रूप से उम्मीद करते हैं:

 [strange] [] 

लेकिन अगर आप attr को static रूप में घोषित करते हैं, तो यह पायथन की तरह कार्य करेगा:

 [strange] [strange] 

कक्षा कुत्ता (ऑब्जेक्ट):

 # Class Object Attribute species = 'mammal' def __init__(self,breed,name): self.breed = breed self.name = name 

उपरोक्त उदाहरण में हम एक वैश्विक रूप से प्रजाति का उपयोग करते हैं क्योंकि यह हमेशा एक समान होता है (आप निरंतर कह सकते हैं)। जब आप init विधि कहते हैं तो इनटी अंदर सभी चर शुरू हो जाएंगे (उदाहरण: नस्ल, नाम)।

कक्षा कुत्ता (ऑब्जेक्ट): ए = '12'

 def __init__(self,breed,name,a): self.breed = breed self.name = name self.a= a 

अगर आप नीचे दिए गए उदाहरण को इस तरह से कॉल करके प्रिंट करते हैं

कुत्ते। 12

डॉग ('लैब', 'सैम', '10') कुत्ते। 10

इसका मतलब है कि यह केवल ऑब्जेक्ट सृजन के दौरान आरंभ किया जाएगा। तो जो कुछ भी आप निरंतर बोलना चाहते हैं वह इसे वैश्विक रूप में बनाते हैं और जो कुछ भी प्रयोग में परिवर्तन करता है