Resumen
Las tuplas tienden a funcionar mejor que las listas en casi todas las categorías:
1) Las tuplas pueden doblarse constantemente .
2) Las tuplas pueden reutilizarse en lugar de copiarse.
3) Las tuplas son compactas y no se asignan en exceso.
4) Las tuplas hacen referencia directa a sus elementos.
Las tuplas pueden doblarse constantemente
Las tuplas de constantes pueden calcularse previamente mediante el optimizador de mirilla de Python o el optimizador AST. Las listas, por otro lado, se acumulan desde cero:
>>> 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
Las tuplas no necesitan ser copiadas
La ejecución tuple(some_tuple)vuelve inmediatamente a sí misma. Como las tuplas son inmutables, no es necesario copiarlas:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
Por el contrario, list(some_list)requiere que todos los datos se copien en una nueva lista:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
Las tuplas no se sobreasignan
Dado que el tamaño de una tupla es fijo, se puede almacenar de manera más compacta que las listas que deben sobreasignarse para que las operaciones append () sean eficientes.
Esto le da a las tuplas una buena ventaja de espacio:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
Aquí está el comentario de Objects / listobject.c que explica qué están haciendo las listas:
/* 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.
*/
Las tuplas se refieren directamente a sus elementos.
Las referencias a los objetos se incorporan directamente en un objeto de tupla. Por el contrario, las listas tienen una capa adicional de indirección a una matriz externa de punteros.
Esto le da a las tuplas una pequeña ventaja de velocidad para búsquedas indexadas y desempaque:
$ 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
Aquí es cómo la tupla (10, 20)se almacena:
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;
Aquí es cómo la lista [10, 20]se almacena:
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;
Tenga en cuenta que el objeto tupla incorpora los dos punteros de datos directamente, mientras que el objeto de la lista tiene una capa adicional de indirección a una matriz externa que contiene los dos punteros de datos.