Mengapa dua daftar identik memiliki jejak memori yang berbeda?

Saya membuat dua daftar l1dan l2, tetapi masing-masing dengan metode pembuatan yang berbeda:

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

Tapi hasilnya mengejutkan saya:

Size of l1 = 144
Size of l2 = 192

Daftar yang dibuat dengan pemahaman daftar adalah ukuran yang lebih besar dalam memori, tetapi kedua daftar tersebut identik dengan Python.

Mengapa demikian? Apakah ini masalah internal CPython, atau penjelasan lain?

Ketika Anda menulis [None] * 10, Python tahu bahwa ia akan membutuhkan daftar tepat 10 objek, sehingga mengalokasikannya dengan tepat.

Saat Anda menggunakan pemahaman daftar, Python tidak tahu berapa banyak yang dibutuhkan. Jadi secara bertahap tumbuh daftar sebagai elemen ditambahkan. Untuk setiap realokasi, ia mengalokasikan lebih banyak ruang daripada yang dibutuhkan segera, sehingga tidak harus merealokasi untuk setiap elemen. Daftar yang dihasilkan cenderung lebih besar dari yang dibutuhkan.

Anda dapat melihat perilaku ini saat membandingkan daftar yang dibuat dengan ukuran yang serupa:

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

Anda dapat melihat bahwa metode pertama mengalokasikan apa yang dibutuhkan, sedangkan metode kedua tumbuh secara berkala. Dalam contoh ini, ia mengalokasikan cukup untuk 16 elemen, dan harus realokasi ketika mencapai tanggal 17.

Seperti dicatat dalam pertanyaan ini , pemahaman daftar menggunakan di list.appendbawah tenda, sehingga akan memanggil metode daftar-ukuran, yang secara keseluruhan dialokasikan.

Untuk menunjukkan hal ini kepada diri sendiri, Anda dapat menggunakan 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
>>>

Perhatikan LIST_APPENDopcode dalam pembongkaran <listcomp>objek kode. Dari dokumen :

LIST_APPEND (i)

Panggilan list.append(TOS[-i], TOS). Digunakan untuk mengimplementasikan daftar pemahaman.

Sekarang, untuk operasi pengulangan daftar, kami memiliki petunjuk tentang apa yang terjadi jika kita mempertimbangkan:

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

Jadi, tampaknya untuk dapat persis mengalokasikan ukuran. Melihat kode sumber , kami melihat inilah yang terjadi:

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

Yaitu, di sini: size = Py_SIZE(a) * n;. Sisa fungsi hanya mengisi array.

Tidak ada yang merupakan blok memori, tetapi itu bukan ukuran yang ditentukan sebelumnya. Selain itu, ada beberapa spasi tambahan dalam array antara elemen array. Anda dapat melihatnya sendiri dengan menjalankan:

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

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

Yang tidak total ukuran l2, tetapi lebih sedikit.

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

Dan ini jauh lebih besar dari sepersepuluh ukuran l1.

Angka-angka Anda harus bervariasi tergantung pada detail sistem operasi Anda dan detail penggunaan memori saat ini di sistem operasi Anda. Ukuran [Tidak ada] tidak pernah bisa lebih besar dari memori yang berdekatan yang tersedia di mana variabel diatur untuk disimpan, dan variabel mungkin harus dipindahkan jika nanti secara dinamis dialokasikan menjadi lebih besar.