Résumé
Les tuples ont tendance à mieux performer que les listes dans presque toutes les catégories:
1) Les tuples peuvent être pliés en permanence .
2) Les tuples peuvent être réutilisés au lieu d'être copiés.
3) Les tuples sont compacts et n'allouent pas trop.
4) Les tuples font directement référence à leurs éléments.
Les tuples peuvent être pliés en permanence
Des tuples de constantes peuvent être précalculés par l'optimiseur de judas de Python ou l'optimiseur AST. Les listes, en revanche, se construisent à partir de zéro:
>>> 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
Les tuples n'ont pas besoin d'être copiés
La course tuple(some_tuple)revient immédiatement. Les tuples étant immuables, ils ne doivent pas être copiés:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
En revanche, list(some_list)nécessite que toutes les données soient copiées dans une nouvelle liste:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
Les tuples ne surallouent pas
Étant donné que la taille d'un tuple est fixe, il peut être stocké de manière plus compacte que les listes qui doivent être surallouées pour rendre les opérations append () efficaces.
Cela donne aux tuples un bel avantage d'espace:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
Voici le commentaire d' Objects / listobject.c qui explique ce que font les listes:
/* 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.
*/
Les tuples se réfèrent directement à leurs éléments
Les références aux objets sont incorporées directement dans un objet tuple. En revanche, les listes ont une couche supplémentaire d'indirection vers un tableau externe de pointeurs.
Cela donne aux tuples un petit avantage de vitesse pour les recherches indexées et le déballage:
$ 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
Voici comment le tuple (10, 20)est stocké:
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;
Voici comment la liste [10, 20]est stockée:
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;
Notez que l'objet tuple incorpore directement les deux pointeurs de données tandis que l'objet liste possède une couche supplémentaire d'indirection vers un tableau externe contenant les deux pointeurs de données.