Warum Tupeln nehmen weniger Platz im Speicher als Listen?

Nehme ich tiefer in die CPython codebase, damit wir sehen können, wie sich die Größen tatsächlich berechnet. In Ihre spezifischen Beispiel, keine Zuweisungen durchgeführt wurden, also werde ich nicht berühren, dass.

Werde ich für die Verwendung von 64-bit-Werte hier, wie Sie sind.

Größe für lists berechnet sich aus der folgenden Funktion, list_sizeof:

static PyObject *
list_sizeof(PyListObject *self)
{
    Py_ssize_t res;

    res = _PyObject_SIZE(Py_TYPE(self)) + self->allocated * sizeof(void*);
    return PyInt_FromSsize_t(res);
}

Hier Py_TYPE(self) ist ein makro, das packt die ob_type von self (Rückkehr PyList_Type), während _PyObject_SIZE ist ein weiteres makro, das packt tp_basicsize von diesem Typ. tp_basicsize berechnet als sizeof(PyListObject) wo PyListObject ist die Instanz-struct.

Den PyListObject - Struktur hat drei Felder:

PyObject_VAR_HEAD     # 24 bytes 
PyObject **ob_item;   #  8 bytes
Py_ssize_t allocated; #  8 bytes

diese Kommentare haben (die ich gekürzt) erklären, was Sie sind, Folgen Sie den obigen link, um Sie zu Lesen. PyObject_VAR_HEAD erweitert, die in drei 8-byte-Felder (ob_refcount, ob_type und ob_size) so ein 24 byte-Beitrag.

So jetzt res ist:

sizeof(PyListObject) + self->allocated * sizeof(void*)

oder:

40 + self->allocated * sizeof(void*)

Wenn Sie in der Liste Instanz hat Elemente zugeordnet sind. der zweite Teil errechnet sich Ihr Beitrag. self->allocated, wie der name schon sagt, hält die Anzahl der zugewiesenen Elemente.

Ohne Elemente, die Größe der Listen berechnet werden:

>>> [].__sizeof__()
40

ich.e die Größe der Instanz-struct.

tuple Objekte definieren nicht ein tuple_sizeof Funktion. Stattdessen nutzen Sie object_sizeof zu berechnen, Ihre Größe:

static PyObject *
object_sizeof(PyObject *self, PyObject *args)
{
    Py_ssize_t res, isize;

    res = 0;
    isize = self->ob_type->tp_itemsize;
    if (isize > 0)
        res = Py_SIZE(self) * isize;
    res += self->ob_type->tp_basicsize;

    return PyInt_FromSsize_t(res);
}

Diese, wie für lists, schnappt sich die tp_basicsize und, wenn das Objekt einen nicht-null - tp_itemsize (D. H. es hat die variable-Länge-Instanzen), es multipliziert die Anzahl der Elemente im Tupel (die er bekommt über Py_SIZE) mit tp_itemsize.

tp_basicsize wieder verwendet sizeof(PyTupleObject) wo die PyTupleObject struct enthält:

PyObject_VAR_HEAD       # 24 bytes 
PyObject *ob_item[1];   # 8  bytes

So, ohne alle Elemente (d.h. Py_SIZE zurück 0) die Größe des leeren Tupel ist gleich sizeof(PyTupleObject):

>>> ().__sizeof__()
24

nicht wahr? Nun, hier ist eine kuriosität, die ich habe nicht gefunden, eine Erklärung für die tp_basicsize von tuples ist eigentlich wie folgt berechnet:

sizeof(PyTupleObject) - sizeof(PyObject *)

warum eine zusätzliche 8 bytes entfernt ist tp_basicsize ist etwas, was ich noch nicht herausfinden können. (Siehe MSeifert Kommentar für eine mögliche Erklärung)

Aber, das ist im Grunde der Unterschied in Ihre spezifischen Beispiel. lists auch halten, um eine Anzahl der zugeordneten Elemente, die hilft, festzustellen, wenn über-reservieren Sie wieder.

Nun, wenn zusätzliche Elemente Hinzugefügt werden, Listen zu tun, in der Tat diese über-Allokation zu erreichen, um O(1) hängt. Diese Ergebnisse in größeren Größen als MSeifert ist, deckt schön in seiner Antwort.

Die Größe der Tupel wird ein Präfix vorangestellt, das heißt an Tupel Initialisierung der Dolmetscher genügend Platz für die enthaltenen Daten, und das ist das Ende, was es ist unveränderlich (kann nicht geändert werden), in der Erwägung, dass eine Liste ist ein veränderliches Objekt daher impliziert die dynamische Zuweisung von Speicher, um zu vermeiden, zuweisen von Speicherplatz jedes mal, wenn Sie anfügen oder ändern Sie die Liste ( genügend Raum enthalten, werden die geänderten Daten und kopieren der Daten), weist er den zusätzlichen Raum für Zukunft Anhängen, änderungen, ... , dass ziemlich viel bringt es auf.