Warum haben zwei identische Listen einen unterschiedlichen Speicherbedarf?

Ich habe zwei Listen l1und l2, aber jeder mit einer anderen Erstellungsmethode:

import sys

l1 = [None] * 10
l2 = [None for _ in range(10)]

print('Size of l1 =', sys.getsizeof(l1))
print('Size of l2 =', sys.getsizeof(l2))

Aber die Ausgabe hat mich überrascht:

Size of l1 = 144
Size of l2 = 192

Die mit einem Listenverständnis erstellte Liste hat eine größere Größe im Speicher, ansonsten sind die beiden Listen in Python identisch.

Warum ist das so? Ist das eine CPython-interne Sache oder eine andere Erklärung?

Wenn Sie schreiben [None] * 10, weiß Python, dass es eine Liste mit genau 10 Objekten benötigt, also weist es genau das zu.

Wenn Sie ein Listenverständnis verwenden, weiß Python nicht, wie viel es benötigt. Daher wird die Liste schrittweise erweitert, wenn Elemente hinzugefügt werden. Für jede Neuzuweisung wird mehr Platz zugewiesen, als sofort benötigt wird, sodass nicht für jedes Element eine Neuzuweisung erforderlich ist. Die resultierende Liste ist wahrscheinlich etwas größer als nötig.

Sie können dieses Verhalten sehen, wenn Sie Listen vergleichen, die mit ähnlichen Größen erstellt wurden:

>>> sys.getsizeof([None]*15)
184
>>> sys.getsizeof([None]*16)
192
>>> sys.getsizeof([None for _ in range(15)])
192
>>> sys.getsizeof([None for _ in range(16)])
192
>>> sys.getsizeof([None for _ in range(17)])
264

Sie können sehen, dass die erste Methode genau das zuweist, was benötigt wird, während die zweite periodisch wächst. In diesem Beispiel werden 16 Elemente zugewiesen, und bei Erreichen des 17. Elements wurde eine Neuzuweisung vorgenommen.

Wie in dieser Frage erwähnt, wird das Listenverständnis list.appendunter der Haube verwendet, sodass die Methode zur Größenänderung der Liste aufgerufen wird, die insgesamt zugeordnet wird.

Um sich dies zu demonstrieren, können Sie den disDissasembler tatsächlich verwenden :

>>> code = compile('[x for x in iterable]', '', 'eval')
>>> import dis
>>> dis.dis(code)
  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x10560b810, file "", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_NAME                0 (iterable)
              8 GET_ITER
             10 CALL_FUNCTION            1
             12 RETURN_VALUE

Disassembly of <code object <listcomp> at 0x10560b810, file "", line 1>:
  1           0 BUILD_LIST               0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                 8 (to 14)
              6 STORE_FAST               1 (x)
              8 LOAD_FAST                1 (x)
             10 LIST_APPEND              2
             12 JUMP_ABSOLUTE            4
        >>   14 RETURN_VALUE
>>>

Beachten Sie den LIST_APPENDOpcode bei der Demontage des <listcomp>Codeobjekts. Aus den Dokumenten :

LIST_APPEND (i)

Anrufe list.append(TOS[-i], TOS). Wird verwendet, um Listenverständnisse zu implementieren.

Für die Listenwiederholungsoperation haben wir nun einen Hinweis darauf, was los ist, wenn wir Folgendes berücksichtigen:

>>> import sys
>>> sys.getsizeof([])
64
>>> 8*10
80
>>> 64 + 80
144
>>> sys.getsizeof([None]*10)
144

Es scheint also in der Lage zu sein , die Größe genau zuzuweisen. Wenn wir uns den Quellcode ansehen, sehen wir, dass genau dies passiert:

static PyObject *
list_repeat(PyListObject *a, Py_ssize_t n)
{
    Py_ssize_t i, j;
    Py_ssize_t size;
    PyListObject *np;
    PyObject **p, **items;
    PyObject *elem;
    if (n < 0)
        n = 0;
    if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n)
        return PyErr_NoMemory();
    size = Py_SIZE(a) * n;
    if (size == 0)
        return PyList_New(0);
    np = (PyListObject *) PyList_New(size);

Nämlich hier : size = Py_SIZE(a) * n;. Der Rest der Funktionen füllt einfach das Array.

Keiner ist ein Speicherblock, aber keine vorgegebene Größe. Darüber hinaus gibt es in einem Array einen zusätzlichen Abstand zwischen Array-Elementen. Sie können dies selbst sehen, indem Sie Folgendes ausführen:

for ele in l2:
    print(sys.getsizeof(ele))

>>>>16
16
16
16
16
16
16
16
16
16

Was nicht die Größe von l2 ergibt, sondern weniger ist.

print(sys.getsizeof([None]))
72

Und das ist viel mehr als ein Zehntel der Größe von l1.

Ihre Nummern sollten sowohl von den Details Ihres Betriebssystems als auch von den Details der aktuellen Speichernutzung in Ihrem Betriebssystem abhängen. Die Größe von [Keine] kann niemals größer sein als der verfügbare benachbarte Speicher, in dem die Variable gespeichert werden soll, und die Variable muss möglicherweise verschoben werden, wenn sie später dynamisch zugewiesen wird, um größer zu sein.