सूचियों को साफ़ करने के विभिन्न तरीके

Question

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

old_list = []
old_list = list()

मेरे द्वारा पूछे जाने का कारण यह है कि मैंने इसे कुछ रनिंग कोड में देखा है:

del old_list[ 0:len(old_list) ]

Comments

आप यह क्यों कर रहे हैं? कचरा संग्रहण का काम करता है। बस पुरानी सूची मूल्य को अनदेखा क्यों न करें और पायथन को अपने आप साफ कर दें?

— S.Lott

@ S.Lott: पोस्टर ने कोड नहीं लिखा है, और यह पूछ रहा है कि मूल लेखक ने ऐसा क्यों किया होगा।

— जॉन फोहि

आप यह भी कर सकते हैं: जबकि l: l.pop ()

— RoadieRich

जबरदस्त हंसी। मुझे यकीन है कि यह कुशल है।

— फोगबर्ड

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

— idbrii

Answer 1

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

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

>>> 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[:] = []

Comments

आप भी कर सकते हैंdel a[:]

— idbrii

पहले वाला ही प्रभावित क्यों करेगा a? मैंने सोचा aऔर bउसी वस्तु के संदर्भ में ... बस यह जानना चाहता हूं कि क्यों। धन्यवाद।

— एलस्टन

अजगर 3.3 के साथ और बाद में आप साथ जा सकते हैं a.clear(), कोई बात नहीं!

— मारेक लेवांडोव्स्की

@ स्टॉलमैन क्योंकि पहले आप नए एरे को इंगित करने के लिए 'ए' के ​​लिए एक संदर्भ बदल रहे हैं, एक को क्लीयर नहीं कर रहे हैं, और बी अभी भी एक पुराने को इंगित करता है

— Pax0r

यह बहुत अच्छा होगा अगर कोई भी उन तरीकों के बीच प्रदर्शन अंतर दिखा सकता है!

— Suanmeiguo

Answer 2

करना alist = []सूची को स्पष्ट नहीं करता है, बस एक खाली सूची बनाता है और इसे चर पर बांधता है alist। पुरानी सूची अभी भी मौजूद होगी अगर इसमें अन्य परिवर्तनशील बाइंडिंग थीं।

इन-प्लेस सूची को वास्तव में साफ़ करने के लिए , आप इनमें से किसी भी तरीके का उपयोग कर सकते हैं:

1. alist.clear() # Python 3.3+, most obvious
2. del alist[:]
3. alist[:] = []
4. alist *= 0 # fastest

देखें परिवर्त्य अनुक्रम प्रकार अधिक जानकारी के लिए प्रलेखन पेज।

Comments

मैंने परीक्षण किया है और alist * = 0 सबसे तेज़ है, अगला सबसे तेज़ alist.clear () है और अन्य दो विधियाँ समान रूप से तेज़ हैं। क्या आप बता सकते हैं कि एलिस्ट * * 0 सबसे तेज़ क्यों है?

— जेनी

@Jenny: यह बस कम (या कम खर्चीला) का उपयोग करता opcodes हुड के नीचे। उदाहरण के लिए, ऑपरेटर संस्करण को किसी भी विधि के नाम को देखने या स्लाइस बनाने की आवश्यकता नहीं है।

— यूजीन यर्मश जूल

"एक होना चाहिए - और अधिमानतः इसे करने के लिए केवल एक ही - स्पष्ट तरीका।" पाइथन यहां चमक रहा है :)

— निक ओ ली

Answer 3

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

उदाहरण के लिए:

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

Answer 4

यह मेरे लिए प्रतीत होता है कि डेल आपको मेमोरी वापस दे देगा, जबकि एक नई सूची असाइन करने से पुराने को हटा दिया जाएगा जब जीसी रन हो जाएगा।

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

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

ध्यान दें कि

del old_list[ 0:len(old_list) ]

के बराबर है

del old_list[:]

Comments

gc को चक्रों में नहीं चलाया जाता है। जैसे ही इसका अंतिम संदर्भ हटा दिया जाता है, सूची को मुक्त कर दिया जाता है।

— अल्गोरियास

अल्गोरियस: यह सीपीथॉन के लिए सच है, लेकिन अन्य कार्यान्वयन के लिए नहीं हो सकता है।

— मुहम्मदिथ

डेल ओल्ड_लिस्ट [0: लेन (ओल्ड_लिस्ट)] और डेल ओल्ड_लिस्ट [:] का एक ही परिणाम है, लेकिन बाद वाला तेज है (पायथन 2.6 में जांचा गया)

— रॉय नीटेरा

Answer 5

del list[:] 

उस सूची चर के मूल्यों को हटा देगा

del list

चर को स्मृति से हटा देगा

Answer 6

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

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

Answer 7

यदि आप सूची को साफ़ कर रहे हैं, तो आपको स्पष्ट रूप से सूची की आवश्यकता नहीं है। यदि ऐसा है, तो आप पूरी सूची को सरल डेल विधि द्वारा हटा सकते हैं।

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

लेकिन मामले में, आपको इसे फिर से चाहिए, आप इसे फिर से संगठित कर सकते हैं। या बस इसके तत्वों को केवल स्पष्ट करें

del a[:]

Answer 8

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

empt_list = []

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

a_list = list(empt_list)

यह a_listएक खाली सूची की तरह बना देगा empt_list।

Comments

Empt_list बनाने का कोई कारण नहीं। बस a_list = सूची () का उपयोग करें।

— डैनियल हार्डिंग