Sommario
Le tuple tendono a funzionare meglio degli elenchi in quasi tutte le categorie:
1) Le tuple possono essere piegate costantemente .
2) Le tuple possono essere riutilizzate anziché copiate.
3) Le tuple sono compatte e non allocano eccessivamente.
4) Le tuple fanno riferimento direttamente ai loro elementi.
Le tuple possono essere piegate costantemente
Tuple di costanti possono essere pre-calcolate dall'ottimizzatore spioncino di Python o dall'ottimizzatore AST. Gli elenchi, d'altra parte, vengono creati da zero:
>>> 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
Le tuple non devono essere copiate
La corsa tuple(some_tuple)ritorna immediatamente se stessa. Poiché le tuple sono immutabili, non devono essere copiate:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
Al contrario, list(some_list)richiede che tutti i dati siano copiati in un nuovo elenco:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
Le tuple non allocano eccessivamente
Poiché le dimensioni di una tupla sono fisse, possono essere archiviate in modo più compatto rispetto agli elenchi che devono essere allocati eccessivamente per rendere efficienti le operazioni append () .
Questo dà alle tuple un bel vantaggio di spazio:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
Ecco il commento da Objects / listobject.c che spiega cosa stanno facendo gli elenchi:
/* 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.
*/
Le tuple si riferiscono direttamente ai loro elementi
I riferimenti agli oggetti sono incorporati direttamente in un oggetto tupla. Al contrario, gli elenchi hanno un ulteriore livello di riferimento indiretto a una matrice esterna di puntatori.
Ciò offre alle tuple un piccolo vantaggio di velocità per le ricerche indicizzate e il disimballaggio:
$ 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
Ecco come (10, 20)viene memorizzata la tupla :
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;
Ecco come [10, 20]viene memorizzato l'elenco :
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;
Si noti che l'oggetto tupla incorpora direttamente i due puntatori di dati mentre l'oggetto elenco ha un ulteriore livello di riferimento indiretto a un array esterno che contiene i due puntatori di dati.