如何用Python中的索引从列表中删除一个元素?

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

如何用Python中的索引从列表中删除一个元素?

I found the list.remove method, but say I want to remove the last element, how do I do this? It seems like the default remove searches the list, but I don't want any search to be performed.

我发现这个列表。删除方法，但是我想删除最后一个元素，我该怎么做呢?似乎默认移除搜索列表，但我不希望任何搜索被执行。

16 个解决方案

#1

Use del and specify the element you want to delete with the index:

使用del并指定要删除的元素:

In [9]: a = list(range(10))
In [10]: a
Out[10]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [11]: del a[-1]
In [12]: a
Out[12]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

Here is the section from the tutorial.

这是本教程的部分。

#2

You probably want pop:

你可能想要流行:

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

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

By default, pop without any arguments removes the last item:

默认情况下，pop没有任何参数删除最后一个项:

a = ['a', 'b', 'c', 'd']
a.pop()

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

#3

Like others mentioned pop and del are the efficient ways to remove an item of given index. Yet just for the sake of completion ( since the same thing can be done via many ways in python ):

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

Using slices ( This does not do inplace removal of item from original list ) :

使用切片(此方法不会将项目从原始列表中删除):

( Also this will be the least efficient method when working with python list but this could be useful ( but not efficient, I reiterate ) when working with user defined objects that do not support pop, yet do define a __getitem__ ):

(在使用python列表时，这将是最低效的方法，但在使用不支持pop的用户定义对象时，这可能是有用的(但不是有效的)，但确实定义了一个__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 ]

Note: Please note that this method does not modify the list inplace like pop and del. It instead makes two copies of lists ( one from the start until the index but without it ( a[:index] ) and one after the index till the last element ( a[index+1:] ) ) and creates a new list object by adding both. This is then reassigned to the list variable ( a ). The old list object is hence dereferenced and hence garbage collected ( provided the original list object is not referenced by any variable other than a )

注意:请注意，此方法不会修改列表的位置，如pop和del。相反，它会生成两个列表的副本(一个从开始到索引，但没有索引(一个[:索引])，一个在索引后面，直到最后一个元素(a[index+1:]))，并通过添加这两个元素创建一个新的列表对象。然后将其重新分配给list变量(a)。因此，旧的列表对象会被取消引用，因此会被垃圾收集(如果原始列表对象没有被其他变量引用，则不会被引用)

This makes this method very inefficient and it can also produce undesirable side effects ( especially when other variables point to the original list object which remains un-modified )

这使得该方法非常低效，而且还可能产生不良的副作用(特别是当其他变量指向未修改的原始列表对象时)

Thanks to @MarkDickinson for pointing this out ...

感谢@MarkDickinson指出这一点……

This Stack Overflow answer explains the concept of slicing.

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

Also note that this works only with positive indices.

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

While using with objects, the __getitem__ method must have been defined and more importantly the __add__ method must have been defined to return an object containing items from both the operands.

在使用对象时，__getitem__方法必须被定义，更重要的是，必须定义__add__方法来返回包含两个操作数的对象的对象。

In essence this works with any object whose class definition is like :

从本质上说，这适用于任何类定义为:

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 )

This works with list which defines __getitem__ and __add__ methods.

这与list定义了__getitem__和__add__方法。

Comparison of the three ways in terms of efficiency:

三种方式的效率比较:

Assume the following is predefined :

假设以下是预定义的:

a = range(10)
index = 3

The del object[index] method:

德尔对象(指数)方法:

By far the most efficient method. Works will all objects that define a __del__ method.

到目前为止，这是最有效的方法。Works将所有定义__del__方法的对象。

The disassembly is as follows :

拆卸工作如下:

Code:

代码:

def del_method():
    global a
    global index
    del a[index]

Disassembly:

拆卸:

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

流行的方法:

Less efficient than the del method. Used when you need to get the deleted item.

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

Code:

代码:

def pop_method():
    global a
    global index
    a.pop(index)

Disassembly:

拆卸:

 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        

The slice and add method.

切片和添加方法。

The least efficient.

最有效的。

Code:

代码:

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

Disassembly:

拆卸:

 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

Note : In all three disassembles ignore the last 2 lines which basically are return None Also the first 2 lines are loading the global values a and index.

注意:在所有的三次反汇编中，忽略最后两行基本上都没有返回，而前两行也没有加载全局值a和索引。

#4

pop is also useful to remove and keep an item from a list. Where del actually trashes the item.

pop也很有用，可以从列表中删除和保存项目。在这里，del实际上将该项目进行了标记。

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

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

#5

Generally, I am using the following method:

一般来说，我使用以下方法:

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

#6

This depends on what you want to do.

这取决于你想做什么。

If you want to return the element you removed, use pop():

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

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

However, if you just want to delete an element, use del:

但是，如果您只想删除一个元素，可以使用del:

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

Additionally, del allows you to use slices (e.g. del[2:]).

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

#7

You could just search for the item you want to delete. really simple. Example:

你可以搜索你想删除的条目。很简单的。例子:

    letters = ["a", "b", "c", "d", "e"]
    numbers.remove(numbers[1])
    print(*letters) # used a * to make it unpack you don't have to

output: a c d e

输出:c d e。

#8

Use the following code to remove element from the list:

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

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

output = [2, 3, 4]

If you want to remove index element data from the list use:

如果要从列表中删除索引元素数据:

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

#9

Yet another way to remove an element(s) from a list by index.

还有一种从索引列表中删除元素的方法。

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] points to the elements from index x to y-1. When we declare that portion of the list as an empty list ([]), those elements are removed.

a[x:y]指向从x到y-1的元素。当我们将列表的部分声明为空列表([])时，这些元素将被删除。

#10

As previously mentioned, best practice is del(); or pop() if you need to know the value.

如前所述，最佳实践是del();或者pop()如果你需要知道它的值。

An alternate solution is to re-stack only those elements you want:

另一种解决方案是只重新堆叠你想要的元素:

    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: hmm... will not work on negative index values, will ponder and update

埃塔:嗯……不会对负面的索引值工作，会思考和更新吗?

I suppose

我想

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

would patch it... but suddenly this idea seems very brittle. Interesting thought experiment though. Seems there should be a 'proper' way to do this with append() / list comprehension.

将补丁……但突然间，这个想法显得很脆弱。有趣的思想实验。似乎应该有一个“适当的”方法来使用append() /列表理解。

pondering

思考

#11

It doesn't sound like you're working with a list of lists, so I'll keep this short. You want to use pop since it will remove elements not elements that are lists, you should use del for that. To call the last element in python it's "-1"

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

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

#12

Use the "del" function:

使用“▽”功能:

del listName[-N]

For example, if you want to remove the last 3 items, your code should be:

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

del listName[-3:]

For example, if you want to remove the last 8 items, your code should be:

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

del listName[-8:]

#13

You can use either del or pop to remove element from list based on index. Pop will print member it is removing from list, while list delete that member without printing it.

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

#14

You can simply use the remove function of python.like this:

您可以简单地使用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]

#15

One can either use del or pop, but I prefer del, since you can specify index and slices, giving the user more control over the data.

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

For example, starting with the list shown, one can remove its last element with del as a slice, and then one can remove the last element from the result using pop.

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

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

#16

l - list of values; we have to remove indexes from inds2rem list.

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]