Perché due elenchi identici hanno un footprint di memoria diverso?

Ho creato due elenchi l1e l2, ciascuno con un metodo di creazione diverso:

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))

Ma l'output mi ha sorpreso:

Size of l1 = 144
Size of l2 = 192

L'elenco creato con una comprensione dell'elenco ha una dimensione maggiore in memoria, ma altrimenti i due elenchi sono identici in Python.

Perché? È una cosa interna di CPython o qualche altra spiegazione?

Quando scrivi [None] * 10, Python sa che avrà bisogno di un elenco di esattamente 10 oggetti, quindi alloca esattamente quello.

Quando si utilizza la comprensione di un elenco, Python non sa quanto sarà necessario. Quindi aumenta gradualmente l'elenco man mano che vengono aggiunti elementi. Per ogni riallocazione alloca più spazio di quanto è immediatamente necessario, in modo da non dover riallocare per ogni elemento. È probabile che l'elenco risultante sia leggermente più grande del necessario.

È possibile visualizzare questo comportamento quando si confrontano elenchi creati con dimensioni simili:

>>> 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

Puoi vedere che il primo metodo alloca proprio ciò che è necessario, mentre il secondo cresce periodicamente. In questo esempio, alloca abbastanza per 16 elementi e ha dovuto riallocare al raggiungimento del 17 °.

Come notato in questa domanda, la comprensione della lista usa list.appendsotto il cofano, quindi chiamerà il metodo di ridimensionamento della lista, che si sovrallocata.

Per dimostrarlo a te stesso, puoi effettivamente utilizzare il disdissasembler:

>>> 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
>>>

Notare il LIST_APPENDcodice operativo nello smontaggio <listcomp>dell'oggetto codice. Dai documenti :

LIST_APPEND (i)

Chiamate list.append(TOS[-i], TOS). Utilizzato per implementare la comprensione dell'elenco.

Ora, per l'operazione di ripetizione dell'elenco, abbiamo un suggerimento su cosa sta succedendo se consideriamo:

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

Quindi, sembra essere in grado di allocare esattamente la dimensione. Guardando il codice sorgente , vediamo che è esattamente quello che succede:

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);

Vale a dire, qui: size = Py_SIZE(a) * n;. Il resto delle funzioni riempie semplicemente l'array.

Nessuno è un blocco di memoria, ma non è una dimensione predefinita. Inoltre, vi è una spaziatura aggiuntiva in una matrice tra gli elementi della matrice. Puoi vederlo tu stesso eseguendo:

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

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

Che non totalizza la dimensione di l2, ma piuttosto è inferiore.

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

E questo è molto più grande di un decimo della dimensione di l1.

I numeri dovrebbero variare a seconda sia dei dettagli del sistema operativo sia dei dettagli dell'utilizzo corrente della memoria nel sistema operativo. La dimensione di [Nessuno] non può mai essere maggiore della memoria adiacente disponibile in cui è impostata la memorizzazione per la variabile e potrebbe essere necessario spostare la variabile se successivamente viene allocata dinamicamente per essere più grande.