දර්ශක අනුව ලැයිස්තුවකින් මූලද්‍රව්‍යයක් ඉවත් කරන්නේ කෙසේද

පයිතන් හි දර්ශකය අනුව ලැයිස්තුවකින් මූලද්‍රව්‍යයක් ඉවත් කරන්නේ කෙසේද?

මම list.removeක්රමය සොයා ගත්තා , නමුත් අවසාන අංගය ඉවත් කිරීමට අවශ්ය යැයි කියන්න, මම මෙය කරන්නේ කෙසේද? පෙරනිමියෙන් ඉවත් කිරීම ලැයිස්තුවක් සේ පෙනේ, නමුත් කිසිදු සෙවීමක් සිදු කිරීමට මට අවශ්‍ය නැත.

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]

මෙන්න නිබන්ධනයේ කොටස.

ඔබට බොහෝ විට අවශ්‍ය වන්නේ 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']

අනෙක් අය වගේ පොප් සඳහන් කර ඇති අතර ඩෙල් වේ ද ලබා දී දර්ශකයේ අයිතමය ඉවත් කිරීමට කාර්යක්ෂම ක්රම. එහෙත් සම්පූර්ණ කිරීම සඳහා (පයිතන්හි එකම දේ බොහෝ ආකාරවලින් කළ හැකි බැවින්):

පෙති භාවිතා කිරීම (මෙය මුල් ලැයිස්තුවෙන් අයිතමය ඉවත් කිරීම සිදු නොකරයි):

(එසේම මෙය පයිතන් ලැයිස්තුව සමඟ වැඩ කිරීමේදී අවම කාර්යක්ෂම ක්‍රමයක් වනු ඇත, නමුත් පොප් සඳහා සහය නොදක්වන පරිශීලක අර්ථ දක්වන ලද වස්තූන් සමඟ වැඩ කිරීමේදී මෙය ප්‍රයෝජනවත් විය හැකිය (නමුත් කාර්යක්ෂම නොවේ, මම නැවත අවධාරණය කරමි __getitem__): a යන්න අර්ථ දක්වන්න ):

>>> 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) නැවත පවරනු ලැබේ . එබැවින් පැරණි ලැයිස්තු වස්තුව අවලංගු කර ඇති අතර එම නිසා කසළ එකතු කරනු ලැබේ (මුල් ලැයිස්තු වස්තුව a හැර වෙනත් විචල්‍යයකින් සඳහන් නොවේ නම්).

මෙම ක්‍රමය ඉතා අකාර්යක්ෂම වන අතර එයට අනවශ්‍ය අතුරු ආබාධ ඇති කළ හැකිය (විශේෂයෙන් වෙනත් විචල්‍යයන් වෙනස් නොකළ මුල් ලැයිස්තු වස්තුව වෙත යොමු කරන විට).

මෙය පෙන්වා දීම ගැන ark මාක් ඩිකින්සන්ට ස්තූතියි ...

මෙම සිරස් පිටාර ගැලීමේ පිළිතුර පෙති කැපීමේ සංකල්පය පැහැදිලි කරයි.

මෙය ක්‍රියාත්මක වන්නේ ධනාත්මක දර්ශක සමඟ පමණක් බව සලකන්න.

වස්තූන් සමඟ භාවිතා කරන අතරතුර, __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]

විසුරුවා හැරීම:

 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)

විසුරුවා හැරීම:

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

විසුරුවා හැරීම:

 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.

popලැයිස්තුවකින් අයිතමයක් ඉවත් කිරීමට සහ තබා ගැනීමට ද ප්‍රයෝජනවත් වේ. කොහෙද delඇත්තටම අයිතමය trashes.

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

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

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]]

මෙය ඔබට කිරීමට අවශ්‍ය දේ මත රඳා පවතී.

ඔබ ඉවත් කළ මූලද්රව්යය ආපසු ලබා දීමට අවශ්ය නම්, භාවිතා කරන්න 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:]).

සාමාන්යයෙන්, මම පහත ක්රමය භාවිතා කරමි:

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

දර්ශක අනුව ලැයිස්තුවකින් මූලද්‍රව්‍යයක් ඉවත් කිරීමට තවත් ක්‍රමයක්.

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]

a [x: y] දර්ශකයේ xසිට මූලද්‍රව්‍ය වෙත යොමු y-1කරයි. අපි ලැයිස්තුවේ එම කොටස හිස් ලැයිස්තුවක් ලෙස ප්‍රකාශ කරන විට ( []), එම මූලද්‍රව්‍ය ඉවත් කරනු ලැබේ.

ඔබට මැකීමට අවශ්‍ය අයිතමය සෙවිය හැකිය. එය ඇත්තෙන්ම සරලයි. උදාහරණයක්:

    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)

නිමැවුම්: acde

ලැයිස්තුවෙන් මූලද්රව්ය ඉවත් කිරීමට පහත කේතය භාවිතා කරන්න:

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]

ලැයිස්තුවකින් තනි මූලද්‍රව්‍යයක් ඉවත් කරන්නේ කෙසේද යන්න සහ විවිධ ක්‍රමවලට ඇති වාසි මොනවාද යන්න දැනටමත් සඳහන් කර ඇත. කෙසේ වෙතත්, බහු මූලද්‍රව්‍ය ඉවත් කිරීම දෝෂ සඳහා යම් විභවයක් ඇති බව සලකන්න :

>>> 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]

l - සාරධර්ම ලැයිස්තුව; අපට 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]

කලින් සඳහන් කළ පරිදි, හොඳම පුහුණුව ඩෙල් (); හෝ අගය දැන ගැනීමට අවශ්‍ය නම් පොප් () කරන්න.

විකල්ප විසඳුමක් නම් ඔබට අවශ්‍ය මූලද්‍රව්‍ය පමණක් නැවත ගොඩගැසීමයි:

    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']

eta: hmm ... negative ණ දර්ශක අගයන් මත ක්‍රියා නොකරනු ඇත, මෙනෙහි කර යාවත්කාලීන කරනු ඇත

මම සිතනවා

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

නමුත් එය හදිසියේම මෙම අදහස ඉතා අස්ථාවර බවක් පෙනේ. සිත්ගන්නාසුලු චින්තන අත්හදා බැලීමක් වුවද. උපග්‍රන්ථ () / ලැයිස්තු අවබෝධය සමඟ මෙය කිරීමට 'නිසි' ක්‍රමයක් තිබිය යුතු බව පෙනේ.

මෙනෙහි කිරීම

ඔබ ලැයිස්තු ලැයිස්තුවක් සමඟ වැඩ කරන බවක් නොපෙනේ, එබැවින් මම මෙය කෙටියෙන් තබමි. ඔබට පොප් භාවිතා කිරීමට අවශ්‍ය වන්නේ එය ලැයිස්තුගත කර ඇති මූලද්‍රව්‍ය නොව මූලද්‍රව්‍ය ඉවත් කරන බැවිනි, ඒ සඳහා ඔබ ඩෙල් භාවිතා කළ යුතුය. පයිතන් හි අවසාන අංගය ඇමතීමට එය "-1"

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

"ඩෙල්" ශ්‍රිතය භාවිතා කරන්න :

del listName[-N]

උදාහරණයක් ලෙස, ඔබට අවසාන අයිතම 3 ඉවත් කිරීමට අවශ්‍ය නම්, ඔබේ කේතය විය යුත්තේ:

del listName[-3:]

උදාහරණයක් ලෙස, ඔබට අවසන් අයිතම 8 ඉවත් කිරීමට අවශ්‍ය නම්, ඔබේ කේතය විය යුත්තේ:

del listName[-8:]

දර්ශකය මත පදනම්ව ලැයිස්තුවෙන් මූලද්‍රව්‍යය ඉවත් කිරීමට ඔබට ඩෙල් හෝ පොප් භාවිතා කළ හැකිය. පොප් විසින් එය ලැයිස්තුවෙන් ඉවත් කරන සාමාජිකයා මුද්‍රණය කරන අතර ලැයිස්තුව එම සාමාජිකයා මුද්‍රණය නොකර මකා දමයි.

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

කෙනෙකුට ඩෙල් හෝ පොප් භාවිතා කළ හැකිය, නමුත් මම ඩෙල්ට කැමතියි, ඔබට දර්ශකය සහ පෙති නියම කළ හැකි බැවින් පරිශීලකයාට දත්ත මත වැඩි පාලනයක් ලබා දේ.

නිදසුනක් ලෙස, පෙන්වා ඇති ලැයිස්තුවෙන් පටන් ගෙන, කෙනෙකුට එහි අවසාන අංගය delපෙත්තක් ලෙස ඉවත් කළ හැකි අතර, පසුව කෙනෙකුට අවසාන අංගය ප්‍රති result ලයෙන් ඉවත් කළ හැකිය pop.

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

හෝ බහු දර්ශක ඉවත් කළ යුතු නම්:

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])

ඔබට .pop () ක්‍රමය භාවිතා කළ හැකිය

පොප් () ක්‍රමය මූලික වශයෙන් කරන්නේ එය ලැයිස්තුවෙන් අවසාන අංගය මකා දැමීමයි.

එය විකල්පයක් වන තර්කයක් ලෙස දර්ශකයේ නම ගනී.

වැඩි විස්තර සඳහා ලියකියවිලි කිහිපයක් බලන්න - https://www.geeksforgeeks.org/python-list-pop/#:~:text=Python%20list%20%7C%20pop(),or%20the%20given%20index%20value .