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

अजगर ऑब्जेक्ट सिस्टम पर नोटों का दूसरा भाग (पहला भाग यहां है )। यह लेख बताता है कि कक्षा में मेटाक्लासेस, टाइप, ऑब्जेक्ट क्या हैं और कैसे विशेषताओं की खोज की जाती है।

कक्षाएं

कक्षाएं (प्रकार) वस्तु कारखाने हैं। उनका मुख्य कार्य वस्तुओं को एक निश्चित व्यवहार के साथ बनाना है।

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

एक सामान्य वस्तु को 2 चरणों में त्वरित किया जाता है: पहला, इसका निर्माण, फिर आरंभीकरण। तदनुसार, __new__ क्लास पद्धति को पहले लॉन्च किया गया है, जो इस क्लास की एक वस्तु लौटाता है, फिर __in__ क्लास पद्धति को निष्पादित किया जाता है, जो पहले से बनाई गई ऑब्जेक्ट को प्रारंभ करता है।

def __new __ (cls, ...) एक स्थिर विधि है (लेकिन आप इसे इस तरह से घोषित नहीं कर सकते हैं) जो क्लास के cls का ऑब्जेक्ट बनाता है।

def __init __ (स्व, ...) एक वर्ग विधि है जो निर्मित वस्तु को इनिशियलाइज़ करती है।

उदाहरण के लिए, एक वर्ग घोषित करें:

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

वर्ग A के लिए, न तो __new__ और न ही __in__ को परिभाषित किया गया है। एक वर्ग (प्रकार) के लिए विशेषता खोज एल्गोरिथ्म के अनुसार, जो साधारण वस्तुओं के लिए विशेषता खोज एल्गोरिथ्म के साथ भ्रमित नहीं होना चाहिए, जब कक्षा उन्हें अपने __dict__ में नहीं मिलती है, तो वह अपने बेस (माता-पिता) कक्षाओं के __dict__ में इन तरीकों की तलाश करेगी।

क्लास ए में अपने माता-पिता के रूप में एक अंतर्निहित क्लास ऑब्जेक्ट है। इस प्रकार, वह उन्हें वस्तु में तलाश करेगा।

और मिलेगा:

>>> object . __dict__[ '__init__' ]
<slot wrapper '__init__' of 'object' objects>
>>> object . __dict__[ '__new__' ]
<built-in method __new__ of type object at 0x82e780>
>>>

चूंकि ऐसी विधियां हैं, इसका मतलब है कि a = A () कॉल के अनुक्रम के समान है:

a = ऑब्जेक्ट .__ नया __ (ए)
ऑब्जेक्ट .__ init __ (ए)

सामान्य शब्दों में, सुपर का उपयोग करते हुए, जो अभिभावक वर्गों द्वारा विशेषताओं की खोज के लिए एल्गोरिथ्म को लागू करता है [1]:

a = सुपर (A, A) .__ नया __ (A)
सुपर (A, A) .__ init __ (a)

एक उदाहरण है।

>>> class A ( object ):
... def __new__ (cls):
... obj = super (A, cls) . __new__(cls)
... print 'created object' , obj
... return obj
... def __init__ ( self ):
... print 'initing object' , self
...
>>> A()
created object <__main__.A object at 0x1620ed0>
initing object <__main__.A object at 0x1620ed0>
<__main__.A object at 0x1620ed0>
>>>

सिंगलटन v। १

यह समझना कि कोई वस्तु कैसे बनाई जाती है, आप अकेले पैटर्न का कार्यान्वयन लिख सकते हैं।

हमें यह सुनिश्चित करना चाहिए कि कक्षा में केवल एक ही उदाहरण हो। यानी क्लास के कंस्ट्रक्टर को कॉल करते समय, हम हमेशा क्लास का एक ही उदाहरण देते हैं।

और इसका मतलब है कि जब आप __new__ विधि कहते हैं, तो उसे हर बार उसी वस्तु को वापस करना होगा। आप स्वयं ऑब्जेक्ट को स्टोर कर सकते हैं, उदाहरण के लिए, वर्ग चर उदाहरण में।

नतीजतन, हम प्राप्त करते हैं:

>>> class C ( object ):
... instance = None
... def __new__ (cls):
... if cls . instance is None :
... cls . instance = super (C, cls) . __new__(cls)
... return cls . instance
...
>>> C() is C()
True
>>> C() . x = 1
>>> c = C()
>>> d = C()
>>> c . x
1
>>> d . x
1
>>> c . x =2
>>> d . x
2
>>> c . x
2

कक्षाएं और मेटाक्लासेस।

एक वर्ग (प्रकार) के लिए, साथ ही एक नियमित वस्तु के लिए, एक वर्ग (प्रकार) होता है जो कक्षाएं बनाता है और वर्ग के व्यवहार को परिभाषित करता है। इस वर्ग को मेटाक्लास कहा जाता है।

नियमित ऑब्जेक्ट की तरह एक क्लास बनाना, कंस्ट्रक्टर को कॉल करने से होता है, लेकिन चूंकि वर्ग में कई अतिरिक्त विशेष गुण हैं जिन्हें आरंभीकृत किया जाना चाहिए, और संबंधित आवश्यक पैरामीटर कंस्ट्रक्टर को पास किए जाते हैं।

XClass = XMetaClass (नाम, आधार, अट्र्स)

फिर, बनाने के ठीक बाद
XClass .__ name__ नाम के बराबर है,
XClass .__ bases__ आधारों के बराबर है,
एक्सक्लास .__ डिक्टिजी, एट्रस के बराबर है, और
XClass .__ class__, XMetaClass के बराबर है

डिफ़ॉल्ट रूप से, सभी परिभाषित वर्गों के लिए, मेटाक्लस प्रकार है।

इस तरह से।

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

समान रूप से, साधारण वस्तुओं के साथ सादृश्य द्वारा:

>>> type ( 'A' , ( object ,), {})
<class '__main__.A'>

और यह:

>>> class B (A):
... def foo ( self ):
... 42
...

समतुल्य रूप

>>> type ( 'B' , (A,), { 'foo' : lambda self : 42 })

कक्षा को परिभाषित करते समय, आप अपने मेटाक्लास का उपयोग करके निर्दिष्ट कर सकते हैं
वर्ग चर __metaclass__:

>>> class A ( object ):
... __metaclass__ = Meta
...
>>>

जो समतुल्य है: ए = मेटा ('ए', (ऑब्जेक्ट), {})

प्रकार और वस्तु के बारे में

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

>>> object . __class__
<type 'type'>
>>> type . __class__
<type 'type'>

>>> object . __dict__
<dictproxy object at 0x7f7797a1cf30>
>>> type . __dict__
<dictproxy object at 0x7f7797a1cfa0>

इसके अलावा, वस्तु और प्रकार टाइप ऑब्जेक्ट्स (कक्षाएं) हैं, और उनकी विशेष विशेषताएं __name__, __bases___ भी हैं:

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

प्रकार या वर्ग वस्तु के उदाहरण ऑब्जेक्ट्स (कोई भी) हैं। यानी कोई भी वस्तु वस्तु वर्ग का एक उदाहरण है:

>>> isinstance ( 1 , object )
True
>>> isinstance ( setattr , object )
True
>>> isinstance ( "foo" , object )
True
>>> isinstance (A, object )
True

यहां तक ​​कि एक समारोह एक वस्तु है:
>>> def bar ():
... pass
...
>>> isinstance (bar, object )
True

इसके अलावा, ऑब्जेक्ट क्लास ही इसका उदाहरण है:

>>> isinstance ( object , object )
True

प्रकार भी इसका एक उदाहरण है:

>>> isinstance ( type , object )
True

तात्कालिकता - वस्तु () सबसे सरल और सबसे सामान्य वस्तु देता है:

>>> o = object ()

जिसमें __dict__ भी नहीं है, केवल __class__ है।

>>> o . __dict__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'object' object has no attribute '__dict__'
>>> o . __class__
<type 'object'>
>>>

एक वर्ग या प्रकार के उदाहरण सिर्फ अन्य वर्ग या अन्य प्रकार हैं:

एक संख्या एक वर्ग नहीं है

>>> isinstance ( 1 , type )
False

स्ट्रिंग भी

>>> isinstance ( "foo" , type )
False

अंतर्निहित सेटट्रा फ़ंक्शन भी एक वर्ग नहीं है।

>>> isinstance ( setattr , type )
False

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

>>> isinstance (A, type )
True

स्ट्रिंग प्रकार एक वर्ग है।

>>> isinstance ( "foo" . __class__, type )
True

क्योंकि वस्तु और प्रकार भी वर्ग हैं, फिर वे प्रकार वर्ग के उदाहरण हैं:

>>> isinstance ( object , type )
True
>>> isinstance ( type , type )
True
>>>

क्योंकि चूंकि कई वर्ग (प्रकार) कई वस्तुओं का एक उपसमूह हैं, इसलिए यह मानना ​​तर्कसंगत है कि प्रकार वस्तु का उपवर्ग है, अर्थात।

>>> issubclass ( type , object )
True
>>> issubclass ( object , type )
False

प्रकार केवल एक वर्ग है जिसका उदाहरण अन्य वर्ग हैं। (अर्थात मेटाक्लास)। और स्वयं कक्षाओं को सरल, साधारण वस्तुओं का विस्तार माना जा सकता है।

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

तो, बस एक वर्ग को परिभाषित करने के लिए, आपको इसे ऑब्जेक्ट से विरासत में प्राप्त करने की आवश्यकता है, एक मेटाक्लस को परिभाषित करने के लिए - हम इसे टाइप से विरासत में लेते हैं।

और एक और बात: प्रकार (ए) और प्रकार (नाम, आधार, अटार) को भ्रमित न करें।
प्रकार (ए) - एक तर्क के साथ एक कॉल, वस्तु का प्रकार लौटाता है,
एक प्रकार (नाम, आधार, अट्र्स) - तीन तर्कों के साथ एक कॉल - यह क्लास कंस्ट्रक्टर के लिए एक कॉल है।

एक वर्ग में गुण खोजने के बारे में

जैसा कि पहले ही उल्लेख किया गया है, एक नियमित ऑब्जेक्ट में विशेषताओं की खोज के लिए एल्गोरिथ्म, लेकिन कुछ सूक्ष्मताएं हैं, क्योंकि प्रकार (कक्षाएं) में __bases__ - मूल कक्षाएं (प्रकार) हैं।

यदि विशेषता __dict__ में मौजूद है, तो इसे वापस कर दिया जाता है, फिर __bases__ से बेस कक्षाओं पर एक खोज की जाती है, और उसके बाद __dict__ __class __ 'a (यानी, वास्तव में एक मेटाक्लस) और उसके (मेटाक्लास) मूल वर्ग (मेटाक्लासेस) पर कॉल होती है।

एक छोटा सा उदाहरण:

>>> class Ameta ( type ):
... def foo (cls):
... print 'Ameta.foo'
...
>>> class A ( object ):
... __metaclass__ = Ameta
...
>>> A . foo()
Ameta.foo

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

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

A .__ डिक्ट्री में 'फू' नहीं है:

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

लेकिन यह मेटाक्लस में है, इसलिए:

>>> A . foo()
Ameta.foo

>>> class B (A):
... @classmethod
... def foo (cls):
... print 'B.foo'
...
>>> B . foo # .. foo B.__dict__ B.__dict__['foo']
<bound method Ameta.foo of <class '__main__.B'>>
>>> B . foo()
B.foo

>>> class C (B):
... pass
...
>>> C . foo() # B.
B.foo

C foo B.

>>> c = C()
>>> c . foo()
B.foo

>>> class D (A):
... pass
...
>>> D . foo()
Ameta.foo

और उदाहरण D नहीं मिलेगा:

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

metaclasses

मेटाक्लासेस वर्ग (या प्रकार) के कारखाने हैं। क्लास की तात्कालिकता भी 2 चरणों में होती है - प्रकार (क्लास) का ऑब्जेक्ट बनाना और इसे इनिशियलाइज़ करना। यह दो मेटाक्लास विधियों का उपयोग करके भी किया जाता है। सबसे पहले, मेटाक्लास की __new__ पद्धति को वर्ग बनाने के लिए आवश्यक मापदंडों के साथ कहा जाता है - नाम, आधार, अटरस, और फिर __in__ एक ही पैरामीटर और वर्ग पहले से ही बनाया गया।

एक उदाहरण है।

>>> class Meta ( type ):
... pass
...
>>> Meta( 'A' , ( object ,), {})
<class '__main__.A'>

शुरुआत में, मेटा क्लास मेटा अपने __dict__ डिक्शनरी में __new__ मेथड के लिए खोज करती है, उसे वहां नहीं ढूंढती है, और अपने पेरेंट क्लासेस (यानी मेटाकालासेस इस केस टाइप में) के लिए __dict__ में खोजना शुरू करती है, यानी। कक्षा में एक नियमित विशेषता खोज होती है। उपयुक्त मापदंडों के साथ __new__ को निष्पादित करने के परिणामस्वरूप, यह एक नया वर्ग प्राप्त करता है, जिसे बाद में मेटाक्लास के __in____ विधि को कॉल करके प्रारंभ किया जाता है।

पूरी तरह से विस्तारित रूप में यह पता चला है:

cls = type .__ dict __ ['__ new __'] (मेटा, 'ए', (ऑब्जेक्ट), {})
प्रकार .__ तानाशाह __ ['__ init __'] (cls, 'A', (ऑब्जेक्ट), {})

या सुपर का उपयोग कर

cls = super (मेटा, मेटा) .__ नया __ (मेटा, 'ए', (ऑब्जेक्ट), {})
सुपर (मेटा, मेटा) .__ init __ (सीएल, 'ए', (ऑब्जेक्ट), {})

यह ध्यान देने योग्य है कि, सामान्य वस्तुओं के तात्कालिकता के विपरीत, वस्तु नहीं ।__ नई__ और वस्तु ।__ init__ हैं, लेकिन टाइप करें। _ new__ और type .__ init__। Object .__ new__ और type .__ new__ में अलग-अलग हस्ताक्षर हैं, और ऑब्जेक्ट .__ new__ एक नियमित ऑब्जेक्ट लौटाता है, और टाइप करें ।__ new__ प्रकार (टाइपोबॉजेक्ट) का एक ऑब्जेक्ट है, अर्थात। वर्ग।

आइए देखें कि यह सब एक उदाहरण के साथ कैसे काम करता है।

>>> class Meta ( type ):
... def __new__ (mcls, name, bases, attrs):
... print 'creating new class' , name
... return super (Meta, mcls) . __new__(mcls, name, bases, attrs)
... def __init__ (cls, name, bases, attrs):
... print 'initing new class' , name
...
...
>>> class A ( object ):
... __metaclass__ = Meta
...
creating new class A
initing new class A

सिर्फ एक वस्तु की तात्कालिकता के दौरान, कोई लेबल प्रदर्शित नहीं किया जाता है।

>>> a = A()
>>>

इसके अलावा, क्रमशः, मेटाक्लास के __new__ और __init__ तरीकों में, आप सब कुछ बदल सकते हैं: नाम, सुपरक्लास की सूची, विशेषता।

लिंक

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

नोट

[१] सुपर के बारे में अधिक यहाँ ।

और पढ़ें

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