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

Question

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

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

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

Here是教程中的部分。

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

Answer 3

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

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

（这也是使用Python列表时效率最低的方法，但是当处理不支持pop的用户定义对象时，这可能很有用（但我觉得效率不高），但确实定义了{{1 }}）：

__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之外的任何变量引用）。

这使得此方法效率非常低，并且还会产生不良副作用（特别是当其他变量指向原始列表对象时仍然未修改）。

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

This Stack Overflow回答解释了切片的概念。

另请注意，这仅适用于正数指数。

在使用对象时，必须定义a方法，更重要的是必须定义 __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 方法：

效率低于del方法，在需要获取已删除项目时使用。

代码：

pop

拆卸：

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。

Answer 4

pop对于从列表中删除和保留项目也很有用。其中del实际上会破坏该项目。

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

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

Answer 5

这取决于你想做什么。

如果要返回删除的元素，请使用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:]）。

Answer 6

通常，我使用以下方法：

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

Answer 7

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

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

Answer 8

您只需搜索要删除的项目即可。这很简单。 例如：

    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)

输出：a c d e

Answer 9

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

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

Answer 10

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

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]

Answer 11

如前所述，最佳做法是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（）/ list comprehension。

琢磨

Answer 12

听起来你并没有使用列表清单，所以我会保持这么简短。你想使用pop，因为它将删除元素而不是列表元素，你应该使用del。要在python中调用最后一个元素，它是＆＃34; -1＆＃34;

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

Answer 13

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]

Answer 14

使用“del”功能：

del listName[-N]

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

del listName[-3:]

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

del listName[-8:]

Answer 15

已经提到了如何从列表中删除单个元素以及不同方法具有哪些优点。但是请注意，删除多个元素可能会导致错误：

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

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

Answer 17

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

Answer 18

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

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

Answer 19

切勿将pop()与循环一起使用。这将导致错误。使用pop()，不要循环。

Answer 20

您可以简单地使用Python的remove功能。像这样：

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]