Dlaczego dwie identyczne listy mają inny ślad pamięci?

Utworzyłem dwie listy l1i l2, ale każda z inną metodą tworzenia:

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

Ale wyjście mnie zaskoczyło:

Size of l1 = 144
Size of l2 = 192

Lista utworzona za pomocą funkcji list złożonych ma większy rozmiar w pamięci, ale w przeciwnym razie obie listy są identyczne w Pythonie.

Dlaczego? Czy to jakaś wewnętrzna sprawa CPythona, czy jakieś inne wyjaśnienie?

Kiedy piszesz [None] * 10 , Python wie, że będzie potrzebował listy dokładnie 10 obiektów, więc przydziela dokładnie to.

Kiedy używasz rozumienia list, Python nie wie, ile będzie potrzebować. Tak więc lista stopniowo rośnie w miarę dodawania elementów. Przy każdej ponownej alokacji przydziela więcej miejsca, niż jest natychmiast potrzebne, więc nie musi ponownie przydzielać dla każdego elementu. Wynikowa lista prawdopodobnie będzie nieco większa niż potrzeba.

Możesz zobaczyć to zachowanie, porównując listy utworzone o podobnych rozmiarach:

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

Możesz zobaczyć, że pierwsza metoda przydziela tylko to, co jest potrzebne, podczas gdy druga rośnie okresowo. W tym przykładzie przydziela wystarczającą ilość na 16 elementów i musiał ponownie przydzielić po osiągnięciu 17.

Jak zauważono w tym pytaniu, rozumienie listy jest używane list.appendpod maską, więc wywoła metodę zmiany rozmiaru listy, która z nadmierną alokacją.

Aby zademonstrować to sobie, możesz faktycznie użyć disdezasemblera:

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

Zwróć uwagę na LIST_APPENDopcode w dezasemblacji <listcomp>obiektu kodu. Z dokumentów :

LIST_APPEND (i)

Połączenia list.append(TOS[-i], TOS). Używane do implementacji list składanych.

Teraz, jeśli chodzi o operację powtarzania listy, mamy wskazówkę dotyczącą tego, co się dzieje, jeśli weźmiemy pod uwagę:

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

Wydaje się więc, że jest w stanie dokładnie przydzielić rozmiar. Patrząc na kod źródłowy , widzimy dokładnie, co się dzieje:

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

Mianowicie tutaj: size = Py_SIZE(a) * n;. Reszta funkcji po prostu wypełnia tablicę.

Żaden jest blokiem pamięci, ale nie ma wstępnie określonego rozmiaru. Oprócz tego istnieje dodatkowe odstępy w tablicy między elementami tablicy. Możesz to zobaczyć, uruchamiając:

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

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

Co nie sumuje rozmiaru l2, ale raczej jest mniejsze.

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

A to znacznie więcej niż jedna dziesiąta rozmiaru l1 .

Twoje liczby powinny się różnić w zależności zarówno od szczegółów systemu operacyjnego, jak i szczegółów bieżącego wykorzystania pamięci w systemie operacyjnym. Rozmiar [None] nigdy nie może być większy niż dostępna sąsiednia pamięć, w której zmienna ma być przechowywana, a zmienna może wymagać przeniesienia, jeśli zostanie później przydzielona dynamicznie, aby była większa.