सूचकांक द्वारा किसी सूची से एक तत्व को कैसे हटाया जाए

Question

मैं पायथन में सूचकांक द्वारा सूची से एक तत्व को कैसे निकालूं?

मुझे list.removeविधि मिल गई , लेकिन मैं अंतिम तत्व को निकालना चाहता हूं, मैं यह कैसे करूं? ऐसा लगता है कि डिफ़ॉल्ट हटाना सूची को खोजता है, लेकिन मैं नहीं चाहता कि कोई खोज की जाए।

Comments

@smci: पायथन सूची सरणी-आधारित है: बीच में एक आइटम को हटाने के लिए, आपको अंतराल को हटाने के लिए दाईं ओर सभी वस्तुओं को स्थानांतरित करना होगा यही कारण है कि यह O(n)समय ऑपरेशन में है। deque()दोनों सिरों पर कुशल संचालन प्रदान करता है लेकिन यह बीच में ओ (1) सम्मिलन / लुकअप / विलोपन प्रदान नहीं करता है।

— jfs

@JFSebastian: cPython कार्यान्वयन, हाँ, मुझे सही करने के लिए धन्यवाद। कड़ाई से भाषा कल्पना सूची को लागू करने के तरीके को निर्दिष्ट नहीं करती है, वैकल्पिक कार्यान्वयन लिंक-सूची का उपयोग करने का विकल्प चुन सकता है।

— smci

@smci: कोई भी व्यावहारिक पायथन कार्यान्वयन O(n)इंडेक्स एक्सेस a[i](लिंक-सूचियों के कारण) का उपयोग नहीं करेगा । नोट: सरणी-आधारित कार्यान्वयन O(1)सूचकांक पहुंच प्रदान करता है ।

— JFS

@JFSebastian: बिल्कुल। मैंने केवल यह नोट किया कि भाषा की युक्ति इसे परिभाषित नहीं करती है , यह एक कार्यान्वयन मुद्दा है। (मुझे यह जानकर आश्चर्य हुआ कि यह नहीं था।)

— smi

@smci यदि आप उस मोटे तौर पर लक्ष्य कर रहे हैं, तो मुझे यकीन नहीं है कि आप कुछ भी अनुकूलित करने की उम्मीद कैसे कर सकते हैं।

— निक टी

Answer 1

delउस तत्व के सूचकांक का उपयोग करें और निर्दिष्ट करें जिसे आप हटाना चाहते हैं:

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[-1]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]

स्लाइस का भी समर्थन करता है:

>>> del a[2:4]
>>> a
[0, 1, 4, 5, 6, 7, 8, 9]

यहाँ ट्यूटोरियल से अनुभाग है।

Comments

धन्यवाद, पॉप और डेल में क्या अंतर है?

— जोन वेंज

डेल ओवरलोडेड है। उदाहरण के लिए डेल पूरी सूची को हटा देता है

— ब्रायन आर। बॉडी

एक और उदाहरण डेल [2: 4], तत्वों 2 और 3 को हटाता है

— ब्रायन आर। बॉन्डी

पॉप () उस तत्व को वापस करता है जिसे आप निकालना चाहते हैं। डेल सिर्फ डिलीट है

मैं वहां "लिंक की गई सूची" का प्रमाण नहीं देख सकता। पर देखो svn.python.org/projects/python/trunk/Objects/listobject.c कैसे PyList_GetItem()अनिवार्य रूप से रिटर्न ((PyListObject *)op) -> ob_item[i];- iएक सरणी की वें तत्व।

— ग्लोगल

Answer 2

आप शायद चाहते हैं pop:

a = ['a', 'b', 'c', 'd']
a.pop(1)

# now a is ['a', 'c', 'd']

डिफ़ॉल्ट रूप से, popबिना किसी तर्क के अंतिम आइटम को हटा दिया जाता है:

a = ['a', 'b', 'c', 'd']
a.pop()

# now a is ['a', 'b', 'c']

Comments

पॉप (-1) मत भूलना। हां, यह डिफ़ॉल्ट है, लेकिन मैं इसे पसंद करता हूं इसलिए मुझे यह याद रखने की ज़रूरत नहीं है कि डिफ़ॉल्ट रूप से कौन से पॉप पॉप का उपयोग करता है।

— लोट

मैं असहमत हूं। यदि आप "पॉप" के प्रोग्रामर की व्युत्पत्ति को जानते हैं (यह एक ऑपरेशन है जो 'स्टैक' डेटा संरचना के शीर्ष को हटाता है और लौटाता है ), तो pop()अपने आप में बहुत स्पष्ट है, जबकि pop(-1)संभवतः सटीक रूप से भ्रमित है क्योंकि यह निरर्थक है।

— coredumperror

a.pop (-1) अंतिम को हटाने के लिए?

— zx1986

@ zx1986 popसबसे प्रोग्रामिंग भाषाओं में आमतौर पर अंतिम आइटम को निकालता है, जैसा कि पायथन में है। तो चाहे आप -1 निर्दिष्ट करें या कुछ भी समान नहीं है।

— पास्कल

वैसे, pop()जो भी तत्व हटा दिया गया है उसे लौटाता है।

— बॉब स्टेन

Answer 3

अन्य लोगों की तरह पॉप और डेल दिए गए इंडेक्स के आइटम को हटाने के लिए कुशल तरीके हैं। अभी तक सिर्फ पूरा करने के लिए (चूंकि एक ही चीज़ पायथन में कई तरीकों से हो सकती है):

स्लाइस का उपयोग करना (यह मूल सूची से आइटम को हटाने के स्थान पर नहीं करता है):

(पायथन सूची के साथ काम करते समय यह भी कम से कम कुशल तरीका होगा, लेकिन यह उपयोगी हो सकता है (लेकिन कुशल नहीं, मैं दोहराता हूं) जब उपयोगकर्ता परिभाषित वस्तुओं के साथ काम करते हैं जो पॉप का समर्थन नहीं करते हैं, फिर भी परिभाषित करते हैं __getitem__):

>>> a = [1, 2, 3, 4, 5, 6]
>>> index = 3 # Only positive index

>>> a = a[:index] + a[index+1 :]
# a is now [1, 2, 3, 5, 6]

नोट: कृपया ध्यान दें कि इस पद्धति की तरह सूची को संशोधित नहीं करता है popऔर del। इसके बजाय सूचियों की दो प्रतियां बनाता है (एक शुरुआत से सूचकांक तक लेकिन इसके बिना a[:index]) ( और अंतिम तत्व तक सूचकांक के बाद a[index+1:]) ( और) दोनों को जोड़कर एक नई सूची ऑब्जेक्ट बनाता है। इसके बाद सूची चर ( a) पर फिर से असाइन किया गया । पुरानी सूची ऑब्जेक्ट को इसलिए डिरेल्ड किया जाता है और इसलिए कचरा एकत्र किया जाता है (बशर्ते मूल सूची ऑब्जेक्ट को किसी अन्य चर द्वारा संदर्भित नहीं किया जाता है)।

यह इस पद्धति को बहुत अक्षम बनाता है और यह अवांछनीय दुष्प्रभाव भी पैदा कर सकता है (विशेषकर जब अन्य चर मूल सूची ऑब्जेक्ट जो अन-संशोधित रहता है) की ओर इशारा करते हैं।

इसे इंगित करने के लिए @MarkDickinson को धन्यवाद ...

यह स्टैक ओवरफ्लो उत्तर स्लाइसिंग की अवधारणा की व्याख्या करता है।

यह भी ध्यान दें कि यह केवल सकारात्मक सूचकांकों के साथ काम करता है।

वस्तुओं के साथ उपयोग करते समय, __getitem__विधि को परिभाषित किया गया होगा और अधिक महत्वपूर्ण बात यह है कि __add__विधि को दोनों ऑपरेंड से किसी वस्तु को वापस करने के लिए परिभाषित किया जाना चाहिए।

संक्षेप में, यह किसी भी वस्तु के साथ काम करता है जिसकी वर्ग परिभाषा इस प्रकार है:

class foo(object):
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return foo(self.items[index])

    def __add__(self, right):
        return foo( self.items + right.items )

यह listकिस परिभाषित __getitem__और __add__तरीकों से काम करता है ।

दक्षता के मामले में तीन तरीकों की तुलना:

मान लें कि निम्न पूर्वनिर्धारित है:

a = range(10)
index = 3

del object[index]विधि:

अब तक की सबसे कुशल विधि। यह उन सभी वस्तुओं को काम करता है जो एक __del__विधि को परिभाषित करते हैं ।

Disassembly इस प्रकार है:

कोड:

def del_method():
    global a
    global index
    del a[index]

disassembly:

 10    0 LOAD_GLOBAL     0 (a)
       3 LOAD_GLOBAL     1 (index)
       6 DELETE_SUBSCR   # This is the line that deletes the item
       7 LOAD_CONST      0 (None)
      10 RETURN_VALUE
None

pop तरीका:

यह डेल विधि की तुलना में कम कुशल है और इसका उपयोग तब किया जाता है जब आपको हटाए गए आइटम को प्राप्त करने की आवश्यकता होती है।

कोड:

def pop_method():
    global a
    global index
    a.pop(index)

disassembly:

 17     0 LOAD_GLOBAL     0 (a)
        3 LOAD_ATTR       1 (pop)
        6 LOAD_GLOBAL     2 (index)
        9 CALL_FUNCTION   1
       12 POP_TOP
       13 LOAD_CONST      0 (None)
       16 RETURN_VALUE

टुकड़ा और विधि जोड़ें।

सबसे कम कुशल।

कोड:

def slice_method():
    global a
    global index
    a = a[:index] + a[index+1:]

disassembly:

 24     0 LOAD_GLOBAL    0 (a)
        3 LOAD_GLOBAL    1 (index)
        6 SLICE+2
        7 LOAD_GLOBAL    0 (a)
       10 LOAD_GLOBAL    1 (index)
       13 LOAD_CONST     1 (1)
       16 BINARY_ADD
       17 SLICE+1
       18 BINARY_ADD
       19 STORE_GLOBAL   0 (a)
       22 LOAD_CONST     0 (None)
       25 RETURN_VALUE
None

नोट: सभी तीन डिसएम्बेंबल में पिछली दो लाइनों को अनदेखा करते हैं जो मूल रूप से हैं return None। इसके अलावा, पहली दो पंक्तियाँ वैश्विक मूल्यों को लोड कर रही हैं aऔर index।

Comments

आपकी स्लाइसिंग विधि किसी सूची से एक तत्व को नहीं हटाती है: इसके बजाय यह एक नई सूची ऑब्जेक्ट बनाता है जिसमें मूल सूची से सभी ith प्रविष्टि होती है। मूल सूची को असम्बद्ध छोड़ दिया गया है।

— मार्क डिकिंसन

@MarkDickinson ने उसी को स्पष्ट करने के लिए उत्तर संपादित किया है ... कृपया मुझे बताएं कि क्या यह अब अच्छा लगता है?

— राघव RV

हो सकता है कि उत्तर पूरी तरह से विषय पर नहीं था, लेकिन अनुक्रमण विधि उपयोगी है यदि आपको किसी अपरिवर्तनीय वस्तु, जैसे कि टुपल से किसी वस्तु को छोड़ना है। पॉप () और डेल () उस मामले में काम नहीं करेगा।

— कालेब

पूरी पोस्ट के दौरान सभी प्रस्तुत विधियों में से @ rvraghav93, a = a[:index] + a[index+1 :]-trick सबसे बड़ी सूची में आने के बाद सबसे सुरक्षित थी। अन्य सभी विधियां एक गतिरोध में समाप्त हुईं। तो बहुत बहुत धन्यवाद

— user3085931

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

— योहन ओबैदिया

Answer 4

popकिसी सूची से आइटम निकालने और रखने के लिए भी उपयोगी है। जहां delवास्तव में आइटम को ट्रैश किया जाता है।

>>> x = [1, 2, 3, 4]

>>> p = x.pop(1)
>>> p
    2

Answer 5

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

del my_list[2]
del my_list[3]
del my_list[7]

चूंकि आप दूसरे तत्व को हटाते हैं, इसलिए मूल रूप से डिलीट किया गया तीसरा तत्व मूल सूची में चौथा तत्व है। आप मूल सूची में 2, 3 और 7 वें तत्व को फ़िल्टर कर सकते हैं और नीचे की तरह एक नई सूची प्राप्त कर सकते हैं:

new list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]

Answer 6

यह इस बात पर निर्भर करता है कि आप क्या करना चाहते हैं।

यदि आप हटाए गए तत्व को वापस करना चाहते हैं, तो उपयोग करें pop():

>>> l = [1, 2, 3, 4, 5]
>>> l.pop(2)
3
>>> l
[1, 2, 4, 5]

हालाँकि, यदि आप किसी तत्व को हटाना चाहते हैं, तो उपयोग करें del:

>>> l = [1, 2, 3, 4, 5]
>>> del l[2]
>>> l
[1, 2, 4, 5]

इसके अतिरिक्त, delआप स्लाइस (जैसे del[2:]) का उपयोग करने की अनुमति देता है ।

Answer 7

आम तौर पर, मैं निम्नलिखित विधि का उपयोग कर रहा हूं:

>>> myList = [10,20,30,40,50]
>>> rmovIndxNo = 3
>>> del myList[rmovIndxNo]
>>> myList
[10, 20, 30, 50]

Answer 8

फिर भी सूचकांक द्वारा सूची से एक तत्व (ओं) को हटाने का एक और तरीका है।

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# remove the element at index 3
a[3:4] = []
# a is now [0, 1, 2, 4, 5, 6, 7, 8, 9]

# remove the elements from index 3 to index 6
a[3:7] = []
# a is now [0, 1, 2, 7, 8, 9]

एक [x: y] सूचकांक से तत्वों के लिए इंगित करता xहै y-1। जब हम सूची के उस हिस्से को एक खाली सूची ( []) के रूप में घोषित करते हैं , तो उन तत्वों को हटा दिया जाता है।

Answer 9

आप बस उस आइटम को खोज सकते हैं जिसे आप हटाना चाहते हैं। यह वास्तव में सरल है। उदाहरण:

    letters = ["a", "b", "c", "d", "e"]
    letters.remove(letters[1])
    print(*letters) # Used with a * to make it unpack you don't have to (Python 3.x or newer)

आउटपुट: एसीड

Comments

मुझे यह समाधान पसंद है, लेकिन निश्चित रूप से यह मानता है कि आपकी सूची में डुप्लिकेट नहीं हैं।

— tommy.carstensen

Answer 10

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

list = [1, 2, 3, 4]
list.remove(1)
print(list)

output = [2, 3, 4]

यदि आप सूची उपयोग से इंडेक्स एलिमेंट डेटा हटाना चाहते हैं:

list = [1, 2, 3, 4]
list.remove(list[2])
print(list)
output : [1, 2, 4]

Comments

कैविएट के साथ आता है कि आपकी सूची में डुप्लिकेट नहीं हो सकते।

— tommy.carstensen

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

— एंथन

Answer 11

जैसा कि पहले उल्लेख किया गया है, सबसे अच्छा अभ्यास डेल है (); या पॉप () यदि आपको मूल्य जानने की आवश्यकता है।

एक वैकल्पिक समाधान केवल उन तत्वों को फिर से स्टैक करना है जिन्हें आप चाहते हैं:

    a = ['a', 'b', 'c', 'd'] 

    def remove_element(list_,index_):
        clipboard = []
        for i in range(len(list_)):
            if i is not index_:
                clipboard.append(list_[i])
        return clipboard

    print(remove_element(a,2))

    >> ['a', 'b', 'd']

एटा: हम्म ... नकारात्मक सूचकांक मूल्यों पर काम नहीं करेगा, विचार और अद्यतन करेगा

मुझे लगता है

if index_<0:index_=len(list_)+index_

यह पैच होगा ... लेकिन अचानक यह विचार बहुत भंगुर लगता है। दिलचस्प सोचा प्रयोग हालांकि। लगता है कि अपेंडिक्स () / लिस्ट कॉम्प्रिहेंशन के साथ ऐसा करने का 'उचित' तरीका होना चाहिए।

विचार

Comments

पायथन के किस संस्करण में एक फ़ंक्शन है del()? उस फ़ंक्शन के लिए आप उस फ़ंक्शन को पहले तर्क के रूप में सूची प्रदान करते हैं और फिर सूचकांक, या पहले सूचकांक और फिर सूची? क्या यह आइटम के बिना सूची तर्क को वापस करता है, या क्या यह जगह में हटाने का काम करता है। मैं delबयान के बारे में जानता हूं , लेकिन समान नाम वाले फ़ंक्शन के बारे में नहीं।

— एंथन

Answer 12

ऐसा नहीं लगता कि आप सूचियों की सूची के साथ काम कर रहे हैं, इसलिए मैं इसे छोटा रखूंगा। आप पॉप का उपयोग करना चाहते हैं क्योंकि यह उन तत्वों को हटा देगा जो सूची में नहीं हैं, आपको उसके लिए डेल का उपयोग करना चाहिए। अजगर में अंतिम तत्व को कॉल करने के लिए यह "-1" है

>>> test = ['item1', 'item2']
>>> test.pop(-1)
'item2'
>>> test
['item1']

Comments

pop()और delदोनों प्रदान किए गए इंडेक्स पर एक तत्व को हटाते हैं, इस बात से स्वतंत्र कि वह तत्व स्वयं एक सूची है या नहीं। a = [1, [2, 3], 4]; del a[1]; b = [1, [2, 3], 4]; b.pop(1); assert a == b

— एंथन

Answer 13

एल - मूल्यों की सूची; हमें inds2rem सूची से अनुक्रमित को निकालना होगा ।

l = range(20)
inds2rem = [2,5,1,7]
map(lambda x: l.pop(x), sorted(inds2rem, key = lambda x:-x))

>>> l
[0, 3, 4, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Comments

काम नहीं कर रहा है, जवाब है <map at 0x7f4d54109a58>। और एल रेंज है (0,20)

— हितेश

Answer 14

"डेल" फ़ंक्शन का उपयोग करें :

del listName[-N]

उदाहरण के लिए, यदि आप अंतिम 3 आइटम हटाना चाहते हैं, तो आपका कोड होना चाहिए:

del listName[-3:]

उदाहरण के लिए, यदि आप अंतिम 8 आइटम निकालना चाहते हैं, तो आपका कोड होना चाहिए:

del listName[-8:]

Comments

delएक बयान है । यदि यह एक समारोह था, तो आपको लिखना होगाdel(listame[-N])

— एंथन डेस

Answer 15

यह पहले ही उल्लेख किया गया है कि किसी सूची से किसी एक तत्व को कैसे हटाया जाए और विभिन्न तरीकों से कौन से फायदे हैं। ध्यान दें, हालांकि, कई तत्वों को हटाने से त्रुटियों की कुछ संभावना है:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in indices:
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 7, 9]

मूल सूची के तत्वों 3 और 8 (3 और 7 नहीं) को हटा दिया गया है (जैसा कि लूप के दौरान सूची को छोटा किया गया था), जो कि इरादा नहीं था। यदि आप कई सूचकांकों को सुरक्षित रूप से निकालना चाहते हैं, तो आपको पहले उच्चतम सूचकांक वाले तत्वों को हटाना चाहिए, जैसे कि:

>>> l = [0,1,2,3,4,5,6,7,8,9]
>>> indices=[3,7]
>>> for i in sorted(indices, reverse=True):
...     del l[i]
... 
>>> l
[0, 1, 2, 4, 5, 6, 8, 9]

Answer 16

या यदि कई सूचकांक हटाए जाने चाहिए:

print([v for i,v in enumerate(your_list) if i not in list_of_unwanted_indexes])

तब भी कर सकता था:

print([v for i,v in enumerate(your_list) if i != unwanted_index])

Comments

आप केवल रिवर्स ऑर्डर में सूचकांकों की सूची को क्यों नहीं सॉर्ट करते हैं और फिर उन्हें एक-एक करके हटाते हैं? इस तरह आपको एक नई सूची बनाने की आवश्यकता नहीं है।

— एंथन

Answer 17

आप सूचकांक के आधार पर सूची से तत्व निकालने के लिए डेल या पॉप का उपयोग कर सकते हैं। पॉप प्रिंट सदस्य को सूची से हटा रहा है, जबकि सूची उस सदस्य को बिना प्रिंट किए हटा देती है।

>>> a=[1,2,3,4,5]
>>> del a[1]
>>> a
[1, 3, 4, 5]
>>> a.pop(1)
 3
>>> a
[1, 4, 5]
>>> 

Answer 18

एक या तो डेल या पॉप का उपयोग कर सकता है, लेकिन मैं डेल पसंद करता हूं, क्योंकि आप सूचकांक और स्लाइस को निर्दिष्ट कर सकते हैं, जिससे उपयोगकर्ता को डेटा पर अधिक नियंत्रण मिल सकता है।

उदाहरण के लिए, दिखाई गई सूची से शुरू करके, कोई अपने अंतिम तत्व delको एक स्लाइस के रूप में निकाल सकता है, और फिर एक अंतिम तत्व को परिणाम के उपयोग से हटा सकता है pop।

>>> l = [1,2,3,4,5]
>>> del l[-1:]
>>> l
[1, 2, 3, 4]
>>> l.pop(-1)
4
>>> l
[1, 2, 3]