दिलचस्प और अजगर की उपयोगिता। भाग 3

पिछले भागों में, हमने स्लाइस, अनपैकिंग / पैकिंग कलेक्शन और बूलियन ऑपरेशन की कुछ विशेषताएं और प्रकार देखे।

टिप्पणियों में एक स्केलर द्वारा संग्रह को गुणा करने की संभावना का उल्लेख किया गया है:

a = [0] * 3 s = 'a' * 2 print(a, s) # -> [0, 0, 0], 'aa' 

अधिक या कम अनुभवी अजगर डेवलपर जानता है कि इसे लिखते समय प्रतिलिपि तंत्र का अभाव है

 a = [0] b = a b[0] = 1 print(a, b) # -> [1], [1] 

फिर निम्न कोड का उत्पादन क्या होगा?

 b = a * 2 b[0] = 2 print(a, b) 

इस मामले में अजगर कम से कम आश्चर्य के सिद्धांत पर काम करता है: चर में हमारे पास एक इकाई है, अर्थात बी को घोषित किया जा सकता है और कैसे

 b = [1] * 2 

इस मामले में व्यवहार समान होगा:

 b = a * 2 b[0] = 2 print(a, b) # -> [1], [2, 1] 

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

 row = [0] * 2 matrix = [row] * 2 print(matrix) # -> [[0, 0], [0, 0]] matrix[0][0] = 1 print(matrix) # -> [[1, 0], [1, 0]] 

इस मामले में आपकी मदद करने के लिए सूची जनरेटर और सुन्न।

सूचियों को जोड़ा जा सकता है और यहां तक ​​कि वेतन वृद्धि भी की जा सकती है, और कोई भी दाईं ओर हो सकता है:

 a = [0] a += (1,) a += {2} a += "ab" a += {1: 2} print(a) # -> [0, 1, 2, 'a', 'b', 1] ,     #       

एक चाल के साथ प्रश्न (एक साक्षात्कार के लिए): अजगर में, मापदंडों को संदर्भ या मूल्य से पारित किया जाता है?

 def inc(a): a += 1 return a a = 5 print(inc(a)) print(a) # -> 5 

जैसा कि हम देखते हैं, फ़ंक्शन बॉडी में मूल्य में परिवर्तन से इसके बाहर की वस्तु का मूल्य नहीं बदला है, इससे हम यह निष्कर्ष निकाल सकते हैं कि मान मान से पारित किए जाते हैं और निम्नलिखित कोड लिखते हैं:

 def appended(a): a += [1] return a a = [5] print(appended(a)) # -> [5, 1] print(a) # -> [5, 1] 

C ++ जैसी भाषाओं में स्टैक पर और डायनेमिक मेमोरी में संग्रहित चर होते हैं। जब फ़ंक्शन को बुलाया जाता है, तो हम सभी तर्क को स्टैक पर रख देते हैं, जिसके बाद हम फ़ंक्शन पर नियंत्रण स्थानांतरित करते हैं। वह स्टैक पर चर के आकार और ऑफसेट को जानती है, इसलिए वह उनकी सही व्याख्या कर सकती है।
उसी समय, हमारे पास दो विकल्प हैं: स्टैक पर चर की मेमोरी को कॉपी करें या ऑब्जेक्ट को डायनेमिक मेमोरी (या स्टैक के उच्च स्तर पर) में संदर्भ दें।
जाहिर है, जब फ़ंक्शन स्टैक पर मान बदलते हैं, तो डायनेमिक मेमोरी में मान नहीं बदलेंगे, और संदर्भ द्वारा मेमोरी क्षेत्र को बदलते समय, हम साझा मेमोरी को क्रमशः संशोधित करते हैं, उसी मेमोरी क्षेत्र के सभी लिंक नए मूल्य को "देखेंगे"।

अजगर में, उन्होंने एक समान तंत्र को छोड़ दिया, प्रतिस्थापन वस्तु के साथ चर नाम का असाइनमेंट तंत्र है, उदाहरण के लिए, जब एक चर बनाते हैं:

 var = "john" 

दुभाषिया ऑब्जेक्ट "जॉन" और "नाम" संस्करण बनाता है, और फिर दिए गए नाम के साथ ऑब्जेक्ट को जोड़ता है।
जब कोई फ़ंक्शन कहा जाता है, तो कोई भी नई ऑब्जेक्ट नहीं बनाई जाती है, इसके बजाय, एक नाम इसके दायरे में बनाया जाता है जो किसी मौजूदा ऑब्जेक्ट से जुड़ा होता है।
लेकिन अजगर में परस्पर और अपरिवर्तनीय प्रकार होते हैं। दूसरे, उदाहरण के लिए, संख्याएं शामिल हैं: अंकगणितीय संचालन के दौरान, मौजूदा ऑब्जेक्ट नहीं बदलते हैं, लेकिन एक नई वस्तु बनाई जाती है, जिसके साथ मौजूदा नाम फिर जुड़ा हुआ है। यदि, इसके बाद, एक भी नाम पुरानी वस्तु से जुड़ा नहीं है, तो इसे लिंक गिनती तंत्र का उपयोग करके हटा दिया जाएगा।
यदि नाम चर प्रकार के एक चर के साथ जुड़ा हुआ है, तो इसके साथ संचालन के दौरान ऑब्जेक्ट की मेमोरी बदल जाती है; तदनुसार, इस मेमोरी क्षेत्र से जुड़े सभी नाम परिवर्तनों को "देखते हैं"।

आप इसके बारे में दस्तावेज़ीकरण में पढ़ सकते हैं, जो यहां और अधिक विवरण में वर्णित है ।

एक और उदाहरण:

 a = [1, 2, 3, 4, 5] def rev(l): l.reverse() return l l = a print(a, l) # -> [1, 2, 3, 4, 5], [1, 2, 3, 4, 5] l = rev(l) print(a, l) # -> [5, 4, 3, 2, 1], [5, 4, 3, 2, 1] 

लेकिन क्या होगा अगर हमने फ़ंक्शन के बाहर चर को बदलने का फैसला किया है? इस मामले में, वैश्विक संशोधक हमारी मदद करेगा:

 def change(): global a a += 1 a = 5 change() print(a) 

नोट: यह मत करो (नहीं, गंभीरता से, अपने कार्यक्रमों में वैश्विक चर का उपयोग न करें, और विशेष रूप से अपने में नहीं)। फ़ंक्शन से कुछ मान वापस करना बेहतर है:

 def func(a, b): return a + 1, b + 1 

हालांकि, अजगर में एक और गुंजाइश और संबंधित कीवर्ड है:

 def private(value=None): def getter(): return value def setter(v): nonlocal value value = v return getter, setter vget, vset = private(42) print(vget()) # -> 42 vset(0) print(vget()) # -> 0 

इस उदाहरण में, हमने एक वैरिएबल बनाया है जिसे बदला जा सकता है (और जिसका मूल्य प्राप्त किया गया है) केवल विधियों के माध्यम से, आप कक्षाओं में एक समान तंत्र का उपयोग कर सकते हैं:

 def private(value=None): def getter(): return value def setter(v): nonlocal value value = v return getter, setter class Person: def __init__(self, name): self.getid, self.setid = private(name) adam = Person("adam") print(adam.getid()) print(adam.setid("john")) print(adam.getid()) print(dir(adam)) 

लेकिन शायद अपने आप को __getattr__ , __setattr__ की संपत्तियों या परिभाषा तक सीमित करना बेहतर होगा।

आप __delattr__ को भी परिभाषित कर सकते हैं।

अजगर की एक और विशेषता विशेषता प्राप्त करने के लिए दो तरीकों की उपस्थिति है: __getattr__ और __getattribute__ ।

उनमें क्या अंतर है? पहले को केवल तभी बुलाया जाता है जब कक्षा में विशेषता नहीं मिली थी, और दूसरा बिना शर्त है। यदि दोनों को कक्षा में घोषित किया जाता है, तो __getattr__ को केवल तभी कहा जाता है, जब इसे __getattribute__ में स्पष्ट रूप से कहा जाता है या यदि __getattribute__ ने एक AttributeError उठाया है।

 class Person(): def __getattr__(self, item): print("__getattr__") if item == "name": return "john" raise AttributeError def __getattribute__(self, item): print("__getattribute__") raise AttributeError person = Person() print(person.name) # -> __getattribute__ # -> __getattr__ # -> john 

और अंत में, कैसे अजगर स्वतंत्र रूप से चर और scopes हेरफेर का एक उदाहरण:

  e = 42 try: 1 / 0 except Exception as e: pass print(e) # -> NameError: name 'e' is not defined 

यह, वैसे, शायद एकमात्र उदाहरण है जहां दूसरा अजगर तीसरे से बेहतर है, क्योंकि यह आउटपुट है:

  ... print(e) # -> float division by zero