दिलचस्प पोस्ट
जावा में इटरेटिव कार्टेसीयन उत्पाद GetClass () का उपयोग कर संसाधन लोड हो रहा है। GetResource () कैसे सीएसएस में विक्रेता उपसर्गों को मान्य करने के लिए -webkit- और -moz-? कैसे एक सरणी में स्ट्रिंग के लिए खोज करने के लिए आर कमांड लाइन में एक समय घड़ी प्रदर्शित करें ग्रहण शुरू नहीं होगा और मैंने कुछ भी नहीं बदला है एंड्रॉइड आयात java.nio.file.files; हल नहीं किया जा सकता है उद्देश्य-सी में फ्लोट्स के साथ परेशानी जावास्क्रिप्ट और PHP के बीच अंतर एक प्रेरक प्रेषक कैसे प्राप्त करें? चेतावनी: PDOStatement :: execute (): SQLSTATE : अमान्य पैरामीटर संख्या: बाउंड चर की संख्या में टोकन की संख्या से मेल नहीं खाती पायथन के साथ UTF-8 स्ट्रिंग को MySQL लिखना इकाई फ़्रेमवर्क 6 का उपयोग करते हुए एसक्यूएल सर्वर से छवि (बाइनरी) को सुरक्षित और पुनः प्राप्त करें मैं एक्सएमएल में टैग के एक ब्लॉक को कैसे बताऊँ? JavaFX 2.1 तालिका दृश्य ताज़ा आइटम

एक सूची से कई तत्व हटाना

क्या एक ही समय में एक से कई तत्वों को हटाना संभव है? अगर मैं इंडेक्स 0 और 2 पर तत्वों को हटाना चाहता हूं, और डेल सोमेलीिस्ट [0] की तरह कुछ कोशिश कर रहा हूं, इसके बाद डेल सोमरेलिस्ट [2] का दूसरा कथन वास्तव में सोबिलिस्ट को हटा देगा [3]

मुझे लगता है कि मैं हमेशा पहले ही उच्च अंक वाले तत्वों को हटा सकता हूं लेकिन मुझे उम्मीद है कि एक बेहतर तरीका है।

वेब के समाधान से एकत्रित समाधान "एक सूची से कई तत्व हटाना"

शायद इस समस्या का सबसे अच्छा समाधान नहीं है:

indices = 0, 2 somelist = [i for j, i in enumerate(somelist) if j not in indices] 

यदि आप कई गैर-आसन्न वस्तुओं को हटा रहे हैं, तो आप जो वर्णन करते हैं वह सबसे अच्छा तरीका है (और हाँ, उच्चतम सूचकांक से शुरू करना सुनिश्चित करें)।

यदि आपकी वस्तुएं आसन्न हैं, तो आप स्लाइस असाइनमेंट सिंटैक्स का उपयोग कर सकते हैं:

 a[2:10] = [] 

किसी कारण के लिए मुझे यहाँ जवाब में से कोई भी पसंद नहीं है। हां, वे काम करते हैं, लेकिन कड़ाई से बोलते हैं उनमें से ज्यादातर एक सूची में तत्वों को नहीं हटा रहे हैं, क्या वे हैं? (लेकिन प्रतिलिपि बनाने और फिर मूल प्रति को संपादित प्रति के साथ बदलकर)

क्यों न केवल उच्च सूचकांक पहले हटाएं?

क्या इसका कोई कारण है? मैं बस करता हूं:

 for i in sorted(indices, reverse=True): del somelist[i] 

यदि आप वास्तव में आइटम को पीछे हटाना नहीं चाहते हैं, तो मुझे लगता है कि आपको केवल इंडेक्स के मूल्यों को विघटित करना चाहिए जो अंतिम हटाए गए इंडेक्स से अधिक हो सकते हैं (वास्तव में उसी सूची का उपयोग नहीं कर सकते हैं, क्योंकि आप एक अलग सूची रखते हैं) या उपयोग करें सूची की एक प्रति (जो 'हटाए जाने' पर नहीं बल्कि एक प्रतिलिपि के साथ मूल की जगह होगी)।

क्या मैं यहाँ कुछ याद कर रहा हूं, किसी भी कारण को रिवर्स ऑर्डर में नहीं हटा सकता?

एक समारोह के रूप में:

 def multi_delete(list_, *args): indexes = sorted(list(args), reverse=True) for index in indexes: del list_[index] return list_ 

एन लॉग (एन) समय में चलाता है, जिसे इसे अभी तक सबसे तेज सही समाधान करना चाहिए।

ग्रेग के उत्तर की विशेषज्ञता के रूप में, आप विस्तारित स्लाइस सिंटैक्स का उपयोग भी कर सकते हैं। जैसे। यदि आप 0 और 2 आइटम हटाना चाहते थे:

 >>> a= [0, 1, 2, 3, 4] >>> del a[0:3:2] >>> a [1, 3, 4] 

यह किसी भी मनमाना चयन को शामिल नहीं करता है, ज़ाहिर है, लेकिन यह निश्चित रूप से दो वस्तुओं को हटाने के लिए काम कर सकता है।

तो, आप अनिवार्य रूप से एक पास में कई तत्व हटाना चाहते हैं? उस स्थिति में, हटाए जाने के लिए अगले तत्व की स्थिति को ऑफसेट कर दिया जाएगा, हालांकि कई पहले हटाए गए थे।

हमारा लक्ष्य सभी स्वरों को हटाना है, जो सूचकांक 1, 4 और 7 के लिए प्रीकॉम्प्यूट किए जाते हैं। ध्यान दें कि इसके महत्वपूर्ण to_delete इंडेक्स आरोही क्रम में हैं, अन्यथा यह काम नहीं करेगा।

 to_delete = [1, 4, 7] target = list("hello world") for offset, index in enumerate(to_delete): index -= offset del target[index] 

यदि आप किसी भी क्रम में तत्वों को हटाना चाहते हैं, तो यह अधिक जटिल होगा। IMO, to_delete सॉर्ट करना आपको यह पता लगाना आसान हो सकता है कि आपको index से कब घटाना चाहिए या नहीं।

आप numpy.delete उपयोग निम्नानुसार कर सकते हैं:

 import numpy as np a = ['a', 'l', 3.14, 42, 'u'] I = [0, 2] np.delete(a, I).tolist() # Returns: ['l', '42', 'u'] 

यदि आप अंत में एक numpy array के साथ समाप्त नहीं करते हैं, तो आप बाहर छोड़ सकते हैं। .tolist() । आपको कुछ बहुत बड़ी गति सुधार देखनी चाहिए, यह एक और अधिक स्केलेबल समाधान बना रही है। मैंने इसे बेंचमार्क नहीं किया है, लेकिन numpy ऑपरेशन को सी या फोरट्रान में लिखे गए कोड संकलित किया गया है।

मैं पायथन में कुल शुरुआत कर रहा हूं, और इस समय मेरे प्रोग्रामिंग कम से कम कहने के लिए कच्चे और गंदे हैं, लेकिन मेरा समाधान शुरुआती ट्यूटोरियल में सीखा बुनियादी आज्ञाओं के संयोजन का उपयोग करना था:

 SomeList = [1,2,3,4,5,6,7,8,10] Rem = [0,5,7] for i in Rem: SomeList[i]='!' # mark for deletion for i in range(0,SomeList.count('!')): SomeList.remove('!') # remove print SomeList 

जाहिर है, एक "चिह्न-के-विलोपन" चरित्र का चयन करने के कारण, इसकी सीमाएं हैं

सूची तराजू के आकार के रूप में प्रदर्शन के लिए, मुझे यकीन है कि मेरा समाधान उप इष्टतम है हालांकि, यह सीधा है, जो मुझे अन्य शुरुआती के लिए अपील की उम्मीद है, और सरल मामलों में काम करेगा जहां कुछ लेखक एक प्रसिद्ध प्रारूप का है, जैसे, हमेशा संख्यात्मक …

यहां एक विकल्प है, जो ट्यूपल्स बनाने के लिए () मौन गेट के मूल उत्तर के रूप में गणना करने के लिए उपयोग नहीं करता है।

यह मुझे और अधिक पठनीय लगता है (शायद मैं अलग तरह से महसूस करता हूं अगर मैं गणना का उपयोग करने की आदत में था।) कैवेैट: मैंने दो तरीकों के प्रदर्शन का परीक्षण नहीं किया है।

 # Returns a new list. "lst" is not modified. def delete_by_indices(lst, indices): indices_as_set = set(indices) return [ lst[i] for i in xrange(len(lst)) if i not in indices_as_set ] 

नोट: पायथन 2.7 वाक्यविन्यास पायथन 3 के लिए, xrange => range

उपयोग:

 lst = [ 11*x for x in xrange(10) ] somelist = delete_by_indices( lst, [0, 4, 5]) 

somelist:

 [11, 22, 33, 66, 77, 88, 99] 

— बोनस —

सूची से अनेक मान हटाएं यही है, हमारे पास वे मूल्य हैं जिन्हें हम हटाना चाहते हैं:

 # Returns a new list. "lst" is not modified. def delete__by_values(lst, values): values_as_set = set(values) return [ x for x in lst if x not in values_as_set ] 

उपयोग:

 somelist = delete__by_values( lst, [0, 44, 55] ) 

somelist:

 [11, 22, 33, 66, 77, 88, 99] 

यह पहले जैसा ही उत्तर है, लेकिन इस बार हमने मूविओं को हटाया गया [0, 44, 55]

यहाँ एक और विधि है जो जगह में तत्वों को हटा देती है अगर आपकी सूची वास्तव में लंबी है, तो यह तेज है

 >>> a = range(10) >>> remove = [0,4,5] >>> from collections import deque >>> deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0) >>> timeit.timeit('[i for j, i in enumerate(a) if j not in remove]', setup='import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1) 0.1704120635986328 >>> timeit.timeit('deque((list.pop(a, i) for i in sorted(remove, reverse=True)), maxlen=0)', setup='from collections import deque;import random;remove=[random.randrange(100000) for i in range(100)]; a = range(100000)', number=1) 0.004853963851928711 

इसका उल्लेख किया गया है, लेकिन किसी को भी वास्तव में इसे ठीक से प्राप्त करने में कामयाब नहीं हुआ।

O(n) समाधान पर होगा:

 indices = {0, 2} somelist = [i for j, i in enumerate(somelist) if j not in indices] 

यह वास्तव में सॉलेंटगेस्ट के संस्करण के करीब है, लेकिन दो ब्रेसेज़ जोड़ता है

निकालें विधि सूची तत्वों की बहुत सारी बदलाव का कारण होगा मुझे लगता है कि एक कॉपी बनाने के लिए बेहतर है:

 ... new_list = [] for el in obj.my_list: if condition_is_true(el): new_list.append(el) del obj.my_list obj.my_list = new_list ... 

तकनीकी तौर पर, इसका उत्तर नहीं है, एक ही समय में दो वस्तुओं को हटाना संभव नहीं है। हालांकि, सुंदर अजगर की एक पंक्ति में दो ऑब्जेक्ट हटाना संभव है।

 del (foo['bar'],foo['baz']) 

फिर से foo['bar'] हटाना होगा, फिर foo['baz']

हम अवरोही क्रम में इंडेक्स सूची को सॉर्ट करने के बाद इंडेक्स पर पुनरावृत्त लूप के लिए इसका उपयोग कर सकते हैं

 mylist=[66.25, 333, 1, 4, 6, 7, 8, 56, 8769, 65] indexes = 4,6 indexes = sorted(indexes, reverse=True) for i in index: mylist.pop(i) print mylist 

सूची के 0 और 2 के सूचकांक के लिए:

 for x in (2,0): listA.pop(x) 

कुछ यादृच्छिक सूचकांक के लिए सूची से हटाने के लिए:

 indices=(5,3,2,7,0) for x in sorted(indices)[::-1]: listA.pop(x) 

सूची सूची मूल्यों का उपयोग करने वाली एक वैकल्पिक सूची समझ विधि:

 stuff = ['a', 'b', 'c', 'd', 'e', 'f', 'woof'] index = [0, 3, 6] new = [i for i in stuff if stuff.index(i) not in index] 

यह रिटर्न:

 ['b', 'c', 'e', 'f'] 

मैं विभिन्न समाधानों की तुलना करने के लिए एक तरीका चाहता था, जिससे घुटनों को चालू करना आसान हो गया।

पहले मैंने अपना डेटा तैयार किया था:

 import random N = 16 * 1024 x = range(N) random.shuffle(x) y = random.sample(range(N), N / 10) 

फिर मैंने अपने कार्यों को परिभाषित किया:

 def list_set(value_list, index_list): index_list = set(index_list) result = [value for index, value in enumerate(value_list) if index not in index_list] return result def list_del(value_list, index_list): for index in sorted(index_list, reverse=True): del(value_list[index]) def list_pop(value_list, index_list): for index in sorted(index_list, reverse=True): value_list.pop(index) 

फिर मैंने समाधान की तुलना करने के लिए समय का उपयोग किया:

 import timeit from collections import OrderedDict M = 1000 setup = 'from __main__ import x, y, list_set, list_del, list_pop' statement_dict = OrderedDict([ ('overhead', 'a = x[:]'), ('set', 'a = x[:]; list_set(a, y)'), ('del', 'a = x[:]; list_del(a, y)'), ('pop', 'a = x[:]; list_pop(a, y)'), ]) overhead = None result_dict = OrderedDict() for name, statement in statement_dict.iteritems(): result = timeit.timeit(statement, number=M, setup=setup) if overhead is None: overhead = result else: result = result - overhead result_dict[name] = result for name, result in result_dict.iteritems(): print "%s = %7.3f" % (name, result) 

उत्पादन

 set = 1.711 del = 3.450 pop = 3.618 

तो एक set में सूचकांक के साथ जनरेटर विजेता था। और del थोड़ी तेजी से तब pop

मैं वास्तव में ऐसा करने के दो तरीके सोच सकता हूँ:

  1. सूची की तरह टुकड़ा करें (यह 1, 3 और 8 तत्वों को हटाता है)

    somelist = somelist [1: 2] + श्वेत श्रमिक [3: 7] + शॉमलिस्ट [8:]

  2. जगह में है, लेकिन एक समय में एक है:

    somelist.pop (2) somelist.pop (0)

आप किसी भी तरह से एक सूची पर ऐसा नहीं कर सकते हैं एक सूची में तत्व अनुक्रम में हैं एक शब्द में वे केवल सूचकांक पर निर्भर करते हैं।

साधारण कोड सिर्फ यह करने के लिए इसे बताए:

 >>> lst = ['a','b','c'] >>> dct = {0: 'a', 1: 'b', 2:'c'} >>> lst[0] 'a' >>> dct[0] 'a' >>> del lst[0] >>> del dct[0] >>> lst[0] 'b' >>> dct[0] Traceback (most recent call last): File "<pyshell#19>", line 1, in <module> dct[0] KeyError: 0 >>> dct[1] 'b' >>> lst[1] 'c' 

एक शब्दकोश में एक सूची "परिवर्तित" करने का एक तरीका है:

 >>> dct = {} >>> for i in xrange(0,len(lst)): dct[i] = lst[i] 

उलटा है:

 lst = [dct[i] for i in sorted(dct.keys())] 

वैसे भी मुझे लगता है कि उच्च सूचकांक से हटना शुरू करना बेहतर है जैसा आपने कहा था।

@sth से टिप्पणी को सामान्य करने के लिए किसी भी वर्ग में मद विलोपन, जो abc.MutableSequence लागू करता है , और विशेष रूप से list में, __delitem__ जादू पद्धति के माध्यम से किया जाता है। यह विधि __getitem__ समान काम करती है, जिसका अर्थ है कि वह एक पूर्णांक या एक टुकड़ा को स्वीकार कर सकता है। यहाँ एक उदाहरण है:

 class MyList(list): def __delitem__(self, item): if isinstance(item, slice): for i in range(*item.indices(len(self))): self[i] = 'null' else: self[item] = 'null' l = MyList(range(10)) print(l) del l[5:8] print(l) 

यह उत्पादन होगा

 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 2, 3, 4, 'null', 'null', 'null', 8, 9] 

इसे केवल इस कारण से आयात करना ओवरकिल हो सकता है, लेकिन यदि आप pandas का उपयोग वैसे भी करते हैं, तो समाधान सरल और सरल है:

 import pandas as pd stuff = pd.Series(['a','b','a','c','a','d']) less_stuff = stuff[stuff != 'a'] # define any condition here # results ['b','c','d'] 
 l = ['a','b','a','c','a','d'] to_remove = [1, 3] [l[i] for i in range(0, len(l)) if i not in to_remove]) 

यह मूल रूप से शीर्ष मतदान के उत्तर के समान है, बस इसे लिखने का एक अलग तरीका है। ध्यान दें कि l.index () का उपयोग करना एक अच्छा विचार नहीं है, क्योंकि यह एक सूची में डुप्लिकेट तत्वों को संभाल नहीं सकता है।

आप इस तर्क का उपयोग कर सकते हैं:

 my_list = ['word','yes','no','nice'] c=[b for i,b in enumerate(my_list) if not i in (0,2,3)] print c