Чому два однакових списки мають різний слід пам’яті?

Я створив два списки 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 під кришкою, тому воно називатиме метод зміни розміру списку, який перевизначає.

Щоб продемонструвати це самому, ви можете реально скористатися disрозбірником:

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

Дзвінки 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] ніколи не може бути більшим, ніж наявна сусідня пам'ять, де змінна встановлена ​​для зберігання, і зміну, можливо, доведеться перенести, якщо вона згодом динамічно розподіляється, щоб бути більшою.