वेरिएबल्स पास करना, उदाहरण बनाना, स्वयं, मैकेनिक्स और कक्षाओं के उपयोग: स्पष्टीकरण की आवश्यकता है

Question

मैं पूरे दिन इस पर बैठा हूं और मैं पहले से थोड़ा थक गया हूं इसलिए कृपया मुझे संक्षिप्त होने का क्षमा करें।

आईएम नया पाइथन।

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

सबसे पहले, वर्ग के __init__ खंड में मैं self.variable=something साथ चर का एक गुच्छा घोषित किया है।

क्या यह सही है कि मुझे उस समारोह में self.variable का उपयोग करके कक्षा के प्रत्येक कार्य में इन चरों को एक्सेस/संशोधित करने में सक्षम होना चाहिए? दूसरे शब्दों में, self.variable घोषित करके मैंने कक्षाओं के दायरे में इन चर, वैश्विक चर बनाए हैं?

यदि नहीं, तो मैं स्वयं को कैसे संभाला?

दूसरा, मैं कक्षा में तर्क सही तरीके से कैसे पास करूं? कुछ उदाहरण कोड शांत होगा।

तीसरा, मैं वर्ग के दायरे के बाहर कक्षा का एक फ़ंक्शन कैसे कॉल करूं? कुछ उदाहरण कोड शांत होगा।

Fouthly, मैं कैसे एक और class OTHERCLASS में class INITIALCLASS का एक उदाहरण बना सकता हूँ, INITIALCLASS को OTHERCLASS से चर गुजर? कुछ उदाहरण कोड शांत होगा।

मैं से INITIALCLASS से तर्कों के साथ एक फ़ंक्शन कॉल करना चाहता हूं। मैंने अभी तक क्या किया है।

class OTHERCLASS(): 
    def __init__(self,variable1,variable2,variable3): 
     self.variable1=variable1 
     self.variable2=variable2 
     self.variable3=variable3 
    def someotherfunction(self): 
     something=somecode(using self.variable3) 
     self.variable2.append(something) 
     print self.variable2 
    def somemorefunctions(self): 
     self.variable2.append(variable1) 

class INITIALCLASS(): 
    def __init__(self): 
     self.variable1=value1 
     self.variable2=[] 
     self.variable3='' 
     self.DoIt=OTHERCLASS(variable1,variable2,variable3) 

    def somefunction(self): 
     variable3=Somecode 
     #tried this 
     self.DoIt.someotherfunctions() 
     #and this 
     DoIt.someotherfunctions() 

मैं स्पष्ट रूप से समझ में नहीं आया कि कैसे वर्ग या कैसे self, जब यह उपयोग करने के लिए और जब संभाल करने नहीं करने के लिए चर पारित करने के लिए। मुझे शायद यह भी समझ में नहीं आया कि कक्षा के उदाहरण को सही तरीके से कैसे बनाया जाए। आम तौर पर मुझे कक्षाओं के यांत्रिकी को समझ में नहीं आया, इसलिए कृपया मेरी मदद करें और मुझे यह समझाएं जैसे मुझे कोई जानकारी नहीं है (जो मुझे नहीं लगता है)। या मुझे एक पूरी तरह से वीडियो, या पठनीय ट्यूटोरियल के लिए इंगित करें।

वेब पर जो कुछ भी मिलता है वह सुपर सरल उदाहरण है, जिसने मुझे बहुत मदद नहीं की। या कक्षाओं और कक्षा विधियों के उदाहरणों की बहुत छोटी परिभाषाएं आदि

यदि आप लोग चाहते हैं तो मैं आपको अपना मूल कोड भेज सकता हूं, लेकिन यह काफी लंबा है।

Answer 1

class Foo   (object): 
    # ^class name #^ inherits from object 

    bar = "Bar" #Class attribute. 

    def __init__(self): 
     #  #^ The first variable is the class instance in methods. 
     #  # This is called "self" by convention, but could be any name you want. 
     #^ double underscore (dunder) methods are usually special. This one 
     # gets called immediately after a new instance is created. 

     self.variable = "Foo" #instance attribute. 
     print self.variable, self.bar #<---self.bar references class attribute 
     self.bar = " Bar is now Baz" #<---self.bar is now an instance attribute 
     print self.variable, self.bar 

    def method(self, arg1, arg2): 
     #This method has arguments. You would call it like this: instance.method(1, 2) 
     print "in method (args):", arg1, arg2 
     print "in method (attributes):", self.variable, self.bar 


a = Foo() # this calls __init__ (indirectly), output: 
       # Foo bar 
       # Foo Bar is now Baz 
print a.variable # Foo 
a.variable = "bar" 
a.method(1, 2) # output: 
       # in method (args): 1 2 
       # in method (attributes): bar Bar is now Baz 
Foo.method(a, 1, 2) #<--- Same as a.method(1, 2). This makes it a little more explicit what the argument "self" actually is. 

class Bar(object): 
    def __init__(self, arg): 
     self.arg = arg 
     self.Foo = Foo() 

b = Bar(a) 
b.arg.variable = "something" 
print a.variable # something 
print b.Foo.variable # Foo 

Answer 2

एक वर्ग के पूरे मुद्दे है कि आप एक उदाहरण बनाना है, और है कि उदाहरण के डेटा का एक सेट समाहित। तो यह कहना गलत है कि कक्षाओं के दायरे में आपके चर वैश्विक हैं: इसके बजाय एक उदाहरण विशेषताएँ रखता है, और वह उदाहरण इसके किसी भी कोड (self.whatever के माध्यम से) में अपने गुणों का उल्लेख कर सकता है। इसी तरह, किसी भी अन्य कोड को एक उदाहरण दिया गया है, उदाहरण के गुणों तक पहुंचने के लिए उस उदाहरण का उपयोग कर सकता है - यानी instance.whatever।

Answer 3

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

class bankaccount(): 
    def __init__(self, name, money): 
     self.name = name 
     self.money = money 

    def earn_money(self, amount): 
     self.money += amount 

    def withdraw_money(self, amount): 
     self.money -= amount 

    def show_balance(self): 
     print self.money 

अब आपके पास एक साधारण खाते और इसकी तंत्र का एक सार मॉडल है। def __init__(self, name, money) कक्षाओं का निर्माता है। यह वस्तु को स्मृति में बनाता है। यदि अब आप एक नया खाता खोलना चाहते हैं तो आपको अपनी कक्षा का उदाहरण देना होगा। ऐसा करने के लिए, आपको कन्स्ट्रक्टर को कॉल करना होगा और आवश्यक पैरामीटर को पास करना होगा। अजगर में एक निर्माता वर्गों के नाम से पुकारा जाता है:

spidermans_account = bankaccount("SpiderMan", 1000) 

स्पाइडरमैन एम जे एक नई अंगूठी वह कुछ पैसे निकालने के लिए है खरीदना चाहता है। वह अपने अकाउंट withdraw विधि कहेंगे:

spidermans_account.withdraw_money(100) 

वह संतुलन वह कहता है देखना चाहता है:

spidermans_account.show_balance() 

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