如何通过索引从列表中删除元素

问题描述：

如何通过索引从列表中删除元素？

我找到了，但是这会慢慢地按值list.remove()扫描列表以查找项目。

解决方案 1：

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

这是本教程的一部分。

解决方案 2：

你可能想要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']

解决方案 3：

就像其他人提到的那样，pop 和 del 是删除给定索引项的有效方法。但只是为了完成（因为在 Python 中可以通过多种方式完成同一件事）：

使用切片（这不会从原始列表中删除项目）：

（此外，在使用 Python 列表时，这也是效率最低的方法，但在使用不支持弹出但定义了 a 的用户定义对象时，这可能很有用（但效率不高，我重申）__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）。因此，旧列表对象被取消引用，并被垃圾回收（前提是原始列表对象未被除 a 之外的任何变量引用）。

这使得该方法非常低效，而且还会产生不良的副作用（尤其是当其他变量指向未被修改的原始列表对象时）。

感谢@MarkDickinson 指出这一点...

这个Stack Overflow 答案解释了切片的概念。

还请注意，这只对正指数有效。

在使用对象时，__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方法：

它比 del 方法效率低，当您需要获取已删除的项目时使用。

代码：

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。

解决方案 4：

如果要删除列表中特定位置的元素，例如第 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]]

解决方案 5：

pop也可用于从列表中删除和保留某项。del实际上会删除该项。

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

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

解决方案 6：

前面已经提到了如何从列表中删除单个元素，以及不同方法的优点。但请注意，删除多个元素可能会出现一些错误：

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

解决方案 7：

使用del语句：

del listName[-N]

例如，如果您想删除最后 3 个项目，您的代码应该是：

del listName[-3:]

例如，如果您想删除最后 8 个项目，您的代码应该是：

del listName[-8:]

解决方案 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:]）。

解决方案 9：

还有另一种方法，通过索引从列表中删除元素。

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。当我们将列表的该部分声明为空列表 ( []) 时，这些元素将被删除。

解决方案 10：

一般我都是采用下面的方法：

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

解决方案 11：

您可以直接搜索要删除的项目。这非常简单。例如：

    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

解决方案 12：

使用以下代码从列表中删除元素：

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]

解决方案 13：

如前所述，如果您需要知道值，最佳做法是 del(); 或 pop()。

另一种解决方案是仅重新堆叠您想要的那些元素：

    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：嗯...不适用于负指数值，将考虑并更新

我想

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

会修补它……但突然间这个想法似乎非常脆弱。不过，这是一个有趣的思想实验。似乎应该有一种“正确”的方法，使用 append() / 列表推导来实现这一点。

思考

解决方案 14：

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]

解决方案 15：

听起来你不是在处理列表列表，所以我就简短一点吧。你想使用 pop，因为它会删除元素，而不是列表元素，你应该使用 del。在 python 中调用最后一个元素是“-1”

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

解决方案 16：

或者如果需要删除多个索引：

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

解决方案 17：

您可以使用 del 或 pop 根据索引从列表中删除元素。Pop 将打印要从列表中删除的成员，而 list 将删除该成员而不打印它。

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

解决方案 18：

可以使用 del 或 pop，但我更喜欢 del，因为您可以指定索引和切片，从而让用户更好地控制数据。

例如，从显示的列表开始，可以使用del作为切片删除其最后一个元素，然后可以使用从结果中删除最后一个元素pop。

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