¿Por qué dos listas idénticas tienen una huella de memoria diferente?

Creé dos listas l1y l2, pero cada una con un método de creación diferente:

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

Pero la salida me sorprendió:

Size of l1 = 144
Size of l2 = 192

La lista creada con una comprensión de la lista es de mayor tamaño en la memoria, pero las dos listas son idénticas en Python de lo contrario.

¿Porqué es eso? ¿Es esto algo interno de CPython, o alguna otra explicación?

Cuando escribe [None] * 10, Python sabe que necesitará una lista de exactamente 10 objetos, por lo que asigna exactamente eso.

Cuando utiliza una lista de comprensión, Python no sabe cuánto necesitará. Por lo tanto, gradualmente crece la lista a medida que se agregan elementos. Para cada reasignación, asigna más espacio del que se necesita inmediatamente, de modo que no tiene que reasignarse para cada elemento. Es probable que la lista resultante sea algo más grande de lo necesario.

Puede ver este comportamiento al comparar listas creadas con tamaños similares:

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

Puede ver que el primer método asigna exactamente lo que se necesita, mientras que el segundo crece periódicamente. En este ejemplo, asigna suficiente para 16 elementos, y tuvo que reasignarse al llegar al 17.

Como se señaló en esta pregunta, la comprensión de la lista se utiliza list.appenddebajo del capó, por lo que llamará al método de cambio de tamaño de la lista, que se sobreasigna.

Para demostrarte esto a ti mismo, puedes usar el disdesensamblador:

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

Observe el LIST_APPENDcódigo de operación en el desmontaje del <listcomp>objeto de código. De los documentos :

LIST_APPEND (i)

Llamadas list.append(TOS[-i], TOS). Se usa para implementar listas de comprensión.

Ahora, para la operación de repetición de lista, tenemos una pista sobre lo que está sucediendo si consideramos:

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

Entonces, parece ser capaz de asignar exactamente el tamaño. Mirando el código fuente , vemos que esto es exactamente lo que sucede:

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

Es decir, aquí: size = Py_SIZE(a) * n;. El resto de las funciones simplemente llena la matriz.

Ninguno es un bloque de memoria, pero no es un tamaño especificado previamente. Además de eso, hay un espacio adicional en una matriz entre los elementos de la matriz. Puede ver esto usted mismo ejecutando:

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

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

Lo que no totaliza el tamaño de l2, sino que es menor.

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

Y esto es mucho mayor que una décima parte del tamaño de l1.

Sus números deben variar según los detalles de su sistema operativo y los detalles del uso de memoria actual en su sistema operativo. El tamaño de [Ninguno] nunca puede ser mayor que la memoria adyacente disponible donde la variable está configurada para ser almacenada, y la variable puede tener que moverse si luego se asigna dinámicamente para que sea más grande.