मैं पायथन प्रोग्रामिंग भाषा सीख रहा हूं और मुझे कुछ समझ में नहीं आया है।
एक विधि की तरह:
def method(self, blah):
def __init__(?):
....
....क्या करता selfहै? इसका क्या मतलब है? क्या यह अनिवार्य है?
__init__विधि क्या करती है? क्यों जरूरी है? (आदि।)
मुझे लगता है कि वे OOP निर्माण हो सकते हैं, लेकिन मैं बहुत ज्यादा नहीं जानता।
जवाबों:
इस कोड में:
class A(object):
def __init__(self):
self.x = 'Hello'
def method_a(self, foo):
print self.x + ' ' + foo... selfचर वस्तु के उदाहरण का प्रतिनिधित्व करता है। अधिकांश ऑब्जेक्ट-ओरिएंटेड भाषाएं एक ऑब्जेक्ट पर परिभाषित तरीकों के लिए एक छिपे हुए पैरामीटर के रूप में इसे पारित करती हैं; अजगर नहीं करता है। आपको इसे स्पष्ट रूप से घोषित करना होगा। जब आप Aकक्षा का एक उदाहरण बनाते हैं और इसके तरीकों को कहते हैं, तो यह स्वचालित रूप से पारित हो जाएगा, जैसा कि ...
a = A() # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument__init__विधि क्या अजगर में एक निर्माता का प्रतिनिधित्व करता है मोटे तौर पर है। जब आप A()पायथन को कॉल करते हैं तो आपके लिए एक ऑब्जेक्ट बनाता है, और इसे __init__विधि के पहले पैरामीटर के रूप में पास करता है । किसी भी अतिरिक्त पैरामीटर (जैसे A(24, 'Hello')) को भी तर्क के रूप में पारित किया जाएगा - इस मामले में एक अपवाद के कारण, क्योंकि निर्माणकर्ता उनसे उम्मीद नहीं कर रहा है।
A.xया के माध्यम से उपलब्ध है a.x। ध्यान दें कि एक विशिष्ट वर्ग पर इसे ओवरराइड करने से आधार प्रभावित नहीं होगा, इसलिए तब A.x = 'foo'; a.x = 'bar'; print a.x; print A.xप्रिंट होगाbarfoo
self, यह सिर्फ सम्मेलन द्वारा है।
objectवर्ग घोषणा में? मैंने देखा है कि कुछ वर्गों के पास यह है और कुछ नहीं है
objectक्योंकि यह डिफ़ॉल्ट रूप से होता है।
हाँ, आप सही हैं, ये ऊप निर्माण हैं।
__init__एक वर्ग के लिए निर्माता है। selfपैरामीटर (जैसे वस्तु के उदाहरण को संदर्भित करता है thisC ++)।
class Point:
def __init__(self, x, y):
self._x = x
self._y = y__init__विधि कहा जाता हो जाता है जब वस्तु के लिए स्मृति आवंटित किया जाता है:
x = Point(1,2)selfयदि आप ऑब्जेक्ट के साथ मान को बनाए रखना चाहते हैं, तो ऑब्जेक्ट की विधि के अंदर पैरामीटर का उपयोग करना महत्वपूर्ण है । यदि, उदाहरण के लिए, आप __init__इस तरह विधि लागू करते हैं :
class Point:
def __init__(self, x, y):
_x = x
_y = yआपके xऔर yपैरामीटर को स्टैक पर वेरिएबल्स में संग्रहीत किया जाएगा और जब इनिट विधि कार्यक्षेत्र से बाहर हो जाएगी, तो उसे छोड़ दिया जाएगा। उन चरों को सेट करना self._xऔर self._yउन चरों को Pointऑब्जेक्ट के सदस्यों के रूप में सेट करना (ऑब्जेक्ट के जीवनकाल के लिए सुलभ)।
selfकंस्ट्रक्टर में क्यों नहीं होना चाहते हैं ? आपको इसे निर्दिष्ट करने की भी क्या आवश्यकता है, क्या यह बेहतर नहीं होता अगर इसे निहित किया जाता?
इस उम्मीद में कि यह थोड़ा मदद कर सकता है, यहाँ एक सरल उदाहरण है कि मैं एक वर्ग के अंदर घोषित एक चर के बीच के अंतर को समझता था, और एक __init__फ़ंक्शन के अंदर घोषित एक चर :
class MyClass(object):
i = 123
def __init__(self):
self.i = 345
a = MyClass()
print(a.i)
print(MyClass.i)आउटपुट:
345
123__init__जाता है वह वर्ग के उदाहरणों के लिए पास हो जाता है , न कि कक्षा के 'स्थिर' चर का, जिसका नाम समान है ...
संक्षेप में:
selfजैसा कि यह सुझाव देता है, स्वयं को संदर्भित करता है - जिस वस्तु ने विधि को बुलाया है। यही है, अगर आपके पास विधि को कॉल करने वाली एन ऑब्जेक्ट्स हैं, तोself.a एन ऑब्जेक्ट्स में से प्रत्येक के लिए चर के एक अलग उदाहरण का उल्लेख करेंगे। aप्रत्येक वस्तु के लिए चर की एन प्रतियों की कल्पना करें__init__इसे अन्य OOP भाषाओं में एक निर्माता के रूप में कहा जाता है जैसे C ++ / Java। मूल विचार यह है कि यह एक विशेष विधि है जिसे स्वचालित रूप से कहा जाता है जब उस कक्षा का एक ऑब्जेक्ट बनाया जाता है__init__एक निर्माता की तरह काम करता है। यदि आप चाहते हैं कि आप उन्हें गैर-स्टैटिक विधियों के रूप में व्यवहार करने के लिए पहले तर्क के रूप में किसी भी कक्षा के कार्यों में "स्व" पास करने की आवश्यकता है। "स्व" आपकी कक्षा के लिए उदाहरण चर हैं।
इस कोड को आज़माएं। आशा है कि यह मेरे जैसे कई C प्रोग्रामर को Py सीखने में मदद करता है।
#! /usr/bin/python2
class Person:
'''Doc - Inside Class '''
def __init__(self, name):
'''Doc - __init__ Constructor'''
self.n_name = name
def show(self, n1, n2):
'''Doc - Inside Show'''
print self.n_name
print 'Sum = ', (n1 + n2)
def __del__(self):
print 'Destructor Deleting object - ', self.n_name
p=Person('Jay')
p.show(2, 3)
print p.__doc__
print p.__init__.__doc__
print p.show.__doc__आउटपुट:
Jay
Sum = 5
Doc - Inside Class
Doc - __init__ Constructor
Doc - Inside Show
Destructor Deleting object - Jay
विशेषता संदर्भ पायथन में सभी विशेषता संदर्भों के लिए उपयोग किए गए मानक सिंटैक्स का उपयोग करते हैं: obj.name। मान्य विशेषता नाम वे सभी नाम हैं जो कक्षा के नामस्थान में तब थे जब क्लास ऑब्जेक्ट बनाया गया था। तो, अगर वर्ग परिभाषा इस तरह दिखती है:
class MyClass:
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'फिर MyClass.iऔर MyClass.fमान्य विशेषता संदर्भ हैं, क्रमशः एक पूर्णांक और एक फ़ंक्शन ऑब्जेक्ट लौटाते हैं। वर्ग विशेषताओं को भी सौंपा जा सकता है, इसलिए आप MyClass.iअसाइनमेंट के मूल्य को बदल सकते हैं । __doc__एक मान्य विशेषता भी है, वर्ग से संबंधित डॉकस्ट्रिंग को वापस करना: "एक सरल उदाहरण वर्ग"।
क्लास इंस्टेंटेशन फंक्शन नोटेशन का उपयोग करता है। बस बहाना है कि क्लास ऑब्जेक्ट एक पैरामीटर रहित फ़ंक्शन है जो क्लास का एक नया उदाहरण देता है। उदाहरण के लिए:
x = MyClass()इन्स्टेन्शियशन आपरेशन ( "को" एक वर्ग वस्तु) एक खाली वस्तु बनाता है। कई वर्ग एक विशिष्ट प्रारंभिक अवस्था में अनुकूलित उदाहरणों के साथ ऑब्जेक्ट बनाना पसंद करते हैं। इसलिए एक वर्ग __init__()इस तरह नामित एक विशेष विधि को परिभाषित कर सकता है :
def __init__(self):
self.data = []जब कोई वर्ग किसी __init__()विधि को परिभाषित करता है , तो क्लास-इंस्टेंटेशन स्वचालित रूप __init__()से नव-निर्मित क्लास इंस्टेंस के लिए आमंत्रित करता है । तो इस उदाहरण में, एक नया, प्रारंभिक उदाहरण प्राप्त किया जा सकता है:
x = MyClass()बेशक, __init__()विधि में अधिक लचीलेपन के लिए तर्क हो सकते हैं। उस स्थिति में, क्लास इंस्टेंटिएशन ऑपरेटर को दिए गए तर्कों को पारित कर दिया जाता है __init__()। उदाहरण के लिए,
class Complex:
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
x = Complex(3.0, -4.5)
x.r, x.iआधिकारिक दस्तावेज से लिया गया , जिसने मुझे अंत में सबसे अधिक मदद की।
class Bill():
def __init__(self,apples,figs,dates):
self.apples = apples
self.figs = figs
self.dates = dates
self.bill = apples + figs + dates
print ("Buy",self.apples,"apples", self.figs,"figs
and",self.dates,"dates.
Total fruitty bill is",self.bill," pieces of fruit :)")जब आप वर्ग विधेयक का उदाहरण बनाते हैं:
purchase = Bill(5,6,7)आपको मिला:
> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18 pieces of
> fruit :)इससे खुद को परेशान नहीं करना पड़ा। यहां तक कि जवाब पढ़ने के बाद भी।
__init__स्वयं को समझने के लिए आपको जिस विधि की आवश्यकता है उसे ठीक से समझने के लिए ।
स्व पैरामीटर
__init__विधि द्वारा स्वीकार किए गए तर्क हैं:
def __init__(self, arg1, arg2):लेकिन हम वास्तव में इसे केवल दो तर्क देते हैं:
instance = OurClass('arg1', 'arg2')अतिरिक्त तर्क कहां से आया है?
जब हम किसी वस्तु की विशेषताओं का उपयोग करते हैं तो हम इसे नाम से (या संदर्भ द्वारा) करते हैं। यहाँ उदाहरण हमारी नई वस्तु का संदर्भ है। हम inst.printargs का उपयोग करते हुए इंस्टेंस ऑब्जेक्ट के प्रिंटार्ग्स विधि तक पहुंचते हैं।
ऑब्जेक्ट की विशेषताओं को एक्सेस करने के लिए __init__विधि के भीतर हमें ऑब्जेक्ट के संदर्भ की आवश्यकता होती है।
जब भी किसी विधि को कहा जाता है, मुख्य तर्क का एक संदर्भ पहले तर्क के रूप में पारित किया जाता है। अधिवेशन द्वारा आप हमेशा अपने तरीकों के लिए इस पहले तर्क को स्व।
इसका मतलब यह है कि __init__हम क्या कर सकते हैं:
self.arg1 = arg1
self.arg2 = arg2यहां हम ऑब्जेक्ट पर विशेषता सेट कर रहे हैं। आप निम्न कार्य करके इसे सत्यापित कर सकते हैं:
instance = OurClass('arg1', 'arg2')
print instance.arg1
arg1इस तरह के मूल्यों को ऑब्जेक्ट विशेषताओं के रूप में जाना जाता है। यहाँ __init__विधि उदाहरण के arg1 और arg2 विशेषताओं को सेट करती है।
स्रोत: http://www.voidspace.org.uk/python/articles/OOP.shtml#the-init-modod
ध्यान दें कि selfवास्तव में कोई भी मान्य अजगर पहचानकर्ता हो सकता है। उदाहरण के लिए, हम क्रिस बी के उदाहरण से आसानी से लिख सकते हैं:
class A(object):
def __init__(foo):
foo.x = 'Hello'
def method_a(bar, foo):
print bar.x + ' ' + fooऔर यह ठीक उसी तरह काम करेगा। हालांकि यह स्वयं का उपयोग करने के लिए अनुशंसित है क्योंकि अन्य अजगर इसे और अधिक आसानी से पहचान लेंगे।
मूल रूप से, आपको एक ही वर्ग में कई कार्यों में एक चर का उपयोग करते समय 'स्व' कीवर्ड का उपयोग करने की आवश्यकता होती है। के रूप में init , यह बैठाना सेटअप डिफ़ॉल्ट मानों के लिए प्रयोग किया जाता है कि वर्ग के भीतर से कोई अन्य कार्य कहा जाता है।
__init__मूल रूप से एक फ़ंक्शन है जो एक विशिष्ट ऑब्जेक्ट के लिए वर्ग के गुणों को "इनिशियलाइज़" / "सक्रिय" करेगा, एक बार संबंधित वर्ग के लिए बनाया और मिलान किया जाएगा।self उस वस्तु का प्रतिनिधित्व करता है जो उन गुणों को विरासत में देगी।'स्व' वर्ग उदाहरण के लिए एक संदर्भ है
class foo:
def bar(self):
print "hi"अब हम फू का एक उदाहरण बना सकते हैं और उस पर विधि को कॉल कर सकते हैं, इस मामले में पायथन द्वारा स्व पैरामीटर जोड़ा जाता है:
f = foo()
f.bar()लेकिन इसे पास भी किया जा सकता है यदि विधि कॉल वर्ग के उदाहरण के संदर्भ में नहीं है, तो नीचे दिया गया कोड समान कार्य करता है
f = foo()
foo.bar(f)दिलचस्प है कि चर नाम 'स्व' सिर्फ एक सम्मेलन है। नीचे दी गई परिभाषा बिल्कुल उसी तरह काम करेगी .. जिसमें कहा गया है कि यह बहुत मजबूत सम्मेलन है जिसका हमेशा पालन किया जाना चाहिए , लेकिन यह भाषा के लचीले स्वभाव के बारे में कुछ कहता है
class foo:
def bar(s):
print "hi"s) अजगर का लचीलापन दिखा रहा था।
सवाल के लिए सिर्फ एक डेमो।
class MyClass:
def __init__(self):
print('__init__ is the constructor for a class')
def __del__(self):
print('__del__ is the destructor for a class')
def __enter__(self):
print('__enter__ is for context manager')
return self
def __exit__(self, exc_type, exc_value, traceback):
print('__exit__ is for context manager')
def greeting(self):
print('hello python')
if __name__ == '__main__':
with MyClass() as mycls:
mycls.greeting()$ python3 class.objects_instantiation.py
__init__ is the constructor for a class
__enter__ is for context manager
hello python
__exit__ is for context manager
__del__ is the destructor for a classइस कोड में:
class Cat:
def __init__(self, name):
self.name = name
def info(self):
print 'I am a cat and I am called', self.nameयहां __init__क्लास के लिए एक कंस्ट्रक्टर के रूप में कार्य किया जाता है और जब किसी ऑब्जेक्ट को इंस्टेंट किया जाता है, तो यह फ़ंक्शन कहलाता है। selfतात्कालिक वस्तु का प्रतिनिधित्व करता है।
c = Cat('Kitty')
c.info()उपरोक्त कथनों का परिणाम निम्नानुसार होगा:
I am a cat and I am called Kittyस्वयं क्या करता है? इसका क्या मतलब है? क्या यह अनिवार्य है ?
हर वर्ग विधि का पहला तर्क, जिसमें init शामिल है, हमेशा वर्ग की वर्तमान आवृत्ति का संदर्भ है । सम्मेलन द्वारा, इस तर्क को हमेशा नाम दिया जाता है self। Init विधि में,self नव निर्मित वस्तु को संदर्भित करता है; अन्य कक्षा विधियों में, यह उस उदाहरण को संदर्भित करता है जिसकी विधि को कहा जाता था।
अजगर " आत्म " का उपयोग करने पर आपको मजबूर नहीं करता है । आप इसे अपना मनचाहा नाम दे सकते हैं। लेकिन याद रखें कि विधि परिभाषा में पहला तर्क ऑब्जेक्ट का संदर्भ है । अजगर आपके लिए सूची में तर्क जोड़ता है ; जब आप विधियों को बुलाते हैं तो आपको इसे शामिल करने की आवश्यकता नहीं होती है। यदि आपने init पद्धति में स्व प्रदान नहीं किया है तो आपको एक त्रुटि मिलेगीself
TypeError: __init___() takes no arguments (1 given)इनिट विधि क्या करती है? क्यों जरूरी है? (आदि।)
initआरंभीकरण के लिए कम है। यह एक रचनाकार है जिसे तब बुलाया जाता है जब आप कक्षा का एक उदाहरण बनाते हैं और यह आवश्यक नहीं है । लेकिन आमतौर पर वस्तु की डिफ़ॉल्ट स्थिति सेट करने के लिए init विधि लिखना हमारा अभ्यास है। यदि आप शुरू में वस्तु की कोई भी स्थिति निर्धारित करने के लिए तैयार नहीं हैं, तो आपको यह विधि लिखने की आवश्यकता नहीं है।
# Source: Class and Instance Variables
# https://docs.python.org/2/tutorial/classes.html#class-and-instance-variables
class MyClass(object):
# class variable
my_CLS_var = 10
# sets "init'ial" state to objects/instances, use self argument
def __init__(self):
# self usage => instance variable (per object)
self.my_OBJ_var = 15
# also possible, class name is used => init class variable
MyClass.my_CLS_var = 20
def run_example_func():
# PRINTS 10 (class variable)
print MyClass.my_CLS_var
# executes __init__ for obj1 instance
# NOTE: __init__ changes class variable above
obj1 = MyClass()
# PRINTS 15 (instance variable)
print obj1.my_OBJ_var
# PRINTS 20 (class variable, changed value)
print MyClass.my_CLS_var
run_example_func()अजगर
__init__औरselfवे क्या करते हैं?क्या करता है
selfहै? इसका क्या मतलब है? क्या यह अनिवार्य है?
__init__विधि क्या करती है? क्यों जरूरी है? (आदि।)
दिया गया उदाहरण सही नहीं है, इसलिए मुझे इसके आधार पर एक सही उदाहरण बनाने दें:
class SomeObject(object):
def __init__(self, blah):
self.blah = blah
def method(self):
return self.blah जब हम ऑब्जेक्ट का एक उदाहरण बनाते हैं, तो __init__इसे बनाने के बाद ऑब्जेक्ट को कस्टमाइज़ करने के लिए कहा जाता है। यही है, जब हम नीचे के SomeObjectसाथ कॉल करते 'blah'हैं (जो कुछ भी हो सकता है), इसे __init__तर्क के रूप में फ़ंक्शन में पास किया जाता है blah:
an_object = SomeObject('blah')selfतर्क का उदाहरण है SomeObjectकि को सौंपा जाएगा an_object।
बाद में, हम इस ऑब्जेक्ट पर एक विधि कॉल करना चाहते हैं:
an_object.method()बिंदीदार लुकअप करना, अर्थात, an_object.methodउदाहरण के लिए फ़ंक्शन के उदाहरण से बांधता है, और विधि (जैसा कि ऊपर कहा गया है) अब एक "बाध्य" विधि है - जिसका अर्थ है कि हमें स्पष्ट रूप से विधि कॉल करने के लिए आवृत्ति को पास करने की आवश्यकता नहीं है ।
विधि कॉल को उदाहरण मिलता है क्योंकि यह बिंदीदार लुकअप पर बंधा हुआ था, और जब बुलाया जाता है, तो निष्पादित करने के लिए प्रोग्राम किए गए कोड को निष्पादित करता है।
निहित रूप से पारित selfतर्क को selfसम्मेलन कहा जाता है। हम किसी भी अन्य कानूनी पायथन नाम का उपयोग कर सकते हैं, लेकिन यदि आप इसे किसी और चीज़ में बदलते हैं, तो संभवतः आपको अन्य पायथन प्रोग्रामरों द्वारा तारांकित और पंख दिया जाएगा।
__init__एक विशेष विधि है, जिसे पायथन डेटामोडेल प्रलेखन में प्रलेखित किया गया है । उदाहरण बनने के तुरंत बाद इसे कहा जाता है (आमतौर पर इसके माध्यम से __new__- हालांकि __new__जब तक आपको किसी अपरिवर्तनीय डेटाटाइप को उप-वर्ग करने की आवश्यकता नहीं होती है)।
यहाँ, लड़के ने बहुत अच्छा और सरल लिखा है: https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/
इसके संदर्भ के रूप में उपरोक्त लिंक पढ़ें:
self? तो ग्राहक के सभी तरीकों के लिए उस स्व पैरामीटर के साथ क्या है? यह क्या है? क्यों, यह उदाहरण है! एक और तरीका रखो, एक वापसी की तरह एक विधि कुछ सार ग्राहक के खाते से पैसे निकालने के निर्देशों को परिभाषित करती है। कॉलिंग jeff.withdraw (100.0) उन निर्देशों को जेफ उदाहरण पर उपयोग करने के लिए कहता है।इसलिए जब हम कहते हैं कि डिफॉल्ट (सेल्फ, अमाउंट):, तो हम कह रहे हैं, "यहां बताया गया है कि आप कस्टमर ऑब्जेक्ट (जिसे हम सेल्फ कहेंगे) और एक डॉलर का फिगर (जिसे हम अमाउंट कहेंगे) से पैसे निकालते हैं। सेल्फ। ग्राहक का उदाहरण है कि आहरण किया जा रहा है। यह मुझे अनुरूपता नहीं दे रहा है। कोड।
init self अन्य तरीकों के लिए समझ में आता है, लेकिन init के बारे में क्या ? जब हम init कहते हैं , तो हम एक ऑब्जेक्ट बनाने की प्रक्रिया में हैं, इसलिए पहले से ही एक स्व कैसे हो सकता है? पायथन हमें स्व पैटर्न का विस्तार करने की अनुमति देता है जब वस्तुओं का निर्माण किया जाता है, भले ही यह बिल्कुल फिट न हो। जरा सोचिए कि jeff = ग्राहक ('जेफ नुप्प', 1000.0) को jeff = ग्राहक (जेफ, 'जेफ नुप्प', 1000.0) कहकर पुकारा जाता है; जो जेफ में उत्तीर्ण होता है उसे भी परिणाम बनाया जाता है।
यही कारण है कि जब हम init कहते हैं , तो हम self.name = नाम जैसी चीजों को कहकर ऑब्जेक्ट को इनिशियलाइज़ करते हैं। याद रखें, चूंकि स्व उदाहरण है, यह jeff.name = नाम कहने के बराबर है, जो कि jeff.name = 'Jeff Knupp के समान है। इसी प्रकार, self.balance = संतुलन jeff.balance = 1000.0 के समान है। इन दो पंक्तियों के बाद, हम ग्राहक ऑब्जेक्ट को "इनिशियलाइज़्ड" और उपयोग के लिए तैयार मानते हैं।
सावधान रहो तुम क्या हो
__init__Init समाप्त होने के बाद , कॉल करने वाला यह मान सकता है कि ऑब्जेक्ट उपयोग के लिए तैयार है। यही है, jeff = ग्राहक ('जेफ़ नुप', 1000.0) के बाद, हम jeff पर कॉल करना और कॉल करना शुरू कर सकते हैं; jeff पूरी तरह से इनिशियलाइज़्ड ऑब्जेक्ट है।
x = 'Hello'बाहर init डाल लेकिन वर्ग के अंदर? क्या यह जावा की तरह है जहाँ यह समान है, या क्या यह एक स्थिर वैरिएबल की तरह हो जाता है जो केवल एक बार आरंभिक होता है?