क्या एक ही समय में एक सूची से कई तत्वों को हटाना संभव है? अगर मैं इंडेक्स 0 और 2 पर तत्वों को हटाना चाहता हूं, और कुछ ऐसा प्रयास करना चाहता हूं del somelist[0], जिसके बाद del somelist[2]दूसरा स्टेटमेंट वास्तव में डिलीट हो जाएगा somelist[3]।
मुझे लगता है कि मैं हमेशा उच्च संख्या वाले तत्वों को पहले हटा सकता था, लेकिन मुझे उम्मीद है कि एक बेहतर तरीका है।
जवाबों:
शायद इस समस्या का सबसे अच्छा समाधान नहीं है:
indices = 0, 2
somelist = [i for j, i in enumerate(somelist) if j not in indices]somelist = [ lst[i] for i in xrange(len(lst)) if i not in set(indices) ]:?
किसी कारण से मुझे यहाँ कोई उत्तर पसंद नहीं है। हां, वे काम करते हैं, लेकिन कड़ाई से बोलते हुए उनमें से एक सूची में तत्वों को नहीं हटा रहे हैं, क्या वे हैं? (लेकिन एक प्रतिलिपि बनाने और फिर संपादित प्रतिलिपि के साथ मूल एक की जगह)।
केवल उच्च सूचकांक को पहले क्यों नहीं हटाया गया?
क्या इसका कोई कारण है? मैं बस करूँगा:
for i in sorted(indices, reverse=True):
del somelist[i]यदि आप वास्तव में आइटमों को पीछे की ओर हटाना नहीं चाहते हैं, तो मुझे लगता है कि आपको सूचकांकों के मूल्यों को हटाना चाहिए, जो कि पिछले हटाए गए सूचकांक से अधिक हैं (वास्तव में एक ही सूची का उपयोग नहीं कर सकते हैं क्योंकि आप एक अलग सूची में हैं) या उपयोग करते हैं सूची की एक प्रति (जो 'हटाई नहीं जाएगी' लेकिन मूल की जगह एक संपादित प्रति के साथ)।
क्या मुझे यहाँ कुछ याद आ रहा है, उल्टे क्रम में हटाने का कोई कारण नहीं?
यदि आप कई गैर-आसन्न आइटम हटा रहे हैं, तो आप जो वर्णन करते हैं वह सबसे अच्छा तरीका है (और हाँ, उच्चतम सूचकांक से शुरू होना सुनिश्चित करें)।
अपने आइटम आसन्न हैं, तो आप टुकड़ा काम सिंटैक्स का उपयोग कर सकते हैं:
a[2:10] = []del a[2:10]उसी प्रभाव से कह सकते हैं ।
आप 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सरणी के साथ समाप्त होने का मन नहीं रखते हैं , तो आप बाहर छोड़ सकते हैं .tolist()। आपको कुछ बहुत बड़ी गति सुधारों को भी देखना चाहिए, जिससे यह अधिक स्केलेबल समाधान बन सकता है। मैंने इसे बेंचमार्क नहीं किया है, लेकिन numpyसंचालन सी या फोरट्रान में लिखा कोड संकलित है।
ग्रेग के जवाब की विशेषज्ञता के रूप में, आप विस्तारित स्लाइस सिंटैक्स का भी उपयोग कर सकते हैं। जैसे। यदि आप आइटम 0 और 2 हटाना चाहते हैं:
>>> a= [0, 1, 2, 3, 4]
>>> del a[0:3:2]
>>> a
[1, 3, 4]इस कोर्स के किसी भी मनमाने ढंग से चयन को कवर नहीं करता है, लेकिन यह निश्चित रूप से किसी भी दो आइटम को हटाने के लिए काम कर सकते हैं।
एक समारोह के रूप में:
def multi_delete(list_, *args):
indexes = sorted(list(args), reverse=True)
for index in indexes:
del list_[index]
return list_में चलाता n लॉग (एन) समय है, जो यह सबसे तेजी से सही समाधान अभी तक करना चाहिए।
n log n? वास्तव में? मुझे नहीं लगता कि del list[index]हे (1) है।
तो, आप अनिवार्य रूप से एक पास में एक से अधिक तत्वों हटाना चाहते हैं? उस स्थिति में, हटाने के लिए अगले तत्व की स्थिति को ऑफसेट किया जाएगा हालांकि कई पहले हटा दिए गए थे।
हमारा लक्ष्य सभी स्वरों को हटाना है, जो कि 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।
मैं पाइथन में कुल शुरुआत कर रहा हूं, और इस समय मेरी प्रोग्रामिंग कम से कम कहने के लिए क्रूड और गंदी है, लेकिन मेरा समाधान शुरुआती ट्यूटोरियल में सीखे गए मूल कमांड के संयोजन का उपयोग करना था:
some_list = [1,2,3,4,5,6,7,8,10]
rem = [0,5,7]
for i in rem:
some_list[i] = '!' # mark for deletion
for i in range(0, some_list.count('!')):
some_list.remove('!') # remove
print some_listजाहिर है, "मार्क-फॉर-डिलीशन" चरित्र का चयन करने के कारण, इसकी सीमाएँ हैं।
सूची तराजू के आकार के रूप में प्रदर्शन के लिए, मुझे यकीन है कि मेरा समाधान उप-इष्टतम है। हालांकि, यह सीधा है, जो मुझे आशा है कि अन्य शुरुआती लोगों से अपील करता हूं, और सरल मामलों में काम करेगा जहां some_listएक प्रसिद्ध प्रारूप है, उदाहरण के लिए, हमेशा संख्यात्मक ...
यहाँ एक विकल्प है, कि tuples बनाने के लिए enumerate () का उपयोग नहीं किया जाता है (जैसा कि SilentGhost के मूल उत्तर में है)।
यह मुझे अधिक पठनीय लगता है। (शायद मैं अलग तरह से महसूस करूंगा अगर मैं एन्यूमरेट का उपयोग करने की आदत में था।) गुफा: मैंने दो तरीकों के प्रदर्शन का परीक्षण नहीं किया है।
# 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]।
[ value for (i, value) in enumerate(lst) if i not in set(indices) ]:। लेकिन मैं अपना उत्तर यहां छोड़ दूंगा, क्योंकि मैं यह भी बताता हूं कि मूल्यों द्वारा कैसे हटाया जाए। जो एक आसान मामला है, लेकिन किसी की मदद कर सकता है।
indices_as_set = set(indices), साइलेंटगॉस्ट के संस्करण को फिर से लिखूंगा [ value for (i, value) in enumerate(lst) if i not in indices_as_set ]।
delete__by_values()?
एक वैकल्पिक सूची समझने की विधि जो सूची सूचकांक मूल्यों का उपयोग करती है:
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']indexभ्रामक है क्योंकि सूची पुनरावृत्ति के लिए विधि का उपयोग किया जाता हैindex()
यहाँ एक और विधि है जो तत्वों को हटाती है। यह भी कि यदि आपकी सूची वास्तव में लंबी है, तो यह तेज है।
>>> 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]यह वास्तव में साइलेंटगॉस्ट के संस्करण के करीब है , लेकिन दो ब्रेसिज़ जोड़ता है।
O(n)यदि आप log(len(indices))प्रत्येक पुनरावृत्ति के लिए लुकअप को गिनते हैं तो यह नहीं है ।
j not in indicesहै O(1)।
j not in indicesभी लुकअप की आवश्यकता होती है, जो है O(log(len(indices)))। जबकि मैं मानता हूं कि 2-तत्व सेट में एक लुकअप योग्य है O(1), सामान्य स्थिति में यह होगा O(log(N))। किसी भी तरह से O(N log(N))अभी भी धड़कता है O(N^2)।
j not in indicesहै O(1)गंभीरता से,।
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 () का उपयोग करना एक अच्छा विचार नहीं है, क्योंकि यह सूची में डुप्लिकेट किए गए तत्वों को संभाल नहीं सकता है।
तकनीकी रूप से, जवाब नहीं है समान समय पर दो वस्तुओं को हटाना संभव नहीं है। हालांकि, सुंदर अजगर की एक पंक्ति में दो वस्तुओं को हटाना संभव है।
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मैं अलग-अलग समाधानों की तुलना करने का एक तरीका चाहता था, जिससे नोज को मोड़ना आसान हो जाए।
पहले मैंने अपना डेटा जनरेट किया:
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)तब मैं timeitसमाधानों की तुलना करता था:
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।
उच्चतम सूचकांक से हटाने के विचार का एक और कार्यान्वयन।
for i in range(len(yourlist)-1, -1, -1):
del yourlist(i)मैं वास्तव में इसे करने के दो तरीकों के बारे में सोच सकता हूं:
सूची को इस तरह काटें (यह 1, 3 और 8 वां तत्व हटाता है)
somelist = somelist [1: 2] + somelist [3: 7] + somelist [8:]
उस जगह पर करो, लेकिन एक समय में:
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']इनमें से एक के बारे में कैसे (मैं पायथन के लिए बहुत नया हूं, लेकिन वे ठीक लगते हैं ):
ocean_basin = ['a', 'Atlantic', 'Pacific', 'Indian', 'a', 'a', 'a']
for i in range(1, (ocean_basin.count('a') + 1)):
ocean_basin.remove('a')
print(ocean_basin)['अटलांटिक', 'प्रशांत', 'इंडियन']
ob = ['a', 'b', 4, 5,'Atlantic', 'Pacific', 'Indian', 'a', 'a', 4, 'a']
remove = ('a', 'b', 4, 5)
ob = [i for i in ob if i not in (remove)]
print(ob)['अटलांटिक', 'प्रशांत', 'इंडियन']
अब तक दिए गए उत्तरों में से कोई भी हटाने के लिए सूचकांकों की एक मनमानी संख्या के लिए सूची की लंबाई पर ओ (एन) में जगह में विलोपन करता है , इसलिए यहां मेरा संस्करण है:
def multi_delete(the_list, indices):
assert type(indices) in {set, frozenset}, "indices must be a set or frozenset"
offset = 0
for i in range(len(the_list)):
if i in indices:
offset += 1
elif offset:
the_list[i - offset] = the_list[i]
if offset:
del the_list[-offset:]
# Example:
a = [0, 1, 2, 3, 4, 5, 6, 7]
multi_delete(a, {1, 2, 4, 6, 7})
print(a) # prints [0, 3, 5]मैंने इसे एक list_diffसमारोह में एक साथ रखा, जो केवल दो सूचियों को इनपुट के रूप में लेता है और पहली सूची के मूल क्रम को संरक्षित करते हुए, अपने अंतर को वापस करता है।
def list_diff(list_a, list_b, verbose=False):
# returns a difference of list_a and list_b,
# preserving the original order, unlike set-based solutions
# get indices of elements to be excluded from list_a
excl_ind = [i for i, x in enumerate(list_a) if x in list_b]
if verbose:
print(excl_ind)
# filter out the excluded indices, producing a new list
new_list = [i for i in list_a if list_a.index(i) not in excl_ind]
if verbose:
print(new_list)
return(new_list)नमूना उपयोग:
my_list = ['a', 'b', 'c', 'd', 'e', 'f', 'woof']
# index = [0, 3, 6]
# define excluded names list
excl_names_list = ['woof', 'c']
list_diff(my_list, excl_names_list)
>> ['a', 'b', 'd', 'e', 'f']