list () sử dụng nhiều bộ nhớ hơn một chút so với khả năng hiểu danh sách

Question 1

Vì vậy, tôi đã chơi với listcác đồ vật và tìm thấy một điều kỳ lạ rằng nếu listđược tạo ra với list()nó sẽ sử dụng nhiều bộ nhớ hơn là khả năng hiểu danh sách? Tôi đang sử dụng Python 3.5.2

In [1]: import sys
In [2]: a = list(range(100))
In [3]: sys.getsizeof(a)
Out[3]: 1008
In [4]: b = [i for i in range(100)]
In [5]: sys.getsizeof(b)
Out[5]: 912
In [6]: type(a) == type(b)
Out[6]: True
In [7]: a == b
Out[7]: True
In [8]: sys.getsizeof(list(b))
Out[8]: 1008

Từ các tài liệu :

Danh sách có thể được xây dựng theo một số cách:

Sử dụng một cặp dấu ngoặc vuông để biểu thị danh sách trống: []

Sử dụng dấu ngoặc vuông, tách mục có dấu phẩy: [a],[a, b, c]

Sử dụng khả năng hiểu danh sách: [x for x in iterable]

Sử dụng hàm tạo kiểu: list()hoặclist(iterable)

Nhưng có vẻ như sử dụng list()nó sử dụng nhiều bộ nhớ hơn.

Và càng listlớn, khoảng cách càng tăng.

Tại sao điều này xảy ra?

CẬP NHẬT # 1

Kiểm tra với Python 3.6.0b2:

Python 3.6.0b2 (default, Oct 11 2016, 11:52:53) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.getsizeof(list(range(100)))
1008
>>> sys.getsizeof([i for i in range(100)])
912

CẬP NHẬT # 2

Kiểm tra với Python 2.7.12:

Python 2.7.12 (default, Jul  1 2016, 15:12:24) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.getsizeof(list(xrange(100)))
1016
>>> sys.getsizeof([i for i in xrange(100)])
920

Question 2

Tôi nghĩ rằng bạn đang thấy các mẫu phân bổ quá mức, đây là mẫu từ nguồn :

/* This over-allocates proportional to the list size, making room
 * for additional growth.  The over-allocation is mild, but is
 * enough to give linear-time amortized behavior over a long
 * sequence of appends() in the presence of a poorly-performing
 * system realloc().
 * The growth pattern is:  0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
 */

new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

In các kích thước của danh sách có độ dài từ 0-88, bạn có thể thấy các mẫu trùng khớp:

# create comprehensions for sizes 0-88
comprehensions = [sys.getsizeof([1 for _ in range(l)]) for l in range(90)]

# only take those that resulted in growth compared to previous length
steps = zip(comprehensions, comprehensions[1:])
growths = [x for x in list(enumerate(steps)) if x[1][0] != x[1][1]]

# print the results:
for growth in growths:
    print(growth)

Kết quả (định dạng là (list length, (old total size, new total size))):

(0, (64, 96)) 
(4, (96, 128))
(8, (128, 192))
(16, (192, 264))
(25, (264, 344))
(35, (344, 432))
(46, (432, 528))
(58, (528, 640))
(72, (640, 768))
(88, (768, 912))

Việc phân bổ quá mức được thực hiện vì lý do hiệu suất cho phép danh sách phát triển mà không cần phân bổ thêm bộ nhớ với mỗi lần tăng trưởng ( hiệu suất phân bổ tốt hơn ).

Một lý do có thể xảy ra cho sự khác biệt với việc sử dụng tính năng hiểu danh sách, đó là tính năng hiểu danh sách không thể tính toán một cách xác định kích thước của danh sách đã tạo, nhưng list()có thể. Điều này có nghĩa là sự hiểu biết sẽ liên tục phát triển danh sách khi nó lấp đầy nó bằng cách sử dụng phân bổ quá mức cho đến khi cuối cùng lấp đầy nó.

Có thể là sẽ không phát triển bộ đệm phân bổ quá mức với các nút được cấp phát không sử dụng sau khi hoàn thành (trên thực tế, trong hầu hết các trường hợp, điều đó sẽ không đạt được mục đích phân bổ quá mức).

list(), tuy nhiên, có thể thêm một số bộ đệm bất kể kích thước danh sách vì nó biết trước kích thước danh sách cuối cùng.

Một bằng chứng hỗ trợ khác, cũng từ nguồn, là chúng ta thấy cách gọi toàn bộ danh sáchLIST_APPEND , cho biết việc sử dụng, từ đó cho biết sử dụng list.resizebộ đệm phân bổ trước mà không biết bao nhiêu phần trăm của nó sẽ được lấp đầy. Điều này phù hợp với hành vi bạn đang thấy.

Để kết luận, list()sẽ phân bổ trước nhiều nút hơn như một chức năng của kích thước danh sách

>>> sys.getsizeof(list([1,2,3]))
60
>>> sys.getsizeof(list([1,2,3,4]))
64

Tính năng hiểu danh sách không biết kích thước danh sách vì vậy nó sử dụng các hoạt động nối thêm khi nó phát triển, làm cạn bộ đệm phân bổ trước:

# one item before filling pre-allocation buffer completely
>>> sys.getsizeof([i for i in [1,2,3]]) 
52
# fills pre-allocation buffer completely
# note that size did not change, we still have buffered unused nodes
>>> sys.getsizeof([i for i in [1,2,3,4]]) 
52
# grows pre-allocation buffer
>>> sys.getsizeof([i for i in [1,2,3,4,5]])
68

Question 3

Cảm ơn mọi người đã giúp tôi hiểu Python tuyệt vời đó.

Tôi không muốn đặt câu hỏi quá lớn (đó là lý do tại sao tôi đăng câu trả lời), chỉ muốn thể hiện và chia sẻ suy nghĩ của mình.

Như @ReutSharabani đã lưu ý chính xác: "danh sách () xác định kích thước danh sách". Bạn có thể thấy nó từ biểu đồ đó.

Khi bạn appendhoặc sử dụng khả năng hiểu danh sách, bạn luôn có một số loại ranh giới mở rộng khi bạn đến một thời điểm nào đó. Và với list()bạn gần như có ranh giới giống nhau, nhưng chúng đang trôi nổi.

CẬP NHẬT

Vì vậy, cảm ơn @ReutSharabani , @tavo , @SvenFestersen

Tóm lại: việc list()phân bổ trước bộ nhớ phụ thuộc vào kích thước danh sách, khả năng hiểu danh sách không thể làm được điều đó (nó yêu cầu thêm bộ nhớ khi cần, chẳng hạn .append()). Đó là lý do tại sao list()lưu trữ nhiều bộ nhớ hơn.

Một biểu đồ khác, hiển thị list()bộ nhớ phân bổ trước. Vì vậy, đường màu xanh lá cây hiển thị list(range(830))phần tử phụ theo phần tử và trong một thời gian bộ nhớ không thay đổi.

CẬP NHẬT 2

Như @Barmar đã lưu ý trong nhận xét bên dưới, list()tôi phải nhanh hơn khả năng hiểu danh sách, vì vậy tôi đã chạy timeit()với number=1000độ dài listtừ 4**0đến 4**10và kết quả là