सारांश
Tuples सूचियों की तुलना में बेहतर प्रदर्शन करते हैं लगभग हर श्रेणी में :
1) ट्यूपल को लगातार मोड़ा जा सकता है ।
2) नकल के बजाय टुपल्स का पुन: उपयोग किया जा सकता है।
3) टुपल्स कॉम्पैक्ट हैं और ओवर-आवंटित नहीं हैं।
4) ट्यूपल्स सीधे अपने तत्वों को संदर्भित करते हैं।
ट्यूपल्स को लगातार मोड़ा जा सकता है
स्थिरांक के टप्ल्स को पायथन के पीपहोल ऑप्टिमाइज़र या एएसटी-ऑप्टिमाइज़र द्वारा पूर्वनिर्मित किया जा सकता है। दूसरी ओर, सूची, खरोंच से निर्मित हो जाती है:
>>> from dis import dis
>>> dis(compile("(10, 'abc')", '', 'eval'))
1 0 LOAD_CONST 2 ((10, 'abc'))
3 RETURN_VALUE
>>> dis(compile("[10, 'abc']", '', 'eval'))
1 0 LOAD_CONST 0 (10)
3 LOAD_CONST 1 ('abc')
6 BUILD_LIST 2
9 RETURN_VALUE
टुपल्स को कॉपी करने की आवश्यकता नहीं है
रनिंग tuple(some_tuple)रिटर्न तुरंत ही। चूंकि ट्यूप्स अपरिवर्तनीय हैं, उन्हें कॉपी करने की आवश्यकता नहीं है:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
इसके विपरीत, list(some_list)सभी डेटा को एक नई सूची में कॉपी करने की आवश्यकता होती है:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
टुपल्स अधिक आवंटित नहीं करते हैं
चूंकि टुपल का आकार निश्चित है, इसलिए इसे सूचियों की तुलना में अधिक कॉम्पैक्ट रूप से संग्रहीत किया जा सकता है, जिन्हें एपेंड () संचालन को कुशल बनाने के लिए ओवर-आवंटित करने की आवश्यकता होती है ।
इससे टुपल्स को एक अच्छा स्थान लाभ मिलता है:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
यहाँ ऑब्जेक्ट्स / listobject.c की टिप्पणी है जो बताती है कि सूचियाँ क्या कर रही हैं:
/* This over-allocates proportional to the list size, making room
* for additional growth. The over-allocation is mild, but is
* enough to give linear-time amortized behavior over a long
* sequence of appends() in the presence of a poorly-performing
* system realloc().
* The growth pattern is: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
* Note: new_allocated won't overflow because the largest possible value
* is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
*/
ट्यूपल्स सीधे अपने तत्वों को संदर्भित करते हैं
वस्तुओं के संदर्भ को सीधे एक टूप्ले ऑब्जेक्ट में शामिल किया जाता है। इसके विपरीत, सूचियों में बाहरी सरणी के संकेत के लिए अप्रत्यक्ष रूप से एक अतिरिक्त परत होती है।
यह ट्यूपल्स को अनुक्रमित लुक्स और अनपैकिंग के लिए एक छोटी गति का लाभ देता है:
$ python3.6 -m timeit -s 'a = (10, 20, 30)' 'a[1]'
10000000 loops, best of 3: 0.0304 usec per loop
$ python3.6 -m timeit -s 'a = [10, 20, 30]' 'a[1]'
10000000 loops, best of 3: 0.0309 usec per loop
$ python3.6 -m timeit -s 'a = (10, 20, 30)' 'x, y, z = a'
10000000 loops, best of 3: 0.0249 usec per loop
$ python3.6 -m timeit -s 'a = [10, 20, 30]' 'x, y, z = a'
10000000 loops, best of 3: 0.0251 usec per loop
यहाँ बताया गया है कि कैसे टपल (10, 20)को संग्रहीत किया जाता है:
typedef struct {
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
Py_ssize_t ob_size;
PyObject *ob_item[2]; /* store a pointer to 10 and a pointer to 20 */
} PyTupleObject;
यहाँ बताया गया है कि सूची कैसे [10, 20]संग्रहीत है:
PyObject arr[2]; /* store a pointer to 10 and a pointer to 20 */
typedef struct {
Py_ssize_t ob_refcnt;
struct _typeobject *ob_type;
Py_ssize_t ob_size;
PyObject **ob_item = arr; /* store a pointer to the two-pointer array */
Py_ssize_t allocated;
} PyListObject;
ध्यान दें कि टपल ऑब्जेक्ट दो डेटा पॉइंटर्स को सीधे शामिल करता है जबकि सूची ऑब्जेक्ट में दो डेटा पॉइंटर्स को पकड़े हुए एक बाहरी सरणी के लिए अप्रत्यक्ष की एक अतिरिक्त परत होती है।