सूचियों को समाशोधन के विभिन्न तरीके


159

क्या आप पाइथन में एक सूची साफ़ करना चाहते हैं, तो इन दो पंक्तियों में से किसी एक से अधिक जटिल करने का कोई कारण है?

old_list = [] 
old_list = list() 

कारण मैं पूछता हूँ कि मैं सिर्फ कुछ चल रहा है कोड में यह देखा है:

del old_list[ 0:len(old_list) ] 
+1

आप ऐसा क्यों कर रहे हैं? कचरा संग्रह काम करता है। क्यों न केवल पुराने सूची मूल्य को अनदेखा करें और पाइथन को स्वचालित रूप से इसे साफ़ करने दें? 12 may. 092009-05-12 02:15:37

+32

@ एसएलओटी: पोस्टर ने कोड नहीं लिखा, और पूछ रहा है कि मूल लेखक ऐसा क्यों कर सकता था। 12 may. 092009-05-12 03:20:59

+14

आपके प्रश्न से संबंधित नहीं है, लेकिन आपको स्लाइस निर्दिष्ट करते समय लेन का उपयोग नहीं करना चाहिए। 'a [: x] 'का मतलब है x और' a [x:] 'से शुरू होता है x का अंत होता है। 'एक [0: लेन (ए)]' '[:]' के रूप में लिखा जा सकता है। आप अंत से गिनने के लिए नकारात्मक भी उपयोग कर सकते हैं ('एक [-1]' अंतिम तत्व है)। 23 feb. 112011-02-23 20:53:51

+1

आप यह भी कर सकते हैं: जबकि l: l.pop() 13 may. 092009-05-13 02:10:35

+9

एलओएल। मुझे यकीन है कि यह कुशल है। 13 may. 092009-05-13 02:17:07

+1

किसी ने भी कुशलता के बारे में कुछ भी नहीं कहा ... 13 may. 092009-05-13 03:11:52

303

जगह में एक सूची समाशोधन एक ही सूची के अन्य सभी संदर्भों को प्रभावित करेगा।

उदाहरण के लिए, इस विधि अन्य संदर्भों को प्रभावित नहीं करता:

>>> a = [1, 2, 3] 
>>> b = a 
>>> a = [] 
>>> print(a) 
[] 
>>> print(b) 
[1, 2, 3] 

लेकिन यह एक करता है:

>>> a = [1, 2, 3] 
>>> b = a 
>>> del a[:]  # equivalent to del a[0:len(a)] 
>>> print(a) 
[] 
>>> print(b) 
[] 
>>> a is b 
True 

तुम भी कर सकता है:

>>> a[:] = [] 
+6

हम्म, आप हर दिन कुछ नया सीखते हैं। 12 may. 092009-05-12 02:05:32

+80

आप 'del a [:] ' 23 feb. 112011-02-23 20:51:16

+1

भी कर सकते हैं क्यों पहला व्यक्ति केवल' ए' को प्रभावित करेगा? मैंने एक वस्तु और 'बी' एक ही वस्तु के संदर्भ को सोचा ... बस जानना चाहते हैं क्यों। धन्यवाद। 22 nov. 142014-11-22 09:48:11

+20

** पायथन 3.3 ** के साथ और बाद में आप 'a.clear()' के साथ जा सकते हैं, कोई समस्या नहीं! 06 dec. 142014-12-06 16:20:51

+4

@ स्टालमैन क्योंकि पहले आप 'ए' के ​​लिए एक संदर्भ बदल रहे हैं, नई सरणी को इंगित करने के लिए, एक को साफ़ नहीं करते हैं, और बी अभी भी पुराने को इंगित करता है 04 feb. 152015-02-04 14:36:34

+4

यदि कोई भी उन तरीकों के बीच प्रदर्शन अंतर दिखा सकता है तो यह बहुत अच्छा होगा! 24 jul. 152015-07-24 20:40:29


11

ऐसा प्रतीत होता है मेरे लिए कि डेल आपको स्मृति वापस दे देगा, जबकि एक नई सूची निर्दिष्ट करने से पुराना व्यक्ति बन जाएगा केवल gc run.matter को हटा दिया जाता है।

यह बड़ी सूचियों के लिए उपयोगी हो सकता है, लेकिन छोटी सूची के लिए यह नगण्य होना चाहिए।

संपादित करें: एल्गोरियास के रूप में, इससे कोई फर्क नहीं पड़ता।

ध्यान दें कि

del old_list[ 0:len(old_list) ] 

के बराबर है

del old_list[:] 
+2

जीसी चक्रों में नहीं चल रहा है। जैसे ही अंतिम संदर्भ गिरा दिया जाता है, सूची पूरी तरह से मुक्त हो जाती है। 12 may. 092009-05-12 04:45:55

+2

एल्गोरियास: यह सीपीथन के लिए सच है, लेकिन अन्य कार्यान्वयन के लिए नहीं हो सकता है। 18 dec. 112011-12-18 23:48:20

+1

del old_list [0: len (old_list)] और del old_list [:] का एक ही परिणाम है, लेकिन बाद वाला एक तेज़ है (पायथन 2.6 में चेक किया गया है) 12 feb. 132013-02-12 14:38:10


4

दो मामलों जिसमें आप एक सूची खाली करने के लिए चाहते हो सकता है के होते हैं:

  1. आप नाम का उपयोग करना चाहते old_list आपके कोड में आगे;
  2. आप पुरानी सूची को कुछ स्मृति मुक्त करने के लिए जल्द से जल्द कचरा इकट्ठा करना चाहते हैं;

मामले 1 में आप सिर्फ असाइनमेंट के साथ पर जाने के:

old_list = [] # or whatever you want it to be equal to 

मामले 2 में del बयान पर नाम old list अंक वस्तु सूची के संदर्भ गिनती कम होगी। यदि सूची वस्तु केवल old_list नाम से इंगित की जाती है, तो संदर्भ गणना 0 होगी, और वस्तु कचरा संग्रह के लिए मुक्त हो जाएगी।

del old_list 

30

एक अजगर सूची को हटाने का एक बहुत ही आसान तरीका है। del list_name [:] का उपयोग करें।

उदाहरण के लिए

:

>>> a = [1, 2, 3]` 
>>> b = a 
>>> del a[:] 
>>> print a, b 
[] [] 

3
del list[:] 

उस सूची चर

del list 

स्मृति


1

से चर खुद को नष्ट करेगा के मूल्यों को नष्ट करेगा आप सूची साफ़ किए जा रहे हैं , जाहिर है, अब सूची की आवश्यकता नहीं है। यदि ऐसा है, तो आप साधारण डेल विधि द्वारा पूरी सूची को हटा सकते हैं।

a = [1, 3, 5, 6] 
del a # This will entirely delete a(the list). 

लेकिन यदि आपको फिर से इसकी आवश्यकता है, तो आप इसे फिर से शुरू कर सकते हैं। या बस अपने तत्वों को

del a[:] 

-1

एक और समाधान जो ठीक काम करता है, खाली सूची को संदर्भ सूची के रूप में खाली सूची बनाना है।

empt_list = [] 

उदाहरण के लिए आपके पास a_list = [1,2,3] जैसी सूची है। यह सिर्फ निम्नलिखित बनाने के हटाने के लिए:

a_list = list(empt_list) 

इस a_list सिर्फ empt_list की तरह एक खाली सूची बनाएगा।


2

एक सूची साफ़ करने के लिए यथा-स्थान अजगर में 3.3+ आप भी list.clear() है, जो अन्य परिवर्तनशील कंटेनर (जैसे dict, set या deque) के इंटरफेस के साथ संगत है उपयोग कर सकते हैं।

old_list.clear() # removes all items from old_list (same as del old_list[:])