How to remove an element from a list by index in Python?
How to remove an element from a list by index in 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.
Use del and specify the element you want to delete with the index:
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.
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:
a = ['a', 'b', 'c', 'd']
a.pop()
# now a is ['a', 'b', 'c']
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 ):
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__ ):
>>> 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 )
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 ...
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.
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.
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.
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.
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 .
上一篇: 在Python中获取列表的最后一个元素