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

अजगर ऑब्जेक्ट सिस्टम ( पहले और दूसरे भाग) पर नोटों का तीसरा हिस्सा। लेख इस बारे में बात करता है कि क्यों सी .__ कॉल __ () सी () के समान नहीं है, मेटाक्लासेस का उपयोग करके सिंगलटन को कैसे लागू किया जाए, मैनलिंग क्या नाम है और यह कैसे काम करता है।

c .__ call__ vs c (), c .__ setattr__ vs setattr

यह सत्यापित करना आसान है कि नई कक्षाओं के लिए x (arg1, arg2) x .__ कॉल __ (arg1, arg2) के बराबर नहीं है, हालांकि यह पुरानी कक्षाओं के लिए सही है।

>>> class C ( object ):
... pass
...
>>> c = C()
>>> c . __call__ = lambda : 42
>>> c()
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
TypeError : 'C' object is not callable
>>> C . __call__ = lambda self : 42
>>> c()
42

वास्तव में सही:

c () <=> प्रकार © । __call __ (s)

स्थिति बिल्कुल __setattr __ / setattr और कई अन्य जादू (और विशेष) विधियों और संबंधित अंतर्निहित कार्यों के साथ समान है जो सभी ऑब्जेक्ट्स के लिए परिभाषित हैं, जिसमें प्रकार - वर्ग की वस्तुएं भी शामिल हैं।

ऐसा क्यों किया गया, इसे सेटट्रा [1] के उदाहरण पर माना जा सकता है।
सबसे पहले , सुनिश्चित करें कि setattr (a, 'x' , 1 ) <==> प्रकार (a) । __setattr __ (a, 'x' , 1 )।

a । x = 1 <=> setattr (ए, 'x' , 1 )

>>> class A ( object ): pass
...
>>> a = A()
>>> a . x = 1
>>> a
<__main__.A object at 0x7fafa9b26f90>
>>> setattr (a, 'y' , 2 )
>>> a . __dict__
{'y': 2, 'x': 1}

__Setattr__ विधि का उपयोग करते हुए, एक नई विशेषता सेट करें जो __dict__ पर जाएगी

>>> a . __setattr__( 'z' , 3 )

सब कुछ सही लगता है:

>>> a . __dict__
{'y': 2, 'x': 1, 'z': 3}

हालांकि:

स्पष्ट रूप से सेट करें। गलत तरीके से .__ setattr__:

>>> a . __setattr__ = lambda self : 42

एक कॉल जिसके परिणामस्वरूप त्रुटि होती है:

>>> a . __setattr__( 'z' , 4 )
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
TypeError : <lambda>() takes exactly 1 argument (2 given)

हालाँकि, इसके बावजूद, सेटट्रा काम करता है:

>>> setattr (a, 'foo' , 'bar' )
>>> a . __dict__
{'y': 2, 'x': 1, '__setattr__': <function <lambda> at 0x7fafa9b3a140>, 'z': 3, 'foo': 'bar'}

लेकिन अगर आप वर्ग विधि को ओवरराइड करते हैं:

>>> A . __setattr__ = lambda self : 42

तब वर्ग उदाहरण के लिए सेटट्रेड एक त्रुटि फेंक देगा:

>>> setattr (a, 'baz' , 'quux' )
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
TypeError : <lambda>() takes exactly 1 argument (3 given)

ऐसा क्यों किया गया?
सेटट्र (a, 'x', 1) को .__ सेटट्रा __ ('x', 1, फिर) के समान होना चाहिए

>>> class A ( object ):
... def __setattr__ ( self , attr, value):
... print 'for instances' , attr, value
... object . __setattr__( self , attr, value)
...
>>> a = A()

Aax के लिए एक नई विशेषता सेट करें = 1 <==> .__ setattr __ ('x', 1)
सब कुछ ठीक है:

>>> a . __setattr__( 'x' , 1 )
for instances x 1
>>> a . __dict__
{'x': 1}

अब कक्षा के लिए एक नई विशेषता सेट करने का प्रयास करते हैं, जो एक वस्तु भी है: A.foo = 'bar' <<==> A .__ setattr __ ('foo', 'bar')

>>> A . __setattr__( 'foo' , 'bar' )
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
TypeError : unbound method __setattr__() must be called with A instance as first argument (got str instance instead)

वर्गों (प्रकार) में विशेषताओं की खोज करने के लिए एल्गोरिदम के अनुसार, सब कुछ तार्किक है, पहला गुण वर्ग (प्रकार) के __dict__ में खोजा गया है:

>>> A . __dict__[ '__setattr__' ]
<function __setattr__ at 0x7f699d22fa28>

लेकिन तथ्य यह है कि यह वर्ग के उदाहरणों के लिए है, न कि वर्ग के लिए। इसलिए, ए .__ सेटट्रा __ ('फू', 'बार') को कॉल करना गलत होगा। और यही कारण है कि setattr () को ऑब्जेक्ट के वर्ग (प्रकार) में एक स्पष्ट खोज करना चाहिए। दरअसल, इसी कारण से, यह अन्य जादू विधियों __add__, __len__, __getatti__ आदि के लिए किया गया था।

एक कॉल करने योग्य प्रकार के रूप में कक्षा

एक वर्ग (प्रकार) एक कॉल करने योग्य प्रकार है, और इसकी कॉल एक ऑब्जेक्ट कंस्ट्रक्टर है।

>>> class C ( object ):
... pass
...
>>> ()
<__main__.C object at 0x1121e10>

के बराबर:

>>> type (C) . __call__(C)
<__main__.C object at 0x1121ed0>

क्योंकि C एक साधारण वर्ग है, फिर इसका मेटाक्लास टाइप है, इसलिए टाइप टू कॉल (C) .__ कॉल __ (C) <==> टाइप .__ कॉल __ (C) का उपयोग किया जाएगा। इनसाइड टाइप .__ कॉल __ (C), C .__ न्यू __ (cls, ...) और C .__ इनिट __ (सेल्फ, ...) पहले से ही कहे जाते हैं।

महत्वपूर्ण बात यह है कि __new__ और __init__ दोनों को एक वर्ग में गुण खोजने के लिए सामान्य एल्गोरिदम का उपयोग करके खोजा जाता है। और C .__ श्रुतिका में उनकी अनुपस्थिति में, मूल वर्ग वस्तु से विधियाँ: ऑब्जेक्ट .__ new__ और ऑब्जेक्ट .__ init____ कहलाएंगे, जबकि __call__ विधि ऑब्जेक्ट की क्लास (प्रकार) की एक विधि है: प्रकार ।__ कॉल __ (C)।

सिंगलटन वी। २

यह जानकर, हम एक मेटाक्लास सिंगलटन कार्यान्वयन बनाएंगे।

हमें एक सिंगलटन से क्या चाहिए? उसी वस्तु को वापस करने के लिए A () को कॉल करना।

ए () <=> प्रकार (ए) .__ कॉल __ (ए)

तो, हमें __call__ पद्धति के व्यवहार को बदलने की आवश्यकता है, जिसे मेटाक्लस में परिभाषित किया गया है। हम यह भूलकर ऐसा करेंगे कि सामान्य तौर पर, किसी भी पैरामीटर को __call__ को पारित किया जा सकता है।

>>> class SingletonMeta ( type ):
... def __call__ (cls, * args, ** kw):
... return super (SingletonMeta, cls) . __call__( * args, ** kw)
...
>>>

ठूंठ तैयार है।
किसी एकल ऑब्जेक्ट को वर्ग विशेषता आवृत्ति में संग्रहीत किया जाता है। ऐसा करने के लिए, __init__ में cls.instance पर आरंभ करें।

>>> class SingletonMeta ( type ):
... def __init__ (cls, * args, ** kw):
... cls . instance = None
... def __call__ (cls, * args, ** kw):
... return super (SingletonMeta, cls) . __call__( * args, ** kw)
...
>>>


__call__:

>>> class SingletonMeta ( type ):
... def __init__ (cls, * args, ** kw):
... cls . instance = None
... def __call__ (cls, * args, ** kw):
... if cls . instance is None :
... cls . instance = super (SingletonMeta, cls) . __call__( * args, ** kw)
... return cls . instance
...
>>> class C ( object ):
... __metaclass__ = SingletonMeta
...

जांचें कि सब कुछ उसी तरह काम करता है जैसा उसे करना चाहिए।

>>> C() is C()
True
>>> a = C()
>>> b = C()
>>> a . x = 42
>>> b . x
42
>>>

मेटाक्लस के रूप में एक कॉल करने योग्य प्रकार

एक मेटाकालास न केवल प्रकार के प्रकार का एक वस्तु हो सकता है, बल्कि आमतौर पर किसी भी कॉल करने योग्य प्रकार का हो सकता है।

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

>>> def mymeta (name, bases, attrs):
... attrs[ 'foo' ] = 'bar'
... return type (name, bases, attrs)
...
>>> class D ( object ):
... __metaclass__ = mymeta
...
>>> D()
<__main__.D object at 0x7fafa9abc090>
>>> d = D()
>>> d . foo
'bar'
>>> d . __dict__
{}
>>> D . __dict__
<dictproxy object at 0x7fafa9b297f8>
>>> dict (D . __dict__)
{'__module__': '__main__', '__metaclass__': <function mymeta at 0x7fafa9b3a9b0>, '__dict__': <attribute '__dict__' of 'D' objects>, 'foo': 'bar', '__weakref__': <attribute '__weakref__' of 'D' objects>, '__doc__': None}

कक्षा परिभाषाएँ

एक वर्ग परिभाषा का एक बयान सिर्फ एक निर्माण है। किसी भी बयान की तरह, यह प्रोग्राम कोड में कहीं भी दिखाई दे सकता है।

>>> if True :
... class A ( object ):
... def foo ( self ):
... print 42
...
>>> A
<class '__main__.A'>
>>> A() . foo()
42
>>>

'वर्ग' के निर्माण में, कोई भी चर, कार्य, वर्ग, जिन्हें __dict__ में संचित किया गया है, के अंदर परिभाषित किया गया है। और परिभाषा में आप किसी भी अन्य निर्माण का उपयोग कर सकते हैं - लूप्स, अगर:।

इसलिए, आप यह कर सकते हैं:

>>> class A ( object ):
... if 1 > 2 :
... def foo ( self ):
... print '1>2'
... else :
... def bar ( self ):
... print 'else'
...
>>>
>>> A()
<__main__.A object at 0x7fafa9abc150>
>>> A() . foo()
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
AttributeError : 'A' object has no attribute 'foo'
>>> A() . bar()
else

या तो
>>> class A ( object ):
... if 1 > 2 :
... x = 1
... def foo ( self ):
... print 'if'
... else :
... y = 1
... def bar ( self ):
... print 'else'
...
>>> A . x
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
AttributeError : type object 'A' has no attribute 'x'
>>> A . y
1
>>> A . foo
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
AttributeError : type object 'A' has no attribute 'foo'
>>> A . bar
<unbound method A.bar>
>>> A . bar()
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
TypeError : unbound method bar() must be called with A instance as first argument (got nothing instead)
>>> A() . bar()
else
>>>

आप एक परिभाषा को दूसरे में घोंसला बना सकते हैं।

>>> class A ( object ):
... class B ( object ):
... pass
...
...
>>> A()
<__main__.A object at 0x7fafa9abc2d0>
>>> A . __dict__
<dictproxy object at 0x7fafa9b340f8>
>>> dict (A . __dict__)
{'__dict__': <attribute '__dict__' of 'A' objects>, '__module__': '__main__', 'B': <class '__main__.B'>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
>>> A . B()
<__main__.B object at 0x7fafa9abc310>


या गतिशील रूप से वर्ग विधियाँ बनाएँ:

>>> FIELDS = [ 'a' , 'b' , 'c' ]
>>> class A ( object ):
... for f in FIELDS:
... locals ()[f] = lambda self : 42
...
>>> a = A()
>>> a . a()
42
>>> a . b()
42
>>> a . c()
42
>>> a . d()
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
AttributeError : 'A' object has no attribute 'd'
>>>

यद्यपि यह निश्चित रूप से अत्यधिक अनुशंसित है कि सामान्य अभ्यास में नहीं किया जाना चाहिए, और अधिक मुहावरेदार साधनों का उपयोग करना बेहतर है।

नामकरण

और वर्ग परिभाषा के बारे में। नामकरण के बारे में।

फॉर्म की कक्षा के वर्गनाम परिभाषा के भीतर कोई भी विशेषता ".__ {attr}" (उसी समय, attr में सबसे अधिक एक _ अंत में होता है) "_ {classname} __ {attr}" द्वारा प्रतिस्थापित किया जाता है। इस प्रकार, कक्षाओं के अंदर, आपके पास "छिपी हुई" निजी विशेषताएं हो सकती हैं जो वर्ग के वारिसों और उदाहरणों के लिए "दृश्यमान" नहीं हैं।

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

आप चर को इस तरह देख सकते हैं:

>>> A . _A__private_foo
1

खैर, यह __dict__ वर्ग में संग्रहीत है:

>>> dict (A . __dict__)
{'__dict__': <attribute '__dict__' of 'A' objects>, '_A__private_foo': 1, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
>>>

उत्तराधिकारियों की पहुंच नहीं है:

>>> class B (A):
... def foo ( self ):
... print self . __private_foo
...
>>> B() . foo()
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
File "<stdin>" , line 3 , in foo
AttributeError : 'B' object has no attribute '_B__private_foo'

सिद्धांत रूप में, वर्ग परिभाषा के अंदर __ {Attr} प्रकार की विशेषताओं के लिए बाहरी पहुंच प्रदान करें, अर्थात। आप __dict__ के साथ name_mangling के आसपास प्राप्त कर सकते हैं।

>>> class C ( object ):
... def __init__ ( self ):
... self . __dict__[ '__value' ] = 1
...
>>> C() . __value
1
>>>

हालांकि, इस तरह की चीजों को इस तथ्य के कारण दृढ़ता से हतोत्साहित किया जाता है कि ".__ {Attr}" के साथ ._ {classname} __ {attr} के प्रतिस्थापन के कारण किसी अन्य वर्ग की परिभाषा के अंदर ऐसी विशेषताओं तक पहुंच असंभव होगी। वे किस वस्तु या वर्ग से हैं, अर्थात्

>>> class D ( object ):
... def __init__ ( self ):
... self . c = C() . __value
...
>>> D()
Traceback (most recent call last):
File "<stdin>" , line 1 , in <module>
File "<stdin>" , line 3 , in __init__
AttributeError : 'C' object has no attribute '_D__value'
>>> C() . __value
1
>>>

यद्यपि C () .__ मान वर्ग परिभाषा के बाहर ठीक काम करता है। चारों ओर जाने के लिए, आपको __dict __ ['__ value'] का उपयोग करना होगा।

लिंक

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

नोट

[१] आधिकारिक दस्तावेज __len __ / len और __hash __ / hash के साथ एक उदाहरण प्रदान करता है।