🧒🏾 👲🏿 🏴󠁧󠁢󠁷󠁬󠁳󠁿 पायथन ऑब्जेक्ट सिस्टम पार्ट 1 पर नोट्स 🚴🏽 👷🏻 👨‍⚕️

अजगर ऑब्जेक्ट सिस्टम पर कुछ नोट्स। उन लोगों के लिए डिज़ाइन किया गया है जो पहले से ही जानते हैं कि कैसे अजगर में प्रोग्राम करना है। यह अजगर 2.3 और उच्चतर में केवल नई कक्षाओं (नई शैली की कक्षाएं) के बारे में है। यह आलेख बताता है कि ऑब्जेक्ट क्या हैं और कैसे विशेषताएँ खोजी जाती हैं।

वस्तुएं

अजगर में सभी डेटा ऑब्जेक्ट हैं। प्रत्येक वस्तु में 2 विशेष गुण होते हैं __class__ और __dict__।

__class__ - वर्ग या प्रकार को परिभाषित करता है जिसका उदाहरण एक वस्तु है। एक प्रकार (या किसी वस्तु का वर्ग) उसके व्यवहार को निर्धारित करता है; बिल्ट-इन सहित सभी वस्तुओं, यह है। टाइप और क्लास एक ही चीज के अलग-अलग नाम हैं। x .__ वर्ग__ <==> प्रकार (x)।
__dict__ एक ऐसा शब्दकोश है जो आंतरिक नामस्थान तक पहुंच प्रदान करता है, लगभग सभी वस्तुओं में यह होता है, कई अंतर्निहित प्रकार नहीं होते हैं।

उदाहरण।

>>> def foo (): pass
...
>>> foo . __class__
<type 'function'>
>>> foo . __dict__
{}
>>> ( 42 ) . __dict__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute '__dict__'
>>> ( 42 ) . __class__
<type 'int'>

>>> class A ( object ):
... qux = 'A'
... def __init__ ( self , name):
... self . name = name
... def foo ( self ):
... print 'foo'
...

>>> a = A( 'a' )

A में __dict__ और __class__ भी है:

>>> a . __dict__ {'name': 'a'}

>>> a . __class__
<class '__main__.A'>
>>> type (a)
<class '__main__.A'>
>>> a . __class__ is type (a)
True

वर्ग और प्रकार एक हैं और एक ही हैं।

>>> a . __class__ is type (a) is A
True

.__ श्रुतिका इस मामले में 'नाम' आंतरिक (या ऑब्जेक्ट-विशिष्ट) विशेषताओं वाला एक शब्दकोश है। और .__ class__ वर्ग (प्रकार) में।

और, उदाहरण के लिए, कक्षा के तरीकों में, असाइनमेंट self.foo = बार लगभग स्वयं के समान होता है ।__ तानाशाही __ ['फू'] = बार या एक समान कॉल के लिए नीचे आता है।

__Dict__ ऑब्जेक्ट में कोई क्लास मेथड, डिस्क्रिप्टर, क्लास वैरिएबल्स, प्रॉपर्टीज़, स्टैटिक मेथड्स नहीं हैं। इन सभी को __class__ एट्रिब्यूट से क्लास का इस्तेमाल करते हुए डायनामिकली डिफाइन किया जाता है और क्लास के लिए स्पेसिफिक (टाइप) ऑब्जेक्ट के लिए होते हैं, न कि ऑब्जेक्ट के लिए।

एक उदाहरण है। ऑब्जेक्ट के वर्ग को फिर से परिभाषित करें:

>>> class B ( object ):
... qux = 'B'
... def __init__ ( self ):
... self . name = 'B object'
... def bar ( self ):
... print 'bar'
...
>>> a . __dict__
{'name': 'a'}
>>> a . foo()
foo
>>> a . __class__
<class '__main__.A'>
>>> a . __class__ = B
>>> a . __class__
<class '__main__.B'>

हम देखते हैं कि क्या बदल गया है।

A.name का मान समान रहता है, अर्थात वर्ग बदलने पर __in__ को नहीं बुलाया गया था।

>>> a . __dict__
{'name': 'a'}

कक्षा चर और "अतीत" वर्ग ए के तरीकों का उपयोग खो गया था:

>>> a . foo()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'B' object has no attribute 'foo'

और यहाँ वर्ग चर और कक्षा बी अभिगम के तरीके हैं:

>>> a . bar()
bar
>>> a . qux
'B'

ऑब्जेक्ट विशेषताओं के साथ काम करें: इंस्टॉलेशन, रिमूवल और सर्च बिल्ट-इन फ़ंक्शंस को कॉल करने के लिए समतुल्य है।

ax = 1 <==> setattr (ए, 'x', 1)
डेल ऐक्स <==> डेल्ट्र (ए, 'एक्स')
ax <==> getattr (ए, 'x')

यह समझा जाना चाहिए कि सेटट्रैट और डेल्ट्र केवल ऑब्जेक्ट को ही प्रभावित करते हैं और बदलते हैं (अधिक सटीक रूप से, .__ श्रुतिका), और ऑब्जेक्ट के वर्ग को नहीं बदलते हैं।

qux - एक वर्ग चर है, अर्थात यह "बी" वर्ग बी के लिए है, और आपत्ति के लिए नहीं:

>>> a . qux
'B'
>>> a . __dict__
{'name': 'a'}

यदि हम इस विशेषता को हटाने की कोशिश करते हैं, तो हमें एक त्रुटि मिलती है, क्योंकि डेल्टा एक .__ डिक्ट्री से विशेषता को हटाने की कोशिश करेगा

>>> delattr (a, 'qux' )
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: qux
>>> del a . qux
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: qux
>>> a . qux
'B'
>>>

इसके अलावा, यदि हम विशेषता को बदलने (सेट) करने का प्रयास करते हैं, तो सेटट्रा इसे इस विशेष ऑब्जेक्ट के लिए __dict__ विशिष्ट में डाल देगा।

>>> b = B()
>>> b . qux
'B'
>>> a . qux = 'myB'
>>> a . qux
'myB'
>>> a . __dict__
{'qux': 'myB', 'name': 'a'}
>>> b . qux
'B'
>>>

खैर, चूंकि __dict__ ऑब्जेक्ट में 'qux' है, इसे डेल्ट्र का उपयोग करके हटाया जा सकता है:

>>> del a . qux

हटाने के बाद, a.qux वर्ग चर का मान लौटाएगा:

>>> a . qux
'B'
>>> a . __dict__
{'name': 'a'}

तो:

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

वस्तुओं और वर्गों

कक्षाएं ऑब्जेक्ट हैं, और उनके पास विशेष गुण __class__ और __dict__ भी हैं।

>>> class A ( object ):
... pass
...

वर्ग का एक प्रकार है।

>>> A . __class__
<type 'type'>

सही __dict__ वर्गों में एक शब्दकोष नहीं है

>>> A . __dict__
<dictproxy object at 0x1111e88>

लेकिन __dict__ आंतरिक नामस्थान तक पहुंचने के लिए ज़िम्मेदार है, जो तरीकों, विवरणों, चर, गुणों, और अधिक को संग्रहीत करता है:

>>> dict (A . __dict__)
{'__module__': '__main__', 'qux': 'A', '__dict__': <attribute '__dict__' of 'A' objects>, 'foo': <function foo at 0x7f7797a25c08>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
>>> A . __dict__ . keys()
['__module__', 'qux', '__dict__', 'foo', '__weakref__', '__doc__']<

कक्षाओं में, __class__ और __dict__ के अलावा, कई और विशेष विशेषताएं हैं: __bases__ - प्रत्यक्ष माता-पिता की एक सूची, __name__ - वर्ग का नाम। [1]

कक्षाओं को साधारण वस्तुओं के कुछ प्रकार के एक्सटेंशन माना जा सकता है जो एक प्रकार का इंटरफ़ेस लागू करते हैं। सभी वर्गों (या प्रकारों) का सेट सभी वस्तुओं के सेट से संबंधित है, या बल्कि, इसका एक सबसेट है। दूसरे शब्दों में, कोई भी वर्ग एक वस्तु है, लेकिन प्रत्येक वस्तु एक वर्ग नहीं है। हम उन वस्तुओं को नियमित रूप से कॉल करने के लिए सहमत होते हैं जो कक्षा नहीं हैं।

एक छोटा प्रदर्शन जो थोड़ा बाद में बेहतर समझा जाएगा।
वर्ग एक वस्तु है।

>>> class A ( object ):
... pass
...

>>> isinstance (A, object )
True

एक संख्या भी एक वस्तु है।

>>> isinstance ( 42 , object )
True

एक वर्ग एक वर्ग (यानी प्रकार) है।

>>> isinstance (A, type )
True

लेकिन संख्या एक वर्ग (प्रकार) नहीं है। (बाद में क्या समझाया जाएगा)

>>> isinstance ( 42 , type )
False
>>>

वैसे, यह भी एक सामान्य वस्तु है।

>>> a = A()
>>> isinstance (a, A)
True
>>> isinstance (a, object )
True
>>> isinstance (a, type )
False

और ए में केवल एक प्रत्यक्ष अभिभावक वर्ग है - वस्तु।

>>> A . __bases__
(<type 'object'>,)

कुछ विशेष मापदंडों को भी बदला जा सकता है:

>>> A . __name__
'A'
>>> A . __name__ = 'B'
>>> A
<class '__main__.B'>

गेटअटर का उपयोग करके हम वर्ग के गुणों तक पहुँच प्राप्त करते हैं:

>>> A . qux
'A'
>>> A . foo
<unbound method A.foo>
>>>

एक नियमित ऑब्जेक्ट में विशेषताओं की खोज करें

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

एक उदाहरण है।

>>> class A ( object ):
... qux = 'A'
... def __init__ ( self , name):
... self . name = name
... def foo ( self ):
... print 'foo'
...

>>> a = A()
>>> b = A()

क्योंकि साधारण वस्तुओं में a और b __dict__ में कोई 'qux' विशेषता नहीं है, फिर खोज उनके प्रकार (वर्ग) के आंतरिक शब्दकोश __dict__ में जारी रहती है, और फिर एक निश्चित क्रम में __dict__ माता-पिता शब्दकोशों के अनुसार:

>>> b . qux
'A'
>>> A . qux
'A'

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

>>> A . qux = 'B'
>>> a . qux
'B'
>>> b . qux
'B'
>>>

इसी प्रकार, रनटाइम में, आप कक्षा में एक विधि जोड़ सकते हैं:

>>> A . quux = lambda self : 'i have quux method'
>>> A . __dict__[ 'quux' ]
<function <lambda> at 0x7f7797a25b90>
>>> A . quux
<unbound method A.<lambda>>

और इसका उपयोग उदाहरणों में दिखाई देगा:

>>> a . quux()
'i have quux method'

किसी भी अन्य वस्तुओं के साथ की तरह, आप वर्ग विशेषता को हटा सकते हैं, उदाहरण के लिए, वर्ग चर qux:

>>> del A . qux

वह __dict__ से सेवानिवृत्त हुई

>>> A . __dict__[ 'qux' ]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'qux'

और उदाहरणों तक पहुंच खो जाएगी।

>>> a . qux
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'qux'
>>>

कक्षाओं में सामान्य वस्तुओं के रूप में लगभग समान विशेषता खोज होती है, लेकिन अंतर होते हैं: खोज हमारे स्वयं के __dict__ शब्दकोश से शुरू होती है, और फिर हम एक विशिष्ट एल्गोरिथ्म द्वारा __dict__ सुपरक्लॉस के शब्दकोश (जो __bases__ में संग्रहीत होते हैं) की खोज करते हैं, और फिर वर्ग में __class__ और उनके सुपरक्लास। (इस पर और बाद में)।

लिंक

पायथन में प्रकारों और कक्षाओं को एकजुट करना नए वर्गों में क्या, कैसे और क्यों की व्याख्या करने वाला मुख्य दस्तावेज है।
मेकिंग टाइप्स लाइक मोर लाइक क्लासेस - PEP 252, जो पुरानी कक्षाओं और नए लोगों के बीच अंतर का वर्णन करता है।
अंतर्निहित कार्य - सभी अंतर्निहित कार्यों के संचालन का विस्तृत विवरण।
डेटा मॉडल - अजगर डेटा मॉडल का विस्तृत विवरण।
अजगर प्रकार और वस्तुओं - चित्रों के साथ सरल उदाहरणों का उपयोग करते हुए अजगर ऑब्जेक्ट मॉडल की व्याख्या।

नोट

[१] सरलता के लिए, हमें __module__ और __doc__ के बारे में भूलना चाहिए। दस्तावेज़ में वर्ग विशेषताओं की पूरी सूची पाई जा सकती है ।

पायथन ऑब्जेक्ट सिस्टम पार्ट 1 पर नोट्स

वस्तुएं

वस्तुओं और वर्गों

एक नियमित ऑब्जेक्ट में विशेषताओं की खोज करें

लिंक

नोट

और पढ़ें

More articles: