Tại sao hai danh sách giống hệt nhau có dấu chân bộ nhớ khác nhau?

Tôi đã tạo hai danh sách l1và l2mỗi danh sách có một phương thức tạo khác nhau:

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

Nhưng đầu ra làm tôi ngạc nhiên:

Size of l1 = 144
Size of l2 = 192

Danh sách được tạo với sự hiểu biết danh sách là một kích thước lớn hơn trong bộ nhớ, nhưng hai danh sách này giống hệt nhau trong Python.

Tại sao vậy? Đây có phải là một số điều nội bộ CPython, hoặc một số giải thích khác?

Khi bạn viết [None] * 10, Python biết rằng nó sẽ cần một danh sách chính xác 10 đối tượng, vì vậy nó phân bổ chính xác điều đó.

Khi bạn sử dụng khả năng hiểu danh sách, Python không biết nó sẽ cần bao nhiêu. Vì vậy, nó dần dần phát triển danh sách như các yếu tố được thêm vào. Đối với mỗi lần tái phân bổ, nó phân bổ nhiều phòng hơn mức cần thiết ngay lập tức, do đó nó không phải phân bổ lại cho từng yếu tố. Danh sách kết quả có thể sẽ lớn hơn một chút so với cần thiết.

Bạn có thể thấy hành vi này khi so sánh các danh sách được tạo với kích thước tương tự:

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

Bạn có thể thấy rằng phương thức đầu tiên chỉ phân bổ những gì cần thiết, trong khi phương thức thứ hai phát triển theo định kỳ. Trong ví dụ này, nó phân bổ đủ cho 16 phần tử và phải phân bổ lại khi đạt đến thứ 17.

Như đã lưu ý trong câu hỏi này, việc hiểu danh sách sử dụng list.appenddưới mui xe, vì vậy nó sẽ gọi phương thức thay đổi kích thước danh sách, mà tổng thể hóa.

Để chứng minh điều này với chính mình, bạn thực sự có thể sử dụng trình giải mã 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
>>>

Lưu ý LIST_APPENDopcode trong việc tháo gỡ <listcomp>đối tượng mã. Từ các tài liệu :

LIST_APPEND (i)

Các cuộc gọi list.append(TOS[-i], TOS). Được sử dụng để thực hiện việc hiểu danh sách.

Bây giờ, đối với hoạt động lặp lại danh sách, chúng tôi có một gợi ý về những gì đang xảy ra nếu chúng tôi xem xét:

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

Vì vậy, nó dường như có thể phân bổ chính xác kích thước. Nhìn vào mã nguồn , chúng tôi thấy đây chính xác là những gì xảy ra:

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

Cụ thể, ở đây : size = Py_SIZE(a) * n;. Phần còn lại của các hàm chỉ đơn giản là điền vào mảng.

Không có khối bộ nhớ, nhưng nó không phải là kích thước được chỉ định trước. Ngoài ra, có một số khoảng cách bổ sung trong một mảng giữa các phần tử mảng. Bạn có thể thấy điều này bằng cách chạy:

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

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

Mà không tổng kích thước của l2, nhưng là ít hơn.

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

Và điều này là lớn hơn nhiều so với một phần mười của kích thước l1.

Số của bạn sẽ thay đổi tùy thuộc vào cả chi tiết của hệ điều hành và chi tiết về việc sử dụng bộ nhớ hiện tại trong hệ điều hành của bạn. Kích thước của [Không] không bao giờ có thể lớn hơn bộ nhớ liền kề khả dụng nơi biến được đặt thành được lưu trữ và biến có thể phải được di chuyển nếu sau đó nó được cấp phát động lớn hơn.