Ringkasan
Tuples cenderung berkinerja lebih baik daripada daftar di hampir setiap kategori:
1) Tuples dapat dilipat secara konstan .
2) Tuples dapat digunakan kembali alih-alih disalin.
3) Tuple kompak dan tidak mengalokasikan berlebihan.
4) Tuples mereferensikan elemen mereka secara langsung.
Tuples dapat dilipat secara konstan
Tupel konstanta dapat dihitung dengan pengoptimal lubang pengintai Python atau pengoptimal AST. Daftar, di sisi lain, bisa dibangun dari awal:
>>> 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
Tuples tidak perlu disalin
Menjalankan tuple(some_tuple)kembali segera dengan sendirinya. Karena tupel tidak dapat diubah, mereka tidak harus disalin:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
Sebaliknya, list(some_list)mengharuskan semua data untuk disalin ke daftar baru:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
Tuples tidak mengalokasikan secara berlebihan
Karena ukuran tuple ditetapkan, ia dapat disimpan lebih kompak daripada daftar yang perlu dialokasikan berlebihan untuk membuat operasi append () lebih efisien.
Ini memberi tuple keuntungan ruang yang bagus:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
Berikut adalah komentar dari Objects / listobject.c yang menjelaskan apa yang dilakukan daftar:
/* 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.
*/
Tuples merujuk langsung ke elemen mereka
Referensi ke objek digabungkan secara langsung dalam objek tuple. Sebaliknya, daftar memiliki lapisan tipuan ekstra ke array eksternal pointer.
Ini memberi tuple keuntungan kecepatan kecil untuk pencarian yang diindeks dan dibongkar:
$ 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
Ini adalah bagaimana tuple (10, 20)disimpan:
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;
Berikut cara penyimpanan daftar [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;
Perhatikan bahwa objek tuple menggabungkan dua pointer data secara langsung sementara objek daftar memiliki lapisan tipuan tambahan ke array eksternal yang memegang dua pointer data.