पाइथन में कस्टम विशेषताएँ

क्या आपने कभी सोचा है कि जब आप अजगर का अंत करते हैं तो क्या होता है? स्ट्रेट कैरेक्टर ("\ u002E") अपने पीछे क्या छुपाता है? वह क्या रहस्य रखता है? यदि रहस्यवाद के बिना, क्या आप जानते हैं कि अजगर में उपयोगकर्ता विशेषताओं के मूल्यों को कैसे खोजना और सेट करना है? क्या आप जानना चाहेंगे? फिर ... स्वागत है!
पढ़ने में लगने वाले समय को आसान, सुखद और उपयोगी बनाने के लिए, भाषा की कुछ बुनियादी अवधारणाओं को जानना अच्छा होगा। विशेष रूप से, समझ और प्रकार दोनों ऑब्जेक्ट बेहद उपयोगी होंगे, साथ ही दोनों संस्थाओं के कुछ उदाहरणों को भी जान सकेंगे। आप उनके बारे में यहाँ सहित पढ़ सकते हैं।
उस शब्दावली के बारे में थोड़ा सा जो मैं उपयोग करता हूं इससे पहले कि हम उस बिंदु पर पहुंचें जिसके लिए हम इकट्ठे हुए हैं:

• एक वस्तु किसी भी इकाई है अजगर (फ़ंक्शन, संख्या, स्ट्रिंग ... एक शब्द में, यही है)।
• एक वर्ग एक ऐसी वस्तु है जिसका प्रकार प्रकार है (आप __class__ विशेषता में प्रकार देख सकते हैं)।
• कुछ वर्ग A का एक उदाहरण एक ऑब्जेक्ट है जिसमें __class__ विशेषता में वर्ग A का संदर्भ है।

अरे हाँ, लेख में सभी उदाहरण python3 में लिखे गए हैं! इस पर निश्चित रूप से विचार किया जाना चाहिए।
यदि उपरोक्त में से कोई भी यह पता लगाने की आपकी इच्छा को मध्यम नहीं कर सका कि आगे क्या होगा, तो शुरू करें!

__dict__

किसी ऑब्जेक्ट की विशेषताओं को सशर्त रूप से दो समूहों में विभाजित किया जा सकता है: अजगर द्वारा परिभाषित (जैसे __class__ , __bases__ ) और उपयोगकर्ता-परिभाषित, मैं बस उनके बारे में बताने जा रहा हूं। __dict__ इस वर्गीकरण के अनुसार "सिस्टम" (अजगर द्वारा परिभाषित) विशेषताओं को संदर्भित करता है। इसका कार्य उपयोगकर्ता विशेषताओं को संग्रहीत करना है। यह एक डिक्शनरी है, जिसमें कुंजी क्रमशः, विशेषता_नाम , मूल्य, विशेषता_वायु है ।
ओ ऑब्जेक्ट की विशेषता जानने के लिए, अजगर स्कैन:

1. वस्तु स्वयं ( o .__ श्रुतिका और उसकी प्रणाली विशेषताएँ)।
2. ऑब्जेक्ट क्लास ( ओ .__ क्लास __.__ डिक्ट्री )। केवल __dict__ कक्षाएं, सिस्टम विशेषताएँ नहीं।
3. जिन वर्गों से ऑब्जेक्ट क्लास विरासत में मिली है ( ओ .__ क्लास __.__ बेसिस __.__ डिक्ट्री )।

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

class StuffHolder: stuff = "class stuff" a = StuffHolder() b = StuffHolder() a.stuff # "class stuff" b.stuff # "class stuff" b.b_stuff = "b stuff" b.b_stuff # "b stuff" a.b_stuff # AttributeError 

उदाहरण एक विशेषता सामग्री के साथ StuffHolder वर्ग का वर्णन करता है, जो दोनों उदाहरणों से विरासत में मिला है। B_stuff विशेषता को ऑब्जेक्ट b में जोड़ने से कोई प्रभाव नहीं पड़ता है ।
आइए सभी अभिनेताओं के __dict__ को देखें :

 StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} a.__dict__ # {} b.__dict__ # {'b_stuff': 'b stuff'} a.__class__ # <class '__main__.StuffHolder'> b.__class__ # <class '__main__.StuffHolder'> 

_{(__Dict__ में StuffHolder क्लास डिक्टेट_प्रोक्सी क्लास की एक वस्तु को अलग-अलग कबाड़ के साथ संग्रहीत करता है, जिसे आपको अभी तक ध्यान देने की आवश्यकता नहीं है)।}

__Dict__ में न तो b और न ही सामान की विशेषता है, इसे वहां पाए बिना सर्च इंजन __dict__ क्लास ( StuffHolder ) में खोजता है, सफलतापूर्वक इसे क्लास में सौंपे गए मान को ढूंढता और लौटाता है। वर्ग संदर्भ वस्तु के __class__ विशेषता में संग्रहीत होता है।
विशेषता की खोज रनटाइम पर होती है, इसलिए उदाहरण बनाने के बाद भी, __dict__ वर्ग में सभी परिवर्तन उनमें दिखाई देंगे:

 a.new_stuff # AttributeError b.new_stuff # AttributeError StuffHolder.new_stuff = "new" StuffHolder.__dict__ # {... 'stuff': 'class stuff', 'new_stuff': 'new'...} a.new_stuff # "new" b.new_stuff # "new" 

एक उदाहरण विशेषता के लिए एक मान निर्दिष्ट करने के मामले में, केवल __dict__ उदाहरण को बदल दिया जाता है , अर्थात, __dict__ वर्ग में मान अपरिवर्तित रहता है (यदि वर्ग विशेषता मान डेटा विवरणक नहीं है):

 StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} c = StuffHolder() c.__dict__ # {} c.stuff = "more c stuff" c.__dict__ # {'stuff': 'more c stuff'} StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} 

यदि वर्ग और उदाहरण मैच में विशेषता के नाम, दुभाषिया मूल्य की खोज करते समय उदाहरण का मूल्य देखेंगे (यदि वर्ग विशेषता का मान डेटा विवरणक नहीं है):

 StuffHolder.__dict__ # {... 'stuff': 'class stuff' ...} d = StuffHolder() d.stuff # "class stuff" d.stuff = "d stuff" d.stuff # "d stuff" 

द्वारा और बड़े, यह सब __dict__ के बारे में कहा जा सकता है। यह उपयोगकर्ता द्वारा परिभाषित विशेषताओं का भंडार है। इसे रनटाइम पर खोजा जाता है और खोज के दौरान ऑब्जेक्ट और बेस कक्षाओं के __dict__ वर्ग को ध्यान में रखा जाता है। यह जानना भी महत्वपूर्ण है कि इस व्यवहार को ओवरराइड करने के कई तरीके हैं। उनमें से एक महान और पराक्रमी Descriptor है!

वर्णनकर्ता

विशेषता मान के रूप में सरल प्रकारों के साथ, अब तक सब कुछ स्पष्ट है। आइए देखें कि समान परिस्थितियों में फ़ंक्शन कैसे व्यवहार करता है:

 class FuncHolder: def func(self): pass fh = FuncHolder() FuncHolder.func # <function func at 0x8f806ac> FuncHolder.__dict__ # {...'func': <function func at 0x8f806ac>...} fh.func # <bound method FuncHolder.func of <__main__.FuncHolder object at 0x900f08c>> 

डब्ल्यूटीएफ? तुम पूछते हो ... शायद। मैं पूछूंगा। इस मामले में फ़ंक्शन किस तरह से अलग है जो हमने पहले ही देखा है? इसका उत्तर सरल है: __get__ विधि के साथ।

 FuncHolder.func.__class__.__get__ # <slot wrapper '__get__' of 'function' objects> 

यह विधि fh उदाहरण के फंक विशेषता के मूल्य को प्राप्त करने के लिए तंत्र को ओवरराइड करती है, और इस विधि को लागू करने वाली वस्तु को गैर-डेटा विवरणक कहा जाता है।

हाउटो से :

एक डिस्क्रिप्टर एक ऑब्जेक्ट एक्सेस है जिसके माध्यम से प्रोटोकॉल डिस्क्रिप्टर में विधियों द्वारा पुनर्निर्धारित किया जाता है:

 descr .__ get __ (आत्म, obj, प्रकार = कोई नहीं) -> मान (विशेषता प्राप्त होने के तरीके को ओवरराइड करता है)
 descr .__ सेट __ (स्वयं, obj, मान) -> कोई नहीं (जिस तरह से एक विशेषता को एक मान दिया जाता है, उससे ओवरराइड होता है)
 descr .__ डिलीट __

दो प्रकार के वर्णनकर्ता हैं:

1. डेटा डिस्क्रिप्टर - एक ऑब्जेक्ट जो __get __ () और __set __ () विधि को लागू करता है
2. गैर-डेटा डिस्क्रिप्टर (डेटा डिस्क्रिप्टर नहीं?) - एक ऑब्जेक्ट जो __get __ () विधि को लागू करता है

वे __dict__ उदाहरण में प्रविष्टियों के संबंध में अपने व्यवहार में भिन्न होते हैं। यदि __dict__ में डेटा डिस्क्रिप्टर के समान नाम के साथ एक प्रविष्टि है, तो डिस्क्रिप्टर का एक फायदा है। यदि रिकॉर्ड का नाम "डेटा डिस्क्रिप्टर" के नाम से मेल खाता है, तो __dict__ में रिकॉर्ड की प्राथमिकता अधिक है।

डेटा डिस्क्रिप्टर

आइए डेटा डिस्क्रिप्टर पर करीब से नज़र डालें:

 class DataDesc: def __get__(self, obj, cls): print("Trying to access from {0} class {1}".format(obj, cls)) def __set__(self, obj, val): print("Trying to set {0} for {1}".format(val, obj)) def __delete__(self, obj): print("Trying to delete from {0}".format(obj)) class DataHolder: data = DataDesc() d = DataHolder() DataHolder.data # Trying to access from None class <class '__main__.DataHolder'> d.data # Trying to access from <__main__.DataHolder object at ...> class <class '__main__.DataHolder'> d.data = 1 # Trying to set 1 for <__main__.DataHolder object at ...> del(d.data) # Trying to delete from <__main__.DataHolder object at ...> 

यह ध्यान देने योग्य है कि DataHolder.data को कॉल वर्ग के एक उदाहरण के बजाय __get__ विधि से गुजरता है।
आइए इस कथन को सत्यापित करें कि तिथि विवरणकर्ताओं को __dict__ उदाहरण में प्रविष्टियों पर एक फायदा है:

 d.__dict__["data"] = "override!" d.__dict__ # {'data': 'override!'} d.data # Trying to access from <__main__.DataHolder object at ...> class <class '__main__.DataHolder'> 

यही है, अगर __dict__ उदाहरण में प्रविष्टि को अनदेखा किया जाता है यदि __dict__ आवृत्ति वर्ग (या उसके आधार वर्ग) में एक ही नाम और मूल्य के साथ एक प्रविष्टि है - डेटा विवरणक।

एक और महत्वपूर्ण बिंदु। यदि आप क्लास के माध्यम से डिस्क्रिप्टर के साथ विशेषता के मूल्य को बदलते हैं, तो कोई डिस्क्रिप्टर विधियों को नहीं बुलाया जाएगा, मान क्लास के __dict__ में बदल जाएगा जैसे कि यह एक नियमित विशेषता थी:

 DataHolder.__dict__ # {...'data': <__main__.DataDesc object at ...>...} DataHolder.data = "kick descriptor out" DataHolder.__dict__ # {...'data': 'kick descriptor out'...} DataHolder.data # "kick descriptor out" 

कोई डेटा डिस्क्रिप्टर नहीं

गैर-डेटा विवरणक का एक उदाहरण:

 class NonDataDesc: def __get__(self, obj, cls): print("Trying to access from {0} class {1}".format(obj, cls)) class NonDataHolder: non_data = NonDataDesc() n = NonDataHolder() NonDataHolder.non_data # Trying to access from None class <class '__main__.NonDataHolder'> n.non_data # Trying to access from <__main__.NonDataHolder object at ...> class <class '__main__.NonDataHolder'> n.non_data = 1 n.non_data # 1 n.__dict__ # {'non_data': 1} 

उनका व्यवहार डेटा डिस्क्रिप्टर ने जो किया उससे थोड़ा अलग है। जब non_data विशेषता के लिए एक मान निर्दिष्ट करने की कोशिश कर रहा है, यह __dict__ उदाहरण के लिए लिखा गया था, इस प्रकार __dict__ वर्ग में संग्रहीत हैंडल छुपा रहा है।

उपयोग के उदाहरण

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

 class Descriptor: def __get__(self, obj, type): print("getter used") def __set__(self, obj, val): print("setter used") def __delete__(self, obj): print("deleter used") class MyClass: prop = Descriptor() 

या आप अंतर्निहित वर्ग संपत्ति का उपयोग कर सकते हैं , यह एक डेटा विवरणक है। उपरोक्त कोड निम्नानुसार फिर से लिखा जा सकता है:

 class MyClass: def _getter(self): print("getter used") def _setter(self, val): print("setter used") def _deleter(self): print("deleter used") prop = property(_getter, _setter, _deleter, "doc string") 

दोनों ही मामलों में, हमें एक जैसा व्यवहार मिलता है:

 m = MyClass() m.prop # getter used m.prop = 1 # setter used del(m.prop) # deleter used 

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

 class MySecondClass: prop = property() m2 = MySecondClass() m2.prop # AttributeError: unreadable attribute m2.prop = 1 # AttributeError: can't set attribute del(m2) # AttributeError: can't delete attribute 

अंतर्निहित वर्णनकर्ताओं में ये भी शामिल हैं:

• स्टेटमिथोड - कक्षा के बाहर एक फ़ंक्शन के रूप में, एक उदाहरण पहले तर्क के रूप में इसे पारित नहीं किया जाता है।
• classmethod - वर्ग विधि के समान, केवल उदाहरण वर्ग को पहले तर्क के रूप में पारित किया जाता है।

 class StaticAndClassMethodHolder: def _method(*args): print("_method called with ", args) static = staticmethod(_method) cls = classmethod(_method) s = StaticAndClassMethodHolder() s._method() # _method called with (<__main__.StaticAndClassMethodHolder object at ...>,) s.static() # _method called with () s.cls() # _method called with (<class '__main__.StaticAndClassMethodHolder'>,) 

__getattr __ (), __setattr __ (), __delattr __ () और __getattribute __ ()

यदि आप एक विशेषता के रूप में एक वस्तु के व्यवहार को निर्धारित करना चाहते हैं, तो आपको वर्णनकर्ताओं (उदाहरण के लिए, संपत्ति ) का उपयोग करना चाहिए। वस्तुओं के परिवार (उदाहरण के लिए, कार्यों ) के लिए भी यही सच है। विशेषताओं तक पहुंच को प्रभावित करने का एक और तरीका __getattr __ () , __setattr __ () , __delattr __ (), और __getattribute __ () विधियों के साथ है । डिस्क्रिप्टर के विपरीत, उन्हें एक ऐसी विशेषता के लिए परिभाषित किया जाना चाहिए, और इस ऑब्जेक्ट की किसी भी विशेषता तक पहुँचने पर उन्हें बुलाया जाता है।

__getattr __ (स्व, नाम) को कहा जाएगा यदि अनुरोधित विशेषता सामान्य तंत्र ( __dict__ उदाहरण, वर्ग, आदि) द्वारा नहीं मिली है:

 class SmartyPants: def __getattr__(self, attr): print("Yep, I know", attr) tellme = "It's a secret" smarty = SmartyPants() smarty.name = "Smartinius Smart" smarty.quicksort # Yep, I know quicksort smarty.python # Yep, I know python smarty.tellme # "It's a secret" smarty.name # "Smartinius Smart" 

विशेषता मान प्राप्त करने का प्रयास करते समय __getattribute __ (स्व, नाम) को बुलाया जाएगा। यदि यह विधि ओवरराइड की जाती है, तो मानक विशेषता मान लुकअप तंत्र सक्षम नहीं होगा। यह ध्यान में रखा जाना चाहिए कि अंतर्निहित विधियों के माध्यम से विशेष विधियों (उदाहरण के लिए, __len __ () , __str __ () ) या भाषा वाक्यविन्यास के माध्यम से एक निहित कॉल __getattribute__ () को बायपास किया जाता है ।

 class Optimist: attr = "class attribute" def __getattribute__(self, name): print("{0} is great!".format(name)) def __len__(self): print("__len__ is special") return 0 o = Optimist() o.instance_attr = "instance" o.attr # attr is great! o.dark_beer # dark_beer is great! o.instance_attr # instance_attr is great! o.__len__ # __len__ is great! len(o) # __len__ is special\n 0 

__setattr __ (स्व, नाम, मान) को एक आवृत्ति विशेषता का मान सेट करने का प्रयास करते समय कहा जाएगा। __Getattribute __ () के समान , यदि यह विधि ओवरराइड है, तो मानक मान सेटिंग तंत्र का उपयोग नहीं किया जाएगा:

 class NoSetters: attr = "class attribute" def __setattr__(self, name, val): print("not setting {0}={1}".format(name,val)) no_setters = NoSetters() no_setters.a = 1 # not setting a=1 no_setters.attr = 1 # not setting attr=1 no_setters.__dict__ # {} no_setters.attr # "class attribute" no_setters.a # AttributeError 

__delattr __ (स्वयं, नाम) - __setattr __ () के समान, लेकिन एक विशेषता को हटाने के दौरान उपयोग किया जाता है।

ओवरराइडिंग __getattribute __ () , __setattr __ (), और __delattr __ () , ध्यान रखें कि विशेषताओं को एक्सेस करने का मानक तरीका ऑब्जेक्ट के माध्यम से कहा जा सकता है:

 class GentleGuy: def __getattribute__(self, name): if name.endswith("_please"): return object.__getattribute__(self, name.replace("_please", "")) raise AttributeError("And the magic word!?") gentle = GentleGuy() gentle.coffee = "some coffee" gentle.coffee # AttributeError gentle.coffee_please # "some coffee" 

नमक

तो, अजगर में एक उदाहरण के attrname विशेषता मूल्य प्राप्त करने के लिए:

1. यदि a .__ वर्ग __.__ गेटअट्रीब्यूट __ () विधि को परिभाषित किया जाता है, तो इसे कहा जाता है और प्राप्त मान वापस आ जाता है।
2. यदि attrname एक विशेष (अजगर द्वारा परिभाषित) विशेषता है, जैसे कि __class__ या __doc__ , तो इसका मान वापस आ जाता है।
3. यह attrname के साथ एक प्रविष्टि के लिए .__ वर्ग __.__ डिक्ट्री की जाँच करता है । यदि यह मौजूद है और मान एक डेटा डिस्क्रिप्टर है, तो डिस्क्रिप्टर के __get __ () पद्धति को कॉल करने का परिणाम वापस आ जाता है। सभी आधार वर्गों की भी जाँच की जाती है।
4. यदि एक प्रविष्टि .rrname नाम .__ श्रुतिका में मौजूद है, तो उस प्रविष्टि का मान वापस आ जाता है। यदि एक वर्ग है, तो उसके आधार वर्गों के बीच भी विशेषता की खोज की जाती है, और यदि वहाँ या __dict__ में एक डेटा विवरणक होता है, तो विवरणक के __get __ () का परिणाम वापस आ जाता है।
5. यह एक .__ वर्ग __.__ डिक्ट्री की जाँच करता है , अगर इसमें attrname के साथ एक प्रविष्टि है और यह एक "डेटा डिस्क्रिप्टर" है, तो परिणाम डिस्क्रिप्टर का __get __ () है , यदि रिकॉर्ड मौजूद है और कोई डिस्क्रिप्टर नहीं है, तो रिकॉर्ड का मान वापस आ जाता है। बेस क्लास भी खोजे जाते हैं।
6. यदि a .__ वर्ग __.__ getattr __ () विधि मौजूद है, तो इसे कहा जाता है और इसका परिणाम वापस आ जाता है। यदि ऐसी कोई विधि नहीं है, तो एक गुणक को फेंक दिया जाता है।

उदाहरण के Attrname विशेषता का मान सेट करने के लिए:

1. यदि a .__ वर्ग __.__ setattr __ () विधि मौजूद है, तो इसे कहा जाता है।
2. यह एक .__ वर्ग __.__ डिक्ट्री की जांच करता है , अगर इसमें एट्रीनाम के साथ एक प्रविष्टि है और यह एक डेटा डिस्क्रिप्टर है, डिस्क्रिप्टर की __set __ () विधि को कहा जाता है। बेस कक्षाओं की भी जाँच की जाती है।
3. Attrname कुंजी के साथ एक मान प्रविष्टि .__ श्रुत__ में जोड़ी जाती है ।

__slots__

जैसा कि गुइडो ने अपनी अजगर कहानी में लिखा है कि नई शैली की कक्षाओं का आविष्कार कैसे किया गया था:

... मुझे डर था कि क्लास सिस्टम में बदलाव से प्रदर्शन पर बुरा असर पड़ेगा। विशेष रूप से, डेटा डिस्क्रिप्टर के सही ढंग से काम करने के लिए, ऑब्जेक्ट की विशेषताओं के साथ सभी जोड़तोड़ __dict__ वर्ग की जांच करने के लिए इस तथ्य के लिए शुरू हुई कि यह विशेषता डेटा डिस्क्रिप्टर है ...

यदि उपयोगकर्ता प्रदर्शन में गिरावट से निराश हैं, तो अजगर डेवलपर्स की देखभाल __slots__ के साथ हुई ।
__Slots__ की उपस्थिति वहां इंगित किए गए ऑब्जेक्ट की संभावित विशेषता नामों को सीमित करती है। इसके अलावा, चूंकि सभी विशेषता नाम अब पहले से ज्ञात हैं, इसलिए यह __dict__ उदाहरण बनाने की आवश्यकता को हटा देता है।

 class Slotter: __slots__ = ["a", "b"] s = Slotter() s.__dict__ # AttributeError sc = 1 # AttributeError sa = 1 sa # 1 sb = 1 sb # 1 dir(s) # [ ... 'a', 'b' ... ] 

यह पता चला कि गुइडो के डर से कोई फर्क नहीं पड़ा, लेकिन जब तक यह स्पष्ट हो गया, तब तक बहुत देर हो चुकी थी। इसके अलावा, __slots__ का उपयोग करना वास्तव में प्रदर्शन को बढ़ा सकता है, विशेष रूप से कई छोटी वस्तुओं को बनाते समय उपयोग की जाने वाली स्मृति की मात्रा को कम करके।

निष्कर्ष

अजगर में एक विशेषता तक पहुंच को भारी संख्या में नियंत्रित किया जा सकता है। उनमें से प्रत्येक अपनी समस्या को हल करता है, और साथ में वे वस्तु का उपयोग करने के लगभग किसी भी बोधगम्य परिदृश्य के लिए उपयुक्त हैं। ये तंत्र भाषा के लचीलेपन का आधार हैं, साथ ही कई विरासत, मेटाक्लासेस और अन्य उपहार भी हैं। मुझे यह पता लगाने में कुछ समय लगा, समझ और, सबसे महत्वपूर्ण बात, विशेषताओं के काम के लिए इस कई विकल्पों को स्वीकार करना। पहली नज़र में, यह थोड़ा बेमानी और विशेष रूप से तर्कसंगत नहीं था, लेकिन, यह देखते हुए कि यह दैनिक प्रोग्रामिंग में शायद ही कभी उपयोगी है, आपके शस्त्रागार में ऐसे शक्तिशाली उपकरण होना अच्छा है।
मुझे उम्मीद है कि इस लेख ने आपके लिए कुछ बिंदुओं को स्पष्ट किया है जो आपके हाथों से नहीं हुए हैं। और अब, आपकी आँखों में आग लगने और पॉइंट में आत्मविश्वास के साथ, आप बदलती जरूरतों को पूरा करने के लिए सबसे अधिक साफ, सबसे पठनीय और प्रतिरोधी हैं! खैर, या एक टिप्पणी।

आपके समय के लिए धन्यवाद।

संदर्भ

1. शलभ चतुर्वेदी। पायथन विशेषताएँ और विधियाँ
2. गुइडो वान रोसुम। न्यू-स्टाइल क्लासेस पर इनसाइड स्टोरी
3. अजगर का प्रलेखन

UPD: उपयोगकर्ता लेरन से उपयोगी लिंक: पायथन डेटा मॉडल