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

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

ලැයිස්තුවකින් මූලද්රව්යයක් ඉවත් කිරීම සඳහා විවිධ ක්රම තුනෙහි බලපෑම්:

removeනිශ්චිත දර්ශකයක් නොව පළමු ගැලපුම් අගය ඉවත් කරයි :

>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]

del නිශ්චිත දර්ශකයකින් අයිතමය ඉවත් කරයි:

>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]

හා popනිශ්චිත දර්ශකය හා නැවත එය අයිතමය ඉවත් කරයි.

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

ඔවුන්ගේ දෝෂ මාතයන් ද වෙනස් ය:

>>> a = [4, 5, 6]
>>> a.remove(7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del a[7]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a.pop(7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: pop index out of range

භාවිතය delදර්ශකය විසින් අංගයක් ඉවත් කිරීමට, pop(), ඔබ නැවත අගය අවශ්ය නම් දර්ශකය මගින් එය ඉවත් කිරීමට හා remove()අගය විසින් අංගයක් ඉවත් කිරීමට. දෙවැන්න ලැයිස්තුව සෙවීම අවශ්‍ය වන අතර ලැයිස්තුවේ ValueErrorඑවැනි වටිනාකමක් නොමැති නම් මතු කරයි .

මූලද්රව්ය iලැයිස්තුවකින් දර්ශකය මකා nදැමීමේදී, මෙම ක්රමවල පරිගණකමය සංකීර්ණතා වේ

del     O(n - i)
pop     O(n - i)
remove  O(n)

වෙනත් කිසිවෙකු එය සඳහන් කර නොමැති බැවින්, ලැයිස්තු කැපීම නිසා del(මෙන් නොව pop) දර්ශක පරාසයක් ඉවත් කිරීමට ඉඩ දෙන බව සලකන්න :

>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]

IndexErrorදර්ශකය ලැයිස්තුවේ නොමැති නම් මෙය වළක්වා ගැනීමටද මෙය ඉඩ දෙයි :

>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]

දැනටමත් අනෙක් අය හොඳින් පිළිතුරු දී ඇත. මේ මගේ කෙළවරේ සිට :)

පැහැදිලිවම, popඅගය ආපසු ලබා දෙන removeඑකම එක වන අතර delඑය සරල මකාදැමීමකට සීමා කරන අතරම වස්තුව සොයන එකම එක වේ.

හොඳම පැහැදිලි කිරීම් බොහොමයක් මෙහි ඇති නමුත් තවත් සරල කිරීමට මම උපරිම උත්සාහයක් දරමි.

මෙම සියලු ක්‍රම අතර, ප්‍රතිලෝම සහ පොප් යනු පෝස්ට්ෆික්ස් වන අතර මකාදැමීම උපසර්ගය වේ.

remove (): මූලද්‍රව්‍යයේ පළමු සිදුවීම ඉවත් කිරීමට එය භාවිතා කරයි

remove(i) => පළමු වරට i අගය

>>> a = [0, 2, 3, 2, 1, 4, 6, 5, 7]
>>> a.remove(2)   # where i = 2
>>> a
[0, 3, 2, 1, 4, 6, 5, 7]

pop (): එය මූලද්‍රව්‍යය ඉවත් කිරීමට භාවිතා කරන්නේ නම්:

නිශ්චිතව දක්වා නැත

pop() => ලැයිස්තුව අවසානයේ සිට

>>>a.pop()
>>>a
[0, 3, 2, 1, 4, 6, 5]

නියම කර ඇත

pop(index) => දර්ශකයේ

>>>a.pop(2)
>>>a
[0, 3, 1, 4, 6, 5]

අවවාදයයි: ඉදිරියෙන් භයානක ක්‍රමය

delete () : එහි උපසර්ග ක්‍රමය.

එකම ක්‍රමයක් සඳහා වෙනස් සින්ටැක්ස් දෙකක් ගැන විමසිල්ලෙන් සිටින්න: [] සහ (). එයට බලය ඇත:

1. දර්ශකය මකන්න

del a[index] => පොප් මෙන් දර්ශකය සහ ඒ ආශ්‍රිත අගය මකා දැමීමට භාවිතා කරයි.

>>>del a[1]
>>>a
[0, 1, 4, 6, 5]

2. පරාසය තුළ අගයන් මකන්න [දර්ශකය 1: දර්ශකය N]

del a[0:3] => පරාසයේ බහු අගයන්

>>>del a[0:3]
>>>a
[6, 5]

3. එකම ලැයිස්තුවකින් සම්පූර්ණ ලැයිස්තුව මකා දැමීමට, නමුත් ලැයිස්තුවක් නොවේ

del (a) => ඉහත සඳහන් කළ පරිදි.

>>>del (a)
>>>a

මෙය ව්‍යාකූලතාවයක් ඇත්නම් පැහැදිලි කරයි යැයි සිතමු.

pop - දර්ශකය ගෙන ප්‍රතිලාභ ලබා දෙයි

ඉවත් කරන්න - අගය ගනී, පළමු සිදුවීම ඉවත් කරයි, සහ කිසිවක් ආපසු ලබා නොදේ

මකන්න - දර්ශකය ගනී, එම දර්ශකයේ අගය ඉවත් කරයි, සහ කිසිවක් ආපසු ලබා නොදේ

විවිධ දත්ත ව්‍යුහයන්හි ඕනෑම ක්‍රියාවක් / ශ්‍රිතයක් විශේෂිත ක්‍රියාවන් සඳහා අර්ථ දක්වා ඇත. මෙන්න ඔබේ නඩුවේදී, එනම් මූලද්රව්යයක් ඉවත් කිරීම, මකා දැමීම, පොප් කිරීම සහ ඉවත් කිරීම. (ඔබ කට්ටල සලකා බලන්නේ නම්, තවත් මෙහෙයුමක් එක් කරන්න - ඉවතලන්න) එකතු කිරීමේදී අනෙක් ව්‍යාකූල අවස්ථාව වේ. ඇතුළු කරන්න / එකතු කරන්න. නිරූපණය සඳහා, අපි deque ක්‍රියාත්මක කරමු. deque යනු දෙමුහුන් රේඛීය දත්ත ව්‍යුහයකි, එහිදී ඔබට මූලද්‍රව්‍ය එකතු කිරීමට / දෙපැත්තෙන්ම මූලද්‍රව්‍ය ඉවත් කිරීමට හැකිය (පසුපස සහ ඉදිරිපස කෙළවර)

class Deque(object):

  def __init__(self):

    self.items=[]

  def addFront(self,item):

    return self.items.insert(0,item)
  def addRear(self,item):

    return self.items.append(item)
  def deleteFront(self):

    return self.items.pop(0)
  def deleteRear(self):
    return self.items.pop()
  def returnAll(self):

    return self.items[:]

මෙහි දී, මෙහෙයුම් බලන්න:

def deleteFront(self):

    return self.items.pop(0)
def deleteRear(self):
    return self.items.pop()

මෙහෙයුම් වලට යමක් ආපසු ලබා දිය යුතුය. ඉතින්, පොප් - දර්ශකයක් සමඟ සහ නැතිව. මට වටිනාකම ආපසු ලබා දීමට අවශ්‍ය නැතිනම්: del self.items [0]

අගය අනුව මකන්න දර්ශකය:

• ඉවත් කරන්න:

  list_ez=[1,2,3,4,5,6,7,8]
  for i in list_ez:
      if i%2==0:
          list_ez.remove(i)
  print list_ez

ප්‍රතිලාභ [1,3,5,7]

කට්ටලවල සිද්ධිය සලකා බලමු.

set_ez=set_ez=set(range(10))

set_ez.remove(11)

# Gives Key Value Error. 
##KeyError: 11

set_ez.discard(11)

# Does Not return any errors.

ඉහත අදහස් දැක්වීම්වල සඳහන් පරිදි මූලද්‍රව්‍යයක් ඉවත් කිරීමට දර්ශක ගන්න. ප්රධාන වෙනසක් වන්නේ ඔවුන් සඳහා කාලය සංකීර්ණ වීමයි. දර්ශකයක් නොමැති පොප් () සඳහා කාල සංකීර්ණතාව O (1) වන නමුත් අවසාන මූලද්‍රව්‍යය මකාදැමීම සඳහා එයම නොවේ.

ඔබගේ භාවිත නඩුව සැමවිටම අවසාන අංගය මකා දැමීම නම්, මකාදැමීමට () වඩා පොප් () භාවිතා කිරීම වඩාත් සුදුසුය. කාල සංකීර්ණතා පිළිබඳ වැඩි විස්තර සඳහා, ඔබට https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt වෙත යොමු විය හැකිය.

මෙම ඉවත් ලැයිස්තුවක් මත මෙම මෙහෙයුම ඉවත් කිරීමට අගය ලබා දී ඇත. එම අගය සහිත අයිතමයක් සොයා ගැනීමට එය ලැයිස්තුව සොයන අතර එය සොයාගත් පළමු ගැලපෙන අයිතමය මකා දමයි. ගැළපෙන අයිතමය තිබේ නම් එය දෝෂයක් වේ, මතු ValueError .

>>> x = [1, 0, 0, 0, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5]
>>> del x[7]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    del x[7]
IndexError: list assignment index out of range

මෙම ඩෙල් ප්රකාශය සමස්ත ලැයිස්තුව මකා කිරීම සඳහා භාවිතා කල හැක. ඩෙල් වෙත ඔබේ තර්කය ලෙස නිශ්චිත ලැයිස්තු අයිතමයක් තිබේ නම් (උදා: ලැයිස්තුවේ 8 වන අයිතමය විශේෂයෙන් සඳහන් කිරීම සඳහා ලැයිස්තු නාමය [7]), එය එම අයිතමය මකා දමනු ඇත. ලැයිස්තුවකින් "පෙත්තක්" මකා දැමීමට පවා හැකිය. පරාසය එහි දර්ශකය, එය මතු කරයි නම් එය වැරදීමක් IndexError .

>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]
>>> del x[4]
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    del x[4]
IndexError: list assignment index out of range

පොප් හි සුපුරුදු භාවිතය නම්, ඔබ ලැයිස්තුව තොගයක් ලෙස භාවිතා කරන විට ලැයිස්තුවකින් අවසන් අයිතමය මකා දැමීමයි. ඩෙල් මෙන් නොව, පොප් එය ලැයිස්තුවෙන් ඉවත් කළ අගය නැවත ලබා දෙයි. ඔබට ලැයිස්තුවේ අවසානය හැර වෙනත් විකල්පයක් ලෙස පොප් සහ පොප් සඳහා දර්ශක අගයක් ලබා දිය හැකිය (උදා: listname.pop (0) ලැයිස්තුවෙන් පළමු අයිතමය මකා දමා එහි පළමු අයිතමය එහි ප්‍රති return ලයක් ලෙස ආපසු ලබා දෙනු ඇත). ලැයිස්තුව පෝලිමක් මෙන් හැසිරවීමට ඔබට මෙය භාවිතා කළ හැකිය, නමුත් පොප් (0) ට වඩා හොඳ කාර්ය සාධනයක් සහිත පෝලිම් මෙහෙයුම් සැපයිය හැකි පුස්තකාල චර්යාවන් තිබේ. පරාසය එහි දර්ශකය, එය මතු කරයි නම් එය වැරදීමක් IndexError .

>>> x = [1, 2, 3] 
>>> x.pop(2) 
3 
>>> x 
[1, 2]
>>> x.pop(4)
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    x.pop(4)
IndexError: pop index out of range

වැඩි විස්තර සඳහා collection.deque බලන්න .

දර්ශකය අනුව අගයක් ඉවත් කිරීමට ඔබට ඉවත් කිරීම භාවිතා කළ හැකිය.

n = [1, 3, 5]

n.remove(n[1])

n පසුව [1, 5] වෙත යොමු වේ.

ඉවත් කිරීම මූලික වශයෙන් අගය මත ක්‍රියා කරයි. දර්ශකයේ වැඩ මකන්න සහ පොප් කරන්න

ඉවත් කිරීම මූලික වශයෙන් ගැලපෙන පළමු අගය ඉවත් කරයි. මකන්න නිශ්චිත දර්ශකයකින් අයිතමය මකා දමයි පොප් මූලික වශයෙන් දර්ශකයක් ගෙන එම දර්ශකයේ අගය නැවත ලබා දෙයි. ඊළඟ වතාවේ ඔබ ලැයිස්තුව මුද්‍රණය කරන විට වටිනාකම නොපෙන්වයි.