सूची समझ से थोड़ा अधिक मेमोरी का उपयोग करता है

Question 1

इसलिए मैं listवस्तुओं के साथ खेल रहा था और थोड़ी अजीब बात यह पाई listगई कि अगर list()इसके साथ बनाया गया है, तो सूची बोध की तुलना में अधिक स्मृति का उपयोग होता है? मैं पायथन 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

से डॉक्स :

सूचियों का निर्माण कई तरीकों से किया जा सकता है:

खाली सूची को दर्शाने के लिए चौकोर कोष्ठकों का उपयोग करना: []

वर्ग कोष्ठक का उपयोग करना, अल्पविराम के साथ आइटम को अलग: [a],[a, b, c]

एक सूची समझ का उपयोग करना: [x for x in iterable]

टाइप कंस्ट्रक्टर का उपयोग करना: list()याlist(iterable)

लेकिन ऐसा लगता है कि list()इसका उपयोग करने से अधिक मेमोरी का उपयोग होता है।

और जितना listबड़ा होता है, खाई बढ़ती जाती है।

ऐसा क्यूँ होता है?

अद्यतन # 1

पायथन 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

अद्यतन # 2

पायथन 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

मुझे लगता है कि आप ओवर-आवंटन पैटर्न देख रहे हैं यह स्रोत से एक नमूना है :

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

0-88 लंबाई के सूची बोध के आकारों को प्रिंट करते हुए आप पैटर्न मैच देख सकते हैं:

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

परिणाम (प्रारूप है (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))

ओवर-आवंटन प्रदर्शन कारणों के लिए किया जाता है जिससे सूचियों को हर विकास (बेहतर परिशोधित प्रदर्शन) के साथ अधिक मेमोरी आवंटित किए बिना बढ़ने की अनुमति मिलती है ।

सूची समझ का उपयोग करने के साथ अंतर का एक संभावित कारण, यह है कि सूची की समझ उत्पन्न सूची के आकार की गणना नहीं कर सकती है, लेकिन list() कर सकती है। इसका मतलब यह है कि समझ लगातार बढ़ेगी क्योंकि यह ओवर-एलोकेशन का उपयोग करके इसे भरता है जब तक कि इसे अंतिम रूप से नहीं भरा जाता है।

यह संभव है कि एक बार किए गए अप्रयुक्त नोड्स के साथ ओवर-आवंटन बफर नहीं बढ़ेगा (वास्तव में, ज्यादातर मामलों में यह अभ्यस्त है, जो ओवर-आवंटन उद्देश्य को हरा देगा)।

list()हालाँकि, कुछ बफर को सूची के आकार से जोड़ सकते हैं क्योंकि यह अंतिम सूची आकार को पहले से जानता है।

एक और समर्थन सबूत, स्रोत से भी, जो हम देखते हैं सूचीLIST_APPENDlist.resize बोध को , जो उपयोग का संकेत देता है , जो बदले में पूर्व-आवंटन बफर का उपभोग करने का संकेत देता है बिना यह जाने कि यह कितना भरा जाएगा। यह आपके द्वारा देखे जा रहे व्यवहार के अनुरूप है।

निष्कर्ष निकालने के लिए, list()सूची आकार के एक फ़ंक्शन के रूप में अधिक नोड्स को पूर्व-आवंटित करेगा

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

सूची की समझ सूची के आकार को नहीं जानती है, इसलिए यह अपग्रेड ऑपरेशन का उपयोग करता है क्योंकि यह बढ़ता है, पूर्व-आवंटन बफर को कम करता है:

# 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

उस भयानक अजगर को समझने में मेरी मदद करने के लिए सभी को धन्यवाद।

मैं यह सवाल नहीं करना चाहता कि बड़े पैमाने पर (इसीलिए मैं उत्तर पोस्ट कर रहा हूं), बस अपने विचारों को दिखाना और साझा करना चाहता हूं।

जैसा कि @ReutSharabani ने सही उल्लेख किया: "सूची () निश्चित रूप से सूची आकार निर्धारित करता है"। आप इसे उस ग्राफ से देख सकते हैं।

जब आप appendया सूची बोध का उपयोग करते हैं, तो आपके पास हमेशा कुछ प्रकार की सीमाएं होती हैं जो कुछ बिंदु तक पहुंचने पर फैली होती हैं। और आपके साथ list()लगभग समान सीमाएं हैं, लेकिन वे तैर रहे हैं।

अपडेट करें

तो @ReutSharabani , @tavo , @SvenFestersen को धन्यवाद

योग करने के लिए: list()उपदेश मेमोरी सूची के आकार पर निर्भर करती है, सूची की समझ ऐसा नहीं कर सकती है (यह आवश्यकता होने पर अधिक मेमोरी का अनुरोध करती है, जैसे .append())। इसलिए list()अधिक मेमोरी स्टोर करें।

एक और ग्राफ, जो list()उपदेशात्मक स्मृति को दर्शाता है । इसलिए ग्रीन लाइन list(range(830))तत्व द्वारा तत्व को जोड़ती है और थोड़ी देर के लिए स्मृति नहीं बदलती है।

अद्यतन २

@Barmar के रूप में, नीचे टिप्पणी में बताया गया है list()मुझे तेजी से सूची समझ से, चाहिए तो मैं भागा timeit()साथ number=1000की लंबाई के लिए listसे 4**0करने के लिए 4**10और परिणाम हैं