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




list (14)

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

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

(यह पाइथन सूची के साथ काम करते समय भी कम से कम कुशल विधि होगी लेकिन यह उपयोगी हो सकता है (लेकिन कुशल नहीं है, मैं दोहराता हूं) उपयोगकर्ता परिभाषित ऑब्जेक्ट्स के साथ काम करते समय जो पॉप का समर्थन नहीं करते हैं, फिर भी एक __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 ) में फिर से सौंप दिया जाता है। इसलिए पुरानी सूची वस्तु को संदर्भित किया जाता है और इसलिए कचरा एकत्रित किया जाता है (बशर्ते मूल सूची वस्तु को किसी अन्य चर के संदर्भ में संदर्भित न किया जाए)

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

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

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

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

ऑब्जेक्ट्स के साथ प्रयोग करते समय, __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__ विधि को परिभाषित करेंगे।

डिस्सेप्लर इस प्रकार है:

कोड:

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

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

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

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


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

del listName[-N]

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

del listName[-3:]

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

del listName[-8:]

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

यदि आप हटाए गए तत्व को वापस करना चाहते हैं, तो 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:] )।


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

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]

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

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

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

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

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

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

    letters = ["a", "b", "c", "d", "e"]
    numbers.remove(numbers[1])
    print(*letters) # used a * to make it unpack you don't have to

आउटपुट: एसीडीई


आप शायद 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']

आप आसानी से पाइथन के निकालने के फ़ंक्शन का उपयोग कर सकते हैं। इस तरह:

v=[1,2,3,4,5,6]
v.remove(v[4]) #I'm removing the number with index 4 of my array
print(v) #If you want verify the process

#it gave me this:
#[1,2,3,4,6]

एल - मूल्यों की सूची; हमें 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]

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

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

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

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

In [9]: a = list(range(10))
In [10]: a
Out[10]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [11]: del a[-1]
In [12]: a
Out[12]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

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


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

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

flat_list = []
for i in list_of_list:
    flat_list+=i

यह कोड ठीक काम करता है क्योंकि यह सिर्फ सूची को विस्तारित करता है। हालांकि यह बहुत समान है लेकिन केवल लूप के लिए एक है। इसलिए लूप के लिए 2 जोड़ने की तुलना में इसकी जटिलता कम है।





python list