如何在Python中按索引从列表中删除元素？


How do I remove an element from a list by index in Python?

如何在Python中按索引从列表中删除元素？

我找到了list.remove方法，但是假设我想删除最后一个元素，我该怎么做？似乎默认的删除搜索列表，但我不希望执行任何搜索。

相关讨论

使用del并指定要删除的元素的索引：

1
2
3
4
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> del a[-1]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8]

还支持切片：

1
2
3
>>> del a[2:4]
>>> a
[0, 1, 4, 5, 6, 7, 8, 9]

这是本教程的一节。

相关讨论

您可能需要pop：

1
2
3
4
a = ['a', 'b', 'c', 'd']
a.pop(1)

# now a is ['a', 'c', 'd']

默认情况下，没有任何参数的pop将删除最后一项：

1
2
3
4
a = ['a', 'b', 'c', 'd']
a.pop()

# now a is ['a', 'b', 'c']
相关讨论

和其他人提到的一样，pop和del是删除给定索引项的有效方法。然而，仅仅是为了完成(因为同样的事情可以通过许多方法在Python中完成)：

使用切片(这不会就地从原始列表中删除项目)：

(在使用python list时，这也是最不有效的方法，但在使用不支持pop但定义__getitem__的用户定义对象时，这可能很有用(但不是有效的，我重申一下)：

1
2
3
4
5
>>> 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指出这一点…

这个堆栈溢出答案解释了切片的概念。

还要注意，这只适用于正指数。

在与对象一起使用时，必须定义__getitem__方法，更重要的是，必须定义__add__方法以返回包含两个操作数中的项的对象。

本质上，这适用于类定义如下的任何对象：

1
2
3
4
5
6
7
8
9
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 )

这与定义__getitem__和__add__方法的list一起工作。

三种方法在效率方面的比较：

假设预先定义了以下内容：

1
2
a = range(10)
index = 3

del object[index]法：

到目前为止，这是最有效的方法。它适用于定义__del__方法的所有对象。

拆卸如下：

代码：

1
2
3
4
def del_method():
    global a
    global index
    del a[index]

Disassembly：

1
2
3
4
5
6
 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方法效率低，在需要获取已删除项时使用。

代码：

1
2
3
4
def pop_method():
    global a
    global index
    a.pop(index)

Disassembly：

1
2
3
4
5
6
7
 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

切片和添加方法。

效率最低的。

代码：

1
2
3
4
def slice_method():
    global a
    global index
    a = a[:index] + a[index+1:]

Disassembly：

1
2
3
4
5
6
7
8
9
10
11
12
13
 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实际上是垃圾。

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

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

这取决于你想做什么。

如果要返回删除的元素，请使用pop()：

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

但是，如果只想删除一个元素，请使用del：

1
2
3
4
>>> l = [1, 2, 3, 4, 5]
>>> del l[2]
>>> l
[1, 2, 4, 5]

另外，del允许您使用切片(例如del[2:])。

通常，我使用以下方法：

1
2
3
4
5
>>> myList = [10,20,30,40,50]
>>> rmovIndxNo = 3
>>> del myList[rmovIndxNo]
>>> myList
[10, 20, 30, 50]

另一种方法是按索引从列表中删除元素。

1
2
3
4
5
6
7
8
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的元素。当我们声明列表的一部分为空列表([]时，这些元素将被删除。

您可以搜索要删除的项目。这真的很简单。例子：

1
2
3
    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)

输出：一个C D

相关讨论

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

1
2
3
4
5
list = [1, 2, 3, 4]
list.remove(1)
print(list)

output = [2, 3, 4]

如果要从列表中删除索引元素数据，请使用：

1
2
3
4
list = [1, 2, 3, 4]
list.remove(list[2])
print(list)
output : [1, 2, 4]
相关讨论

如前所述，如果需要知道值，最佳实践是del()；或pop()。

另一种解决方案是只重新堆叠需要的元素：

1
2
3
4
5
6
7
8
9
10
11
12
    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']

埃塔：嗯…不会对负索引值起作用，会思考和更新

我想

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

会修补它…但突然间，这个想法显得很脆弱。不过，有趣的思维实验。对于append()/list的理解，似乎应该有一种"正确"的方法来实现这一点。

沉思

相关讨论

这听起来不像是你在处理一个列表，所以我会保持简短。您希望使用pop，因为它将删除元素而不是列表中的元素，所以应该使用del。调用python中的最后一个元素是"-1"

1
2
3
4
5
>>> test = ['item1', 'item2']
>>> test.pop(-1)
'item2'
>>> test
['item1']
相关讨论

L-值列表；我们必须从inds2rem列表中删除索引。

1
2
3
4
5
6
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]
相关讨论

如果要删除列表中的特定位置元素，如2th、3th和7th。你不能用

1
2
3
del my_list[2]
del my_list[3]
del my_list[7]

因为删除第二个元素后，删除的第三个元素实际上是原始列表中的第四个元素。您可以过滤原始列表中的2th、3th和7th元素并得到一个新的列表，如下所示：

1
new list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]
相关讨论

使用"del"功能：

1
del listName[-N]

例如，如果要删除最后3个项，则代码应为：

1
del listName[-3:]

例如，如果要删除最后8项，则代码应为：

1
del listName[-8:]
相关讨论

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

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

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

或者如果应删除多个索引：

1
print([v for i,v in enumerate(your_list) if i not in list_of_unwanted_indexes])

当然，也可以这样做：

1
print([v for i,v in enumerate(your_list) if i != unwanted_index])
相关讨论

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

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

但不要将pop()与loop一起使用。它将导致错误。请使用pop()而不使用loop。

您可以简单地使用python的remove函数。这样地：

1
2
3
4
5
6
v = [1, 2, 3, 4, 5, 6]
v.remove(v[4]) # I'm removing the number with index 4 of my array
print(v) # If you want verify the process

# It gave me this:
#[1,2,3,4,6]
相关讨论