有没有简单的方法可以按值删除列表元素？-IT科技

摘要：问题描述：如果列表中存在某个值（但可能不存在），我想将其从列表中删除。a = [1, 2, 3, 4] b = a.index(6) del a[b] print(a) 上面给出了错误：ValueError: list.index(x): x not in list 所以我必须这样做：a = [1, 2, ...

问题描述：

如果列表中存在某个值（但可能不存在），我想将其从列表中删除。

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

del a[b]
print(a)

上面给出了错误：

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)

但难道没有更简单的方法可以做到这一点吗？

解决方案 1：

要删除元素的第一次出现list.remove，请使用：

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

要删除元素的所有出现，请使用列表推导：

>>> xs = ['a', 'b', 'c', 'd', 'b', 'b', 'b', 'b']
>>> xs = [x for x in xs if x != 'b']
>>> print(xs)
['a', 'c', 'd']

解决方案 2：

通常，如果您告诉 Python 执行其无法完成的操作，它会抛出异常，因此您必须执行以下任一操作：

if c in a:
    a.remove(c)

或者：

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

只要异常是您预料到的并且能够正确处理，异常并不一定是坏事。

解决方案 3：

你可以做

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

但上面需要在列表 a 中搜索 6 2 次，因此尝试 except 会更快

try:
    a.remove(6)
except:
    pass

解决方案 4：

考虑：

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

要删除所有出现的内容，可以使用 Python 中的 filter 函数。例如，它看起来像：

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

因此，它将保留的所有元素a != 2。

要取出其中一件物品，请使用

a.remove(2)

解决方案 5：

以下是如何就地执行此操作（不使用列表理解）：

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

解决方案 6：

正如许多其他答案所述，list.remove()可以工作，但如果该项目不在列表中，则会抛出ValueError。使用 python 3.4+，有一种有趣的方法来处理这个问题，使用suppress contextmanager：

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

解决方案 7：

如果您知道要删除什么值，这里有一个简单的方法（无论如何，这是我能想到的最简单的方法）：

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

你会得到
[0, 0, 2, 3, 4]

解决方案 8：

一行代码：

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

有时它很有用。

甚至更简单：

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

解决方案 9：

另一种可能性是使用集合而不是列表（如果集合适用于您的应用程序）。

即如果你的数据没有排序，并且没有重复，那么

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

没有错误。

通常，列表只是用于存放无序项的便捷容器。有人会问如何从列表中删除某个元素的所有出现。如果您一开始就不想重复，那么集合再次派上用场。

my_set.add(3)

不会从上面改变 my_set。

解决方案 10：

如果您的元素不同，那么简单的集合差异就可以了。

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]

解决方案 11：

此示例很快，将从列表中删除某个值的所有实例：

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

解决方案 12：

只需使用列表的 remove 方法即可更轻松地在列表中查找值，然后删除该索引（如果存在）：

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

解决方案 13：

我们也可以使用.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]
>>>

解决方案 14：

这里的许多答案都涉及创建新列表。这涉及将旧列表中的所有数据复制到新列表（已删除的项目除外）。如果您的列表很大，您可能无法负担得起（或者您不应该想要）。

在这些情况下，就地修改列表会快得多。如果您必须从列表中删除多个元素，则可能会很棘手。假设您循环遍历列表并删除一个项目，则列表会发生变化，而标准 for 循环不会考虑这一点。循环的结果可能不是您所期望的。

例子：

a = [0, 1, 2, 3, 4, 5]
for i in a:
    a.remove(i)  # Remove all items
print(a)

Out: [1, 3, 5]

一个简单的解决方案是以相反的顺序循环遍历列表。在这种情况下，你会得到：

a = [0, 1, 2, 3, 4, 5]
for i in reversed(a):
    a.remove(i)  # Remove all items
print(a)

Out: []

然后，如果您只需要删除具有某些特定值的元素，那么您只需if statement在循环中放置一个即可：

a = [0, 1, 2, 3, 4, 5]
for i in reversed(a):
    if i == 2 or i == 3:  # Remove all items having value 2 or 3.
        a.remove(i)
print(a)

Out: [0, 1, 4, 5]

解决方案 15：

使用 for 循环和条件：

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

解决方案 16：

 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)

解决方案 17：

通过索引除要删除的元素之外的所有内容来覆盖列表

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

解决方案 18：

何时nums为列表并且c是要删除的值：

c要删除列表中第一次出现的，只需执行以下操作：

if c in nums:
    nums.remove(c)

c要从列表中删除所有出现的项，请执行以下操作：

while c in nums:
    nums.remove(c)

添加异常处理是最佳做法，但我主要想展示如何从列表中删除元素的所有出现。

解决方案 19：

举个例子，我们想从 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 版本中编写的，因此您可能需要针对旧版本进行调整。

解决方案 20：

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]

解决方案 21：

您可以使用它来从列表中查找和删除指定的项目

def find_and_delete_element(lst,item):
    for ele in lst:
        if ele == item:
            lst.remove(item)
    return lst

解决方案 22：

这将从"-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']

解决方案 23：

也许您的解决方案适用于整数，但对于我来说，它不适用于字典。

一方面，remove() 对我来说不起作用。但也许它适用于基本类型。我猜下面的代码也是从对象列表中删除项目的方法。

另一方面，“del”也未能正常工作。就我而言，使用的是 Python 3.6：当我尝试使用“del”命令从“for”队列中的列表中删除元素时，Python 会在此过程中更改索引，并且队列会提前停止。只有当您按相反顺序逐个删除元素时，它才会起作用。这样，您在遍历它时就不会更改待处理的元素数组索引

然后，我习惯：

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

其中 'list' 类似于 [{'key1':value1'},{'key2':value2}, {'key3':value3}, ...]

您还可以使用枚举执行更多 Python 操作：

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

解决方案 24：

这是我的答案，只需使用while和for

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

解决方案 25：

一些最简单的基准方法：

import random
from copy import copy
sample = random.sample(range(100000), 10000)
remove = random.sample(range(100000), 1000)

%%timeit
sample1 = copy(sample)
remove1 = copy(remove)

for i in reversed(sample1):
    if i in remove1:
        sample1.remove(i)
# 271 ms ± 16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# remove all instances

%%timeit
sample1 = copy(sample)
remove1 = copy(remove)

filtered = list(filter(lambda x: x not in remove1, sample1))
# 280 ms ± 18.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# remove all instances

%%timeit
sample1 = copy(sample)
remove1 = copy(remove) 

filtered = [ele for ele in sample1 if ele not in remove1]
# 293 ms ± 72.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# remove all instances

%%timeit
sample1 = copy(sample)
remove1 = copy(remove) 

for val in remove1:
    if val in sample1:
        sample1.remove(val)
# 558 ms ± 40.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# only remove first occurrence

%%timeit
sample1 = copy(sample)
remove1 = copy(remove) 

for val in remove1:
    try:
        sample1.remove(val)
    except:
        pass
# 609 ms ± 11.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
# only remove first occurrence

解决方案 26：

这是一个效率较低的解决方案，但它仍然有效：

a = [ ]// 这是你的列表

b // 您需要删除的元素

counter = a.count(b)

while counter > 0:
    if b in a:
       a.remove(b)
       counter -= 1

print(a)

解决方案 27：

这是使用以下方法的其他答案的变体：

反转()
列表理解
列表.删除（元素）

正如其他人指出的那样，reversed()需要确保以相反的顺序删除元素，否则，如果没有它，在向前遍历时，它将不会处理删除右侧的记录。

不同之处在于我们使用列表推导同时迭代和删除元素，因此无需重复遍历。我们还使用列表推导来构建已删除元素的列表。

a = [1,2,2,2,2,3,4,5]
deleted = [a.remove(n) or n for n in reversed(a) if n == 2]
print(deleted)
# [2, 2, 2, 2]
print(a)
# [1, 3, 4, 5]

对于结果列表中的值，我们使用a.remove(n) or n。左侧表达式，即a.remove(n)始终计算为None。因此，or将始终偏向右侧表达式，即n。因此，结果列表将始终是已删除项目的列表。当列表包含更复杂的对象（例如字典）时，这很有用。

materials = [{"n":"silver","t":"metal" },
             {"n":"iron"  ,"t":"metal" },
             {"n":"water" ,"t":"liquid"}]
deleted = [materials.remove(m) or m for m in reversed(materials) if m["t"] == "metal"]
print(deleted)
# [{'n': 'iron', 't': 'metal'}, {'n': 'silver', 't': 'metal'}]
print(materials)
# [{'n': 'water', 't': 'liquid'}]

这种方法的缺点是它会强制构建一个临时列表，在大多数情况下，您会在不久之后丢弃该列表。例如，在此示例中，临时列表在构建后立即被丢弃：

a = [1,2,2,2,2,3,4,5]
[a.remove(n) or n for n in reversed(a) if n == 2]
print(a)
# [1, 3, 4, 5]

该解决方案的优点在于它用 1 行简洁的 Python 代码实现了就地删除。