Resumo
As tuplas tendem a ter um desempenho melhor do que as listas em quase todas as categorias:
1) As tuplas podem ser dobradas constantemente .
2) As tuplas podem ser reutilizadas em vez de copiadas.
3) As tuplas são compactas e não superalocam.
4) Tuplas referenciam diretamente seus elementos.
As tuplas podem ser dobradas constantemente
Tuplas de constantes podem ser pré-computadas pelo otimizador de olho mágico do Python ou pelo otimizador AST. As listas, por outro lado, são criadas do 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
Tuplas não precisam ser copiadas
A execução tuple(some_tuple)retorna imediatamente a si mesma. Como as tuplas são imutáveis, elas não precisam ser copiadas:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
Por outro lado, list(some_list)exige que todos os dados sejam copiados para uma nova lista:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
Tuplas não superalocam
Como o tamanho de uma tupla é fixo, ele pode ser armazenado de forma mais compacta do que as listas que precisam ser superalocadas para tornar eficientes as operações append () .
Isso dá às tuplas uma boa vantagem de espaço:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
Aqui está o comentário de Objects / listobject.c que explica o que as listas estão fazendo:
/* 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.
*/
Tuplas se referem diretamente a seus elementos
Referências a objetos são incorporadas diretamente em um objeto de tupla. Por outro lado, as listas têm uma camada extra de indireção para uma matriz externa de ponteiros.
Isso fornece às tuplas uma pequena vantagem de velocidade para pesquisas indexadas e descompactação:
$ 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
Aqui está como a tupla (10, 20)é armazenada:
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;
Aqui está como a lista [10, 20]é armazenada:
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;
Observe que o objeto tupla incorpora os dois ponteiros de dados diretamente, enquanto o objeto de lista possui uma camada adicional de indireção a uma matriz externa que contém os dois ponteiros de dados.