Zusammenfassung
Tupel schneiden in fast jeder Kategorie besser ab als Listen :
1) Tupel können konstant gefaltet werden .
2) Tupel können wiederverwendet anstatt kopiert werden.
3) Tupel sind kompakt und nicht zu viel zugeordnet.
4) Tupel verweisen direkt auf ihre Elemente.
Tupel können konstant gefaltet werden
Tupel von Konstanten können mit Pythons Gucklochoptimierer oder AST-Optimierer vorberechnet werden. Listen hingegen werden von Grund auf neu erstellt:
>>> 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
Tupel müssen nicht kopiert werden
Running tuple(some_tuple)kehrt sofort selbst zurück. Da Tupel unveränderlich sind, müssen sie nicht kopiert werden:
>>> a = (10, 20, 30)
>>> b = tuple(a)
>>> a is b
True
Im Gegensatz dazu list(some_list)müssen alle Daten in eine neue Liste kopiert werden:
>>> a = [10, 20, 30]
>>> b = list(a)
>>> a is b
False
Tupel werden nicht überbelegt
Da die Größe eines Tupels festgelegt ist, kann es kompakter gespeichert werden als Listen, die überbelegt werden müssen, um append () -Operationen effizient zu gestalten.
Dies gibt Tupeln einen schönen Platzvorteil:
>>> import sys
>>> sys.getsizeof(tuple(iter(range(10))))
128
>>> sys.getsizeof(list(iter(range(10))))
200
Hier ist der Kommentar von Objects / listobject.c , der erklärt, was Listen tun:
/* 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.
*/
Tupel beziehen sich direkt auf ihre Elemente
Verweise auf Objekte werden direkt in ein Tupelobjekt aufgenommen. Im Gegensatz dazu verfügen Listen über eine zusätzliche Indirektionsebene für ein externes Array von Zeigern.
Dies gibt Tupeln einen kleinen Geschwindigkeitsvorteil für indizierte Suchvorgänge und das Auspacken:
$ 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
So wird das Tupel (10, 20)gespeichert:
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;
So wird die Liste [10, 20]gespeichert:
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;
Beachten Sie, dass das Tupelobjekt die beiden Datenzeiger direkt enthält, während das Listenobjekt eine zusätzliche Indirektionsebene zu einem externen Array aufweist, das die beiden Datenzeiger enthält.