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

Question

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

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

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

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__अन्य लोगों के कोड को पढ़ने की कोशिश करने पर मुझे बहुत सारी कक्षाएं आती हैं, लेकिन मैं उन्हें बनाने में तर्क नहीं समझता।

Comments

init की कहानी है ... blah, blah, blah .... कंस्ट्रक्टर-डिस्ट्रॉक्टर लेकिन कोई डिस्ट्रक्टर नहीं क्योंकि कचरा संग्रह उपलब्ध है।

— मिस्टर जीकी

Answer 1

आपने जो लिखा है, आप एक महत्वपूर्ण समझ को याद कर रहे हैं: एक वर्ग और एक वस्तु के बीच का अंतर। __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एक विशेषता है जिसे legsचर में वस्तु कहा जाता है self। विशेषताएँ तरह तरह के चर हैं, लेकिन वे किसी वस्तु की स्थिति या वस्तु के लिए उपलब्ध विशेष क्रियाओं (कार्यों) का वर्णन करते हैं।

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

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

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

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

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

यह थोड़ा नाजुक है (हम मान रहे हैं कि यह otherMyInteger होगा), लेकिन अब हम इसे अनदेखा कर देंगे। वास्तविक कोड में, हम नहीं करेंगे; हम इसे सुनिश्चित करने के लिए परीक्षण करेंगे, और हो सकता है कि इसे ज़ब्त भी करें ("आप एक पूर्णांक नहीं हैं; उल्लास से, आपके पास एक बनने के लिए 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"- कोड में एक ही स्थान पर नहीं है।

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

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

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

तो, अंदर की बातें __init__। आप उन्हें डॉग के जन्म प्रमाण पत्र में ध्यान देने योग्य बातें समझ सकते हैं। colourअपने आप में एक यादृच्छिक चर है, इसमें कुछ भी हो सकता है। fido.colourया self.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__) उद्देश्य यह वर्णन करना है कि ऑब्जेक्ट को स्ट्रिंग में कैसे परिवर्तित किया जाए, जैसे कि आप इसे प्रिंट करते हैं।

Comments

वाह धन्यवाद..तो वास्तव में मेरे लिए बहुत कुछ समझ में आता है जिससे कुछ ऐसा होता है जो मुझे लगता है, मुझे इनिट फ़ंक्शन में पूर्व-घोषणा करने की आवश्यकता है। इस मामले में, डॉग के पैर और रंग हैं। उदाहरण के लिए, यदि मैंने एक वर्ग बनाया है जिसमें दो नंबर जोड़े गए हैं, तो मैं स्वयं की घोषणा करूंगा। उत्तर और उत्तर पाने के लिए कक्षा में पहले onnumber + secondnumber करें, उसके बाद बस firstnumber + secondnumber करें?

— लॉस्टसॉल

एक प्रकार का। आप ऐसा कर सकते हैं। लेकिन यह केवल चीजों को जोड़ने के लिए एक वर्ग बनाने के लिए शायद ही समझ में आता है। कक्षाएं सामान्य रूप से व्यवहार के साथ डेटा को लागू करती हैं - शुद्ध व्यवहार केवल कार्य हैं। मैं कुछ प्रासंगिक के साथ उत्तर का विस्तार करूंगा; थोड़ा इंतजार करें।

— आमदन

अद्भुत जवाब के लिए धन्यवाद। मैं अब कक्षाओं की शक्ति को देखता और समझता हूं। क्षमा करें, अगर यह गूंगा लगता है। आप बस मुझे महसूस करते हैं कि मैं डेटा को सॉर्ट कर सकता हूं और एक साथ कई अलग-अलग चीजों की स्थिति को बनाए रख सकता हूं (जबकि मैं केवल कई चर के रूप में ट्रैक करूंगा क्योंकि मैं लूप के माध्यम से बना सकता हूं या अधिक कर सकता हूं)। तो कहते हैं, मुझे प्रति कुत्ते की औसत संख्या का पता लगाने की आवश्यकता है? क्या उन सभी वस्तुओं की एक सूची प्राप्त करने का एक तरीका है जो मैंने एक वर्ग के साथ बनाया है ताकि मैं इस तरह से एक कैलेंडर शुरू कर सकूं? या मुझे उन कक्षाओं की एक सूची बनाए रखनी चाहिए जो मैं बनाता हूं (यानी [

— फ़िडो

Answer 2

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

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

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

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

    class Human:
        gender
        nationality
        favorite_drink
        core_characteristic
        favorite_beverage
        name
        age

        def love    
        def drink
        def laugh
        def do_your_special_thing                

    class Americans(Humans)
        def drink(beverage):
            if beverage != favorite_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_football_world_cup()

    class Germans(Humans)
        def drink(beverage):
            if favorite_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)।

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

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

hans = German(favorite_drink = "Cola")

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

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

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

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

Answer 3

यह सिर्फ इंस्टेंस के वेरिएबल्स को इनिशियलाइज़ करना है।

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

Comments

मुझे क्षमा करें, मुझे वास्तव में समझ में नहीं आया कि इसका क्या अर्थ है। ऊपर दिए गए उदाहरण..क्योंकि डेवलपर ने अपने मुख्य कोड 'लेफ्ट = फ़ू', आदि में नहीं जोड़ा है ..

— लॉस्टसूल

आप फ़ंक्शन के डिफ़ॉल्ट मानों का मतलब है? यदि पैरामीटर निर्दिष्ट नहीं left=Noneकिया गया है, Noneतो बाएं को आरंभिक किया जाएगा left।

— वृद्धावस्था

मुझे लगता है कि इसका अर्थ समझ में आने लगा है। क्या यह पसंद है कि आपको जावा "स्ट्रिंग लेफ्ट" या कुछ और में अपने वेरिएबल्स को पूर्वनिर्धारित करना होगा? फिर एक बार कक्षा में इसकी शुरुआत करने के बाद, आप मूल्यों में हेरफेर कर सकते हैं? कार्यों की तुलना में इसका थोड़ा सा भ्रमित होना क्योंकि मैं केवल फ़ंक्शन को मान भेज सकता हूं और अग्रिम में कुछ भी आरंभ करने की आवश्यकता नहीं है।

— लॉस्टसॉल

@ लॉस्टौल: left = fooकाम करेगा - एक बार। वर्गों की बात हर अलग के लिए कुछ समझदार करने की है crawler। कक्षाएं फ़ंक्शंस नहीं हैं, न ही कुछ ऐसा जो फ़ंक्शंस की तुलना कर सकता है (ठीक है, तब तक जब तक आप बहुत अधिक उन्नत नहीं हो जाते और कार्यात्मक प्रोग्रामिंग में नहीं मिल जाते, लेकिन यह आपको अभी भ्रमित करेगा)। वास्तव में कौन सी कक्षाएं हैं, इसके लिए मेरा उत्तर पढ़ें - आप अभी भी इसे प्राप्त नहीं कर रहे हैं।

— आमदन

Answer 4

ऐसा लगता है जैसे आपको __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]

Answer 5

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

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__

Answer 6

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

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

__init__जब आप कॉल करते हैं तो मूल रूप से इंस्टेंस विशेषताओं को स्वचालित रूप से सेट करता है instance = MyClass(some_individual_traits)।

Answer 7

__init__समारोह कक्षा में सभी सदस्य चर स्थापित कर रही है। इसलिए एक बार आपका बाइकलर बनने के बाद आप सदस्य तक पहुँच सकते हैं और एक मूल्य वापस पा सकते हैं:

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

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

Answer 8

class Dog(object):

    # Class Object Attribute
    species = 'mammal'

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

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

class Dog(object):
    a = '12'

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

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

Dog.a
12

Dog('Lab','Sam','10')
Dog.a
10

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