ලැයිස්තු අංගයක් අගය අනුව මකා දැමීමට සරල ක්‍රමයක් තිබේද?

ලැයිස්තුවක් තුළ ලැයිස්තුවක් තිබේ නම් එය ඉවත් කිරීමට මට අවශ්‍යය (එය එසේ නොවිය හැක).

a = [1, 2, 3, 4]
b = a.index(6)

del a[b]
print(a)

ඉහත නඩුව (එය නොපවතින) පහත දෝෂය පෙන්වයි:

Traceback (most recent call last):
  File "D:\zjm_code\a.py", line 6, in <module>
    b = a.index(6)
ValueError: list.index(x): x not in list

එබැවින් මට මෙය කළ යුතුය:

a = [1, 2, 3, 4]

try:
    b = a.index(6)
    del a[b]
except:
    pass

print(a)

නමුත් මෙය කිරීමට සරල ක්‍රමයක් නැද්ද?

ලැයිස්තුවක මූලද්‍රව්‍යයේ පළමු සිදුවීම ඉවත් කිරීමට, සරලව භාවිතා කරන්න list.remove:

>>> a = ['a', 'b', 'c', 'd']
>>> a.remove('b')
>>> print(a)
['a', 'c', 'd']

එය ඔබගේ මූලද්රව්යයේ සියලු සිදුවීම් ඉවත් නොකරන බව සිතන්න. ඒ සඳහා ලැයිස්තු අවබෝධයක් භාවිතා කරන්න.

>>> a = [10, 20, 30, 40, 20, 30, 40, 20, 70, 20]
>>> a = [x for x in a if x != 20]
>>> print(a)
[10, 30, 40, 30, 40, 70]

සාමාන්‍යයෙන් පයිතන් ව්‍යතිරේකයක් විසි කරයි, ඔබට එය කළ නොහැකි දෙයක් කිරීමට පැවසුවහොත් ඔබට එය කිරීමට සිදුවේ:

if c in a:
    a.remove(c)

හෝ:

try:
    a.remove(c)
except ValueError:
    pass

ව්‍යතිරේකයක් යනු ඔබ අපේක්ෂා කරන හා නිසි ලෙස හැසිරෙන තාක් කල් නරක දෙයක් නොවේ.

ඔබට කළ හැකිය

a=[1,2,3,4]
if 6 in a:
    a.remove(6)

නමුත් ඉහත ලැයිස්තුවේ 6 වතාවක් සෙවීමට 2 වතාවක් අවශ්‍ය වේ, එබැවින් වේගවත් වීමට හැර උත්සාහ කරන්න

try:
    a.remove(6)
except:
    pass

සලකා බලන්න:

a = [1,2,2,3,4,5]

සියලු සිදුවීම් ඉවත් කිරීම සඳහා, ඔබට පයිතන් හි පෙරහන් ශ්‍රිතය භාවිතා කළ හැකිය. උදාහරණයක් ලෙස, එය මෙසේ පෙනේ:

a = list(filter(lambda x: x!= 2, a))

එබැවින්, එය සියළුම අංග තබා ගනී a != 2.

භාවිතා කරන අයිතම වලින් එකක් පමණක් ගැනීමට

a.remove(2)

එය ස්ථානගතව කරන්නේ කෙසේද යන්න මෙන්න (ලැයිස්තු අවබෝධය නොමැතිව):

def remove_all(seq, value):
    pos = 0
    for item in seq:
        if item != value:
           seq[pos] = item
           pos += 1
    del seq[pos:]

මකා දැමිය යුතු වටිනාකම ඔබ දන්නේ නම්, මෙන්න සරල ක්‍රමයක් (මට සිතිය හැකි තරම් සරල, කෙසේ වෙතත්):

a = [0, 1, 1, 0, 1, 2, 1, 3, 1, 4]
while a.count(1) > 0:
    a.remove(1)

ඔබට ලැබෙනු ඇත [0, 0, 2, 3, 4]

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

IE ඔබේ දත්ත ඇණවුම් කර නොමැති නම් සහ අනුපිටපත් නොමැති නම්

my_set=set([3,4,2])
my_set.discard(1)

දෝෂ රහිත ය.

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

my_set.add(3)

ඉහළින් my_set වෙනස් නොකරයි.

වෙනත් බොහෝ පිළිතුරු වලින් ප්‍රකාශ කර ඇති පරිදි, ක්‍රියා list.remove()කරනු ඇත, නමුත් ValueErrorඅයිතමය ලැයිස්තුවේ නොතිබුනේ නම් විසි කරන්න . භාවිතා, පිඹුරා 3.4+ සමග, මේ සම්බන්ධයෙන් කටයුතු කිරීමට සිත්ගන්නා ප්රවේශය තියෙන්නේ මැඩීමට contextmanager :

from contextlib import suppress
with suppress(ValueError):
    a.remove('b')

ඔබේ මූලද්‍රව්‍ය එකිනෙකට වෙනස් නම්, සරල කට්ටල වෙනසක් සිදු කරයි.

c = [1,2,3,4,'x',8,6,7,'x',9,'x']
z = list(set(c) - set(['x']))
print z
[1, 2, 3, 4, 6, 7, 8, 9]

ලැයිස්තුවක වටිනාකමක් සොයා ගැනීම සහ එම දර්ශකය මකා දැමීම (එය තිබේ නම්) ලැයිස්තුව ඉවත් කිරීමේ ක්‍රමය භාවිතා කිරීමෙන් පහසු වේ:

>>> a = [1, 2, 3, 4]
>>> try:
...   a.remove(6)
... except ValueError:
...   pass
... 
>>> print a
[1, 2, 3, 4]
>>> try:
...   a.remove(3)
... except ValueError:
...   pass
... 
>>> print a
[1, 2, 4]

ඔබ මෙය බොහෝ විට කරන්නේ නම්, ඔබට එය ශ්‍රිතයකින් ඔතා ගත හැකිය:

def remove_if_exists(L, value):
  try:
    L.remove(value)
  except ValueError:
    pass

මෙම උදාහරණය වේගවත් වන අතර ලැයිස්තුවෙන් වටිනාකමේ සියලු අවස්ථා මකා දමනු ඇත:

a = [1,2,3,1,2,3,4]
while True:
    try:
        a.remove(3)
    except:
        break
print a
>>> [1, 2, 1, 2, 4]

එක් පේළියක:

a.remove('b') if 'b' in a else None

සමහර විට එය ප්‍රයෝජනවත් වේ.

ඊටත් වඩා පහසුයි:

if 'b' in a: a.remove('b')

ඔබ ඉවත් කිරීමට බලාපොරොත්තු වන අංග හැර සියල්ල සුචිගත කිරීමෙන් ලැයිස්තුව නැවත ලියන්න

>>> s = [5,4,3,2,1]
>>> s[0:2] + s[3:]
[5, 4, 2, 1]

වඩාත් පොදුවේ,

>>> s = [5,4,3,2,1]
>>> i = s.index(3)
>>> s[:i] + s[i+1:]
[5, 4, 2, 1]

අපට .pop:

>>> lst = [23,34,54,45]
>>> remove_element = 23
>>> if remove_element in lst:
...     lst.pop(lst.index(remove_element))
... 
23
>>> lst
[34, 54, 45]
>>> 

සඳහා පුඩුවක් සහ කොන්දේසියක් සමඟ:

def cleaner(seq, value):    
    temp = []                      
    for number in seq:
        if number != value:
            temp.append(number)
    return temp

ඔබට සමහරක් ඉවත් කිරීමට අවශ්‍ය නම්, නමුත් සියල්ලම නොවේ:

def cleaner(seq, value, occ):
    temp = []
    for number in seq:
        if number == value and occ:
            occ -= 1
            continue
        else:
            temp.append(number)
    return temp

 list1=[1,2,3,3,4,5,6,1,3,4,5]
 n=int(input('enter  number'))
 while n in list1:
    list1.remove(n)
 print(list1)

උදාහරණයක් ලෙස කියන්න, අපට x 1 න් සියල්ල ඉවත් කිරීමට අවශ්‍යය. මම මේ ගැන යන්නේ කෙසේද:

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

දැන්, මෙය මගේ ක්‍රමයේ ප්‍රායෝගික භාවිතයකි:

def Function(List, Unwanted):
    [List.remove(Unwanted) for Item in range(List.count(Unwanted))]
    return List
x = Function(x, 1)
print(x)

තනි පේළියක මෙය මගේ ක්‍රමයයි:

[x.remove(1) for Item in range(x.count(1))]
print(x)

දෙකම මෙය ප්‍රතිදානයක් ලෙස ලබා දෙයි:

[2, 3, 2, 3, 2, 3]

මෙය උපකාරී වේ යැයි සිතමි. PS, ආයාචනය කරන්න මෙය 3.6.2 අනුවාදයේ ලියා ඇති බැවින් පැරණි අනුවාද සඳහා එය සකස් කිරීමට ඔබට අවශ්‍ය විය හැකිය.

arr = [1, 1, 3, 4, 5, 2, 4, 3]

# to remove first occurence of that element, suppose 3 in this example
arr.remove(3)

# to remove all occurences of that element, again suppose 3
# use something called list comprehension
new_arr = [element for element in arr if element!=3]

# if you want to delete a position use "pop" function, suppose 
# position 4 
# the pop function also returns a value
removed_element = arr.pop(4)

# u can also use "del" to delete a position
del arr[4]

මෙය "-v"අරාවෙහි සියලු අවස්ථා ඉවත් කරයි sys.argv, සහ කිසිදු අවස්ථාවක් හමු නොවූයේ නම් පැමිණිලි නොකරයි:

while "-v" in sys.argv:
    sys.argv.remove('-v')

පහත දැක්වෙන ගොනුවකින් ඔබට කේතය ක්‍රියාකාරී ලෙස දැකිය හැකිය speechToText.py:

$ python speechToText.py -v
['speechToText.py']

$ python speechToText.py -x
['speechToText.py', '-x']

$ python speechToText.py -v -v
['speechToText.py']

$ python speechToText.py -v -v -x
['speechToText.py', '-x']

සමහර විට ඔබේ විසඳුම් ints සමඟ ක්‍රියා කරයි, නමුත් එය මට ශබ්ද කෝෂ සමඟ ක්‍රියා නොකරයි.

එක් අතකින්, ඉවත් කරන්න () මා වෙනුවෙන් වැඩ කර නැත. නමුත් සමහර විට එය මූලික වර්ග සමඟ ක්‍රියා කරයි. වස්තු ලැයිස්තුවෙන් අයිතම ඉවත් කිරීමේ ක්‍රමය ද කේත බෙලෝ බව මම අනුමාන කරමි.

අනෙක් අතට, 'ඩෙල්' නිසි ලෙස ක්‍රියා කර නැත. මගේ නඩුවේදී, පයිතන් 3.6 භාවිතා කිරීම: ඩෙල් විධාන සමඟ 'සඳහා' බකල් එකක ලැයිස්තුවකින් මූලද්‍රව්‍යයක් මකා දැමීමට උත්සාහ කරන විට, පයිතන් ක්‍රියාවලියේ දර්ශකය වෙනස් කරන අතර කාලයට පෙර බකල් අකාලයේ නතර වේ. එය ක්‍රියාත්මක වන්නේ ඔබ මූලද්‍රව්‍යය මූලද්‍රව්‍යය ප්‍රතිලෝම අනුපිළිවෙලින් මකා දැමුවහොත් පමණි . මේ ආකාරයට ඔබ අපේක්ෂිත මූලද්‍රව්‍ය අරාව දර්ශකය හරහා ගමන් කරන විට එය වෙනස් නොකරයි

එවිට, මම භාවිතා කළේ:

c = len(list)-1
for element in (reversed(list)):
    if condition(element):
        del list[c]
    c -= 1
print(list)

එහිදී 'ලැයිස්තුව' [key 'key1': value1 '}, key' key2 ': value2}, key' key3 ': value3}, ...]

ගණන් ගැනීමේදී ඔබට තවත් පයිතොනික් කළ හැකිය:

for i, element in enumerate(reversed(list)):
    if condition(element):
        del list[(i+1)*-1]
print(list)

මේ මගේ පිළිතුර, හුදෙක් භාවිතා වේ ඇති අතර සහ සඳහා

def remove_all(data, value):
    i = j = 0
    while j < len(data):
        if data[j] == value:
            j += 1
            continue
        data[i] = data[j]
        i += 1
        j += 1
    for x in range(j - i):
        data.pop()