Почему два одинаковых списка имеют разный объем памяти?

Я создал два списка l1и l2, но каждый со своим методом создания:

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

Но результат меня удивил:

Size of l1 = 144
Size of l2 = 192

Список, созданный с пониманием списка, имеет больший размер в памяти, но оба списка в Python идентичны.

Это почему? Это какая-то внутренняя часть CPython или какое-то другое объяснение?

Когда вы пишете [None] * 10, Python знает, что ему потребуется список из ровно 10 объектов, поэтому он выделяет именно это.

Когда вы используете понимание списка, Python не знает, сколько ему понадобится. Таким образом, список постепенно увеличивается по мере добавления элементов. Для каждого перераспределения он выделяет больше места, чем необходимо, так что ему не нужно перераспределять для каждого элемента. Результирующий список, вероятно, будет несколько больше, чем нужно.

Вы можете увидеть это поведение при сравнении списков, созданных с одинаковыми размерами:

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

Вы можете видеть, что первый метод выделяет только то, что нужно, а второй периодически увеличивается. В этом примере он выделяет достаточно для 16 элементов, и пришлось перераспределить при достижении 17-го.

Как уже отмечалось в этом вопросе, понимание списка используется list.appendпод капотом, поэтому он вызовет метод list-resize, который перераспределяется.

Чтобы продемонстрировать это себе, вы можете использовать disdisasembler:

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

Обратите внимание на LIST_APPENDкод операции при разборке <listcomp>объекта кода. Из документов :

LIST_APPEND (я)

Звонки list.append(TOS[-i], TOS). Используется для реализации списочных представлений.

Теперь, для операции повторения списка, у нас есть подсказка о том, что происходит, если мы рассмотрим:

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

Так что, похоже, можно точно выделить размер. Глядя на исходный код , мы видим, что именно это и происходит:

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

А именно здесь size = Py_SIZE(a) * n;. Остальные функции просто заполняют массив.

Ни один из них не является блоком памяти, но это не предопределенный размер. В дополнение к этому в массиве есть некоторый дополнительный интервал между элементами массива. Вы можете увидеть это сами, запустив:

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

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

Который не составляет размер l2, а скорее меньше.

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

И это намного больше, чем одна десятая размера l1.

Ваши номера должны отличаться в зависимости от деталей вашей операционной системы и сведений о текущем использовании памяти в вашей операционной системе. Размер [None] никогда не может быть больше доступной смежной памяти, в которой переменная установлена ​​для хранения, и переменная может быть перемещена, если впоследствии она динамически распределяется, чтобы быть больше.