पायथन: कोड की सिर्फ एक पंक्ति जोड़कर स्मृति की खपत को आधे से कैसे कम किया जाए?

हाय हब्र।

एक परियोजना में जहां एक बड़ी गतिशील सूची को स्टोर करना और संसाधित करना आवश्यक था, परीक्षक स्मृति की कमी के बारे में शिकायत करने लगे। कोड की केवल एक पंक्ति जोड़कर "थोड़ा रक्त" के साथ समस्या को ठीक करने का एक सरल तरीका नीचे वर्णित है। तस्वीर में परिणाम:


यह कैसे काम करता है, कट के नीचे जारी रहा।

एक साधारण "प्रशिक्षण" उदाहरण पर विचार करें - एक व्यक्ति के बारे में व्यक्तिगत डेटा युक्त DataItem वर्ग बनाएं, उदाहरण के लिए, नाम, आयु और पता।

class DataItem(object): def __init__(self, name, age, address): self.name = name self.age = age self.address = address 

"बच्चों का" सवाल यह है कि इस तरह की वस्तु स्मृति में कितना लेती है?

चलो माथे में समाधान का प्रयास करें:

 d1 = DataItem("Alex", 42, "-") print ("sys.getsizeof(d1):", sys.getsizeof(d1)) 

हमें 56 बाइट्स की प्रतिक्रिया मिलती है। यह थोड़ा सा लगता है, काफी संतुष्ट है।
हालाँकि, हम किसी अन्य ऑब्जेक्ट पर जाँच करते हैं जिसमें अधिक डेटा है:

 d2 = DataItem("Boris", 24, "In the middle of nowhere") print ("sys.getsizeof(d2):", sys.getsizeof(d2)) 

उत्तर फिर से 56 है। इस बिंदु पर, हम समझते हैं कि कुछ यहाँ ठीक नहीं है, और सब कुछ उतना सरल नहीं है जितना पहली नज़र में लगता है।

अंतर्ज्ञान हमें विफल नहीं करता है, और सब कुछ वास्तव में इतना सरल नहीं है। पायथन गतिशील टाइपिंग के साथ एक बहुत ही लचीली भाषा है, और अपने काम के लिए, यह बहुत अधिक अतिरिक्त डेटा संग्रहीत करता है। जो अपने आप में बहुत कुछ ले जाता है। बस एक उदाहरण के रूप में, sys.getizeof ("") 33 को लौटाएगा - हाँ, 33 से अधिक बाइट्स प्रति रिक्त रेखा के रूप में! और sys.getsizeof (1) एक पूर्णांक के लिए 24 - 24 बाइट्स लौटाएगा (मैं सी प्रोग्रामर को स्क्रीन से दूर जाने और आगे नहीं पढ़ने के लिए कहता हूं, ताकि सुंदर में विश्वास न खोएं)। अधिक जटिल तत्वों के लिए, जैसे कि एक शब्दकोश, sys.getsizeof (तानाशाह) (27) बाइट्स लौटाएगा - और यह एक खाली शब्दकोश के लिए है। मैंने आगे जारी नहीं रखा, मुझे आशा है कि सिद्धांत स्पष्ट है, और रैम निर्माताओं को अपने चिप्स बेचने की भी आवश्यकता है ।

लेकिन वापस हमारे DataItem वर्ग और "बच्चे" सवाल पर। ऐसी कक्षा को स्मृति में कितना समय लगता है? आरंभ करने के लिए, हम निम्न स्तर पर कक्षा की संपूर्ण सामग्री प्रदर्शित करते हैं:

 def dump(obj): for attr in dir(obj): print(" obj.%s = %r" % (attr, getattr(obj, attr))) 

यह फ़ंक्शन दिखाएगा कि "हुड के नीचे" क्या छिपा हुआ है ताकि सभी पायथन फ़ंक्शन (टाइपिंग, इनहेरिटेंस और अन्य उपहार) कार्य कर सकें।
परिणाम प्रभावशाली है:


यह सब कितना लेती है? गितुब पर एक ऐसा फ़ंक्शन था जो डेटा की वास्तविक मात्रा की गणना करता है, सभी वस्तुओं के लिए पुन: प्राप्त करने वाला गेटिसोफ़ कहता है।

 def get_size(obj, seen=None): # From https://goshippo.com/blog/measure-real-size-any-python-object/ # Recursively finds size of objects size = sys.getsizeof(obj) if seen is None: seen = set() obj_id = id(obj) if obj_id in seen: return 0 # Important mark as seen *before* entering recursion to gracefully handle # self-referential objects seen.add(obj_id) if isinstance(obj, dict): size += sum([get_size(v, seen) for v in obj.values()]) size += sum([get_size(k, seen) for k in obj.keys()]) elif hasattr(obj, '__dict__'): size += get_size(obj.__dict__, seen) elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)): size += sum([get_size(i, seen) for i in obj]) return size 

हम इसे आजमाते हैं:

 d1 = DataItem("Alex", 42, "-") print ("get_size(d1):", get_size(d1)) d2 = DataItem("Boris", 24, "In the middle of nowhere") print ("get_size(d2):", get_size(d2)) 

हमें क्रमशः ४६० और ४4४ बाइट्स मिलते हैं, जो सत्य की तरह अधिक है।

इस कार्य के बाद, कई प्रयोग किए जा सकते हैं। उदाहरण के लिए, मुझे आश्चर्य है कि यदि आप डेटाइम संरचनाओं को सूची में रखते हैं तो कितना डेटा लगेगा। Get_size ([d1]) फ़ंक्शन 532 बाइट देता है - जाहिर है यह "वही" 460 + कुछ ओवरहेड है। लेकिन get_size ([d1, d2]) 863 बाइट लौटाएगा - 460 से कम + 484 अलग से। और भी दिलचस्प get_size ([d1, d2, d1]) के लिए परिणाम है - हमें 871 बाइट्स मिलते हैं, बस थोड़ा और, अर्थात्। पायथन एक दूसरे के लिए एक ही वस्तु के लिए मेमोरी आवंटित नहीं करने के लिए पर्याप्त स्मार्ट है।

अब हम प्रश्न के दूसरे भाग की ओर मुड़ते हैं - क्या मेमोरी की खपत को कम करना संभव है? हाँ आप कर सकते हैं। पायथन एक दुभाषिया है, और हम किसी भी समय अपनी कक्षा का विस्तार कर सकते हैं, उदाहरण के लिए, एक नया क्षेत्र जोड़ें:

 d1 = DataItem("Alex", 42, "-") print ("get_size(d1):", get_size(d1)) d1.weight = 66 print ("get_size(d1):", get_size(d1)) 

यह बहुत अच्छा है, लेकिन अगर हमें इस कार्यक्षमता की आवश्यकता नहीं है , तो हम दुभाषिया को __slots__ निर्देश का उपयोग करके कक्षा की वस्तुओं को सूचीबद्ध करने के लिए मजबूर कर सकते हैं:

 class DataItem(object): __slots__ = ['name', 'age', 'address'] def __init__(self, name, age, address): self.name = name self.age = age self.address = address 

आप प्रलेखन ( RTFM ) में अधिक पढ़ सकते हैं, जो कहता है कि "__slots__ हमें डेटा सदस्यों (जैसे गुण) को स्पष्ट रूप से घोषित करने की अनुमति देता है और __dict__ और __weakref__ के निर्माण से इनकार करता है। __dict__ का उपयोग करके सहेजे गए स्थान महत्वपूर्ण हो सकते हैं "।
जाँच करें: हाँ, वास्तव में महत्वपूर्ण है, get_size (d1) रिटर्न ... 460 के बजाय 64 बाइट्स, अर्थात्। 7 गुना कम। एक बोनस के रूप में, वस्तुओं को लगभग 20% तेजी से बनाया जाता है (लेख का पहला स्क्रीनशॉट देखें)।

काश, वास्तविक उपयोग के साथ, स्मृति में इतना बड़ा लाभ अन्य ओवरहेड्स के कारण नहीं होगा। चलो बस तत्वों को जोड़कर 100,000 के लिए एक सरणी बनाएं, और मेमोरी खपत देखें:

 data = [] for p in range(100000): data.append(DataItem("Alex", 42, "middle of nowhere")) snapshot = tracemalloc.take_snapshot() top_stats = snapshot.statistics('lineno') total = sum(stat.size for stat in top_stats) print("Total allocated size: %.1f MB" % (total / (1024*1024))) 

हमारे पास __slots__ के बिना 16.8 एमबी और इसके साथ 6.9 एमबी है। बेशक 7 बार नहीं, लेकिन यहां तक ​​कि काफी अच्छी तरह से, यह देखते हुए कि कोड परिवर्तन न्यूनतम था।

अब कमियों के बारे में। __Slots__ को सक्रिय करना __dict__ सहित सभी तत्वों के निर्माण पर प्रतिबंध लगाता है, जिसका अर्थ है, उदाहरण के लिए, एक संरचना को जोंस में अनुवाद करने के लिए ऐसा कोड काम नहीं करेगा:

  def toJSON(self): return json.dumps(self.__dict__) 

लेकिन इसे ठीक करना आसान है, बस अपना तानाशाही प्रोग्राम बनाएं, सभी तत्वों को लूप में छांट कर:

  def toJSON(self): data = dict() for var in self.__slots__: data[var] = getattr(self, var) return json.dumps(data) 

कक्षा में नए चर को गतिशील रूप से जोड़ना असंभव होगा, लेकिन मेरे मामले में यह आवश्यक नहीं था।

और आज के लिए आखिरी परीक्षा। यह देखना दिलचस्प है कि पूरे कार्यक्रम में कितनी स्मृति है। प्रोग्राम के अंत में एक अंतहीन लूप जोड़ें ताकि यह बंद न हो, और विंडोज टास्क मैनेजर में मेमोरी खपत देखें।
__Slots__ के बिना:

16.8MB कुछ चमत्कार से बदल गया (संपादन - नीचे दिए गए चमत्कार का स्पष्टीकरण) 70 एमबी में (सी प्रोग्रामर उम्मीद है कि स्क्रीन पर अभी तक वापस नहीं आए हैं?)।

__Slots__ सक्षम होने के साथ:


6.9MB 27MB में बदल गया ... ठीक है, आखिरकार, हमने मेमोरी को बचाया, 70 के बजाय 27MB कोड की एक पंक्ति को जोड़ने के परिणाम के लिए इतना बुरा नहीं है।

संपादित करें : टिप्पणियों में (परीक्षण के लिए robert_ayrapetyan के लिए धन्यवाद), उन्होंने सुझाव दिया कि ट्रेसमेलॉक डिबगिंग लाइब्रेरी के उपयोग से बहुत अधिक अतिरिक्त मेमोरी हो जाती है। जाहिर है, यह प्रत्येक निर्मित वस्तु में अतिरिक्त तत्व जोड़ता है। यदि आप इसे अक्षम करते हैं, तो कुल मेमोरी खपत बहुत कम होगी, स्क्रीनशॉट 2 विकल्प दिखाता है:


अगर आपको और अधिक मेमोरी बचाने की आवश्यकता है, तो क्या करें? यह खस्ता पुस्तकालय का उपयोग करना संभव है, जो आपको सी-शैली संरचनाएं बनाने की अनुमति देता है, लेकिन मेरे मामले में इसे कोड के गहन शोधन की आवश्यकता होगी, और पहली विधि काफी पर्याप्त निकली।

यह अजीब है कि __slots__ के उपयोग की कभी भी हैबर पर विस्तार से जांच नहीं की गई है, मुझे उम्मीद है कि यह लेख इस अंतर को थोड़ा भर देगा।

एक निष्कर्ष के बजाय।
यह लेख पायथन के विरोधी विज्ञापन की तरह लग सकता है, लेकिन यह बिल्कुल भी नहीं है। पायथन बहुत विश्वसनीय है (आपको पायथन प्रोग्राम को छोड़ने के लिए बहुत कठिन प्रयास करना होगा), एक भाषा जो आसानी से पढ़ने योग्य और कोड लिखने में आसान है। ये लाभ कई मामलों में विपक्ष को पछाड़ते हैं, लेकिन यदि आपको अधिकतम प्रदर्शन और दक्षता की आवश्यकता है, तो आप C ++ में लिखे गए पुस्तकालयों का उपयोग कर सकते हैं जो डेटा के साथ बहुत तेज़ी से और कुशलता से काम करते हैं।

ध्यान देने के लिए आप सभी का धन्यवाद, और अच्छा कोड :)