पायथन में प्रयुक्त अनुकूलन: सूची और टपल

पायथन में, दो समान प्रकार हैं - सूची (सूची) और ट्यूपल (ट्यूपल)। दोनों के बीच सबसे प्रसिद्ध अंतर यह है कि ट्यूपल्स अपरिवर्तनीय हैं।

आप टपल में वस्तुओं को नहीं बदल सकते हैं:

>>> a = (1,2,3) >>> a[0] = 10 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment 

लेकिन आप एक टपल के अंदर उत्परिवर्तनीय वस्तुओं को संशोधित कर सकते हैं:

 >>> b = (1,[1,2,3],3) >>> b[1] [1, 2, 3] >>> b[1].append(4) >>> b (1, [1, 2, 3, 4], 3) 

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

tuples

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

आप ध्यान नहीं दे सकते हैं, लेकिन जब आप टुपल्स का उपयोग करते हैं:

• तर्कों या मापदंडों के साथ काम करें (उन्हें ट्यूपल्स के रूप में संग्रहीत किया जाता है)
• किसी फ़ंक्शन से दो या अधिक चर वापस करें
• एक शब्दकोश में iterate मूल्य कुंजियाँ
• स्ट्रिंग स्वरूपण का उपयोग करें

आमतौर पर, सबसे सरल स्क्रिप्ट हजारों टुपल्स का उपयोग करती है:

 >>> import gc >>> def type_stats(type_obj): ... count = 0 ... for obj in gc.get_objects(): ... if type(obj) == type_obj: ... count += 1 ... return count ... >>> type_stats(tuple) 3136 >>> type_stats(list) 659 >>> import pandas >>> type_stats(tuple) 6953 >>> type_stats(list) 2455 

खाली सूची बनाम खाली ट्यूपल्स

एक खाली नलिका एक सिंगलटन की तरह काम करती है, अर्थात चल रहे पायथन लिपि की स्मृति में हमेशा केवल एक खाली टपल होता है। सभी खाली tuples बस एक ही वस्तु को संदर्भित करते हैं, यह संभव है क्योंकि tuples अपरिवर्तनीय हैं। यह दृष्टिकोण बहुत सारी मेमोरी को बचाता है और खाली ट्यूपल्स के साथ काम करने की प्रक्रिया को गति देता है।

 >>> a = () >>> b = () >>> a is b True >>> id(a) 4409020488 >>> id(b) 4409020488 >>> #  CPython,  id    . 

लेकिन यह सूचियों के साथ काम नहीं करता है, क्योंकि इन्हें बदला जा सकता है:

 >>> a = [] >>> b = [] >>> a is b False >>> id(a) 4465566920 >>> id(b) 4465370632 

टुपल्स के लिए मेमोरी आवंटन का अनुकूलन

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

इस सूची को 20 समूहों में विभाजित किया गया है, जहां प्रत्येक समूह आकार n के tuples की एक सूची है, जहां n 0 से 20 तक है। प्रत्येक समूह 2,000 से अधिक tuples को संग्रहीत कर सकता है। पहला समूह केवल एक तत्व को संग्रहीत करता है और एक खाली टपल की सूची है।

 >>> a = (1,2,3) >>> id(a) 4427578104 >>> del a >>> b = (1,2,4) >>> id(b) 4427578104 

उपरोक्त उदाहरण में, हम देख सकते हैं कि स्मृति में a और b का एक ही पता है। यह इस तथ्य के कारण है कि हमने तुरंत उसी आकार का एक मुफ्त टपल लिया।

सूचियों के लिए मेमोरी आवंटन का अनुकूलन

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

 >>> a = [] >>> id(a) 4465566792 >>> del a >>> b = [] >>> id(b) 4465566792 

सूची का आकार बदलें

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

जब आप लूप में कई तत्वों को जोड़ने का प्रयास करते हैं तो यह अनुकूलन विशेष रूप से सहायक होता है।

सूची आकार वृद्धि पैटर्न कुछ इस तरह दिखता है: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88 ...

उदाहरण के लिए, यदि आप 8 तत्वों के साथ एक नए तत्व को सूची में जोड़ना चाहते हैं, तो इसमें कोई निःशुल्क सेल नहीं होगा और पायथन तुरंत अपने आकार को 16 कोशिकाओं तक विस्तारित करेगा, जहां उनमें से 9 उपयोगकर्ता के कब्जे और दिखाई देंगे।

पायथन आकार का सूत्र:

 >>> def get_new_size(n_items): ... new_size = n_items + (n_items // 2 ** 3) ... if n_items < 9: ... new_size += 3 ... else: ... new_size += 6 ... ... return new_size ... >>> get_new_size(9) 16 

गति

अगर हम गति में इन दो प्रकारों की तुलना करते हैं, तो अस्पताल में औसतन, ट्यूपल सूचियों की तुलना में थोड़ा तेज होते हैं। स्टैकओवरफ्लो पर गति के अंतर के लिए रेमंड हेटिंगर की एक महान व्याख्या है।

पुनश्च: मैं इस लेख का लेखक हूं, आप कोई भी प्रश्न पूछ सकते हैं।