del and specify the index of the element you want to delete:
>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> del a[-1] >>> a [0, 1, 2, 3, 4, 5, 6, 7, 8]
Also supports slices:
>>> del a[2:4] >>> a [0, 1, 4, 5, 6, 7, 8, 9]
How to remove an element from a list by index in Python?
You probably want
a = ['a', 'b', 'c', 'd'] a.pop(1) # now a is ['a', 'c', 'd']
pop without any arguments removes the last item:
a = ['a', 'b', 'c', 'd'] a.pop() # now a is ['a', 'b', 'c']
As other answers mentioned pop and del are the efficient ways to remove an item from a given index. Yet just for the sake of completion (since the same thing can be done in many ways in Python):
Using slices (this does not do in place removal of an item from the 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
>>> 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 in place like
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).
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
Comparison of the three ways in terms of efficiency:
Assume the following is predefined:
a = range(10) index = 3
del object[index] method:
By far the most efficient method. It works will all objects that define a
The disassembly is as follows:
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
It is less efficient than the del method and is used when you need to get the deleted item.
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
The slice and add method.
The least efficient.
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
Note: In all three disassembles ignore the last two lines which basically are
return None. Also, the first two lines are loading the global values
If you want to remove elements at specific positions in a list, like the 2nd, 3rd and 7th elements, you can’t use
del my_list del my_list del my_list
Since after you delete the second element, the third element you delete actually is the fourth element in the original list. You can filter the 2nd, 3rd and 7th elements in the original list and get a new list, like below:
new_list = [j for i, j in enumerate(my_list) if i not in [2, 3, 7]]
How to remove multiple elements from a list by index in Python?
It has already been mentioned how to remove a single element from a list and which advantages the different methods have. Note, however, that removing multiple elements has some potential for errors:
>>> 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]
Elements 3 and 8 (not 3 and 7) of the original list have been removed (as the list was shortened during the loop), which might not have been the intention. If you want to safely remove multiple indices you should instead delete the elements with highest index first, e.g. like this:
>>> 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]
This depends on what you want to do.
If you want to return the element you removed, use
>>> 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
>>> l = [1, 2, 3, 4, 5] >>> del l >>> l [1, 2, 4, 5]
del allows you to use slices (e.g.
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
y-1. When we declare that portion of the list as an empty list (
), those elements are removed.
As previously mentioned, best practice is del(); or pop() if you need to know the value.
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
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.
Hope you learned something from this post.
Follow Programming Articles for more!