Difference between del, remove, and pop on lists
Question:
Is there any difference between these three methods to remove an element from a list?
>>> a = [1, 2, 3]
>>> a.remove(2)
>>> a
[1, 3]
>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]
>>> a = [1, 2, 3]
>>> a.pop(1)
2
>>> a
[1, 3]
Answers:
The effects of the three different methods to remove an element from a list:
remove
removes the first matching value, not a specific index:
>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]
del
removes the item at a specific index:
>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]
and pop
removes the item at a specific index and returns it.
>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]
Their error modes are different too:
>>> a = [4, 5, 6]
>>> a.remove(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del a[7]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a.pop(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop index out of range
Use del
to remove an element by index, pop()
to remove it by index if you need the returned value, and remove()
to delete an element by value. The last requires searching the list, and raises ValueError
if no such value occurs in the list.
When deleting index i
from a list of n
elements, the computational complexities of these methods are
del O(n - i)
pop O(n - i)
remove O(n)
You can also use remove to remove a value by index as well.
n = [1, 3, 5]
n.remove(n[1])
n would then refer to [1, 5]
pop
Takes index (when given, else take last), removes value at that index, and returns value
remove
Takes value, removes first occurrence, and returns nothing
delete
Takes index, removes value at that index, and returns nothing
While pop and delete both take indices to remove an element as stated in above comments. A key difference is the time complexity for them. The time complexity for pop() with no index is O(1) but is not the same case for deletion of last element.
If your use case is always to delete the last element, it’s always preferable to use pop() over delete(). For more explanation on time complexities, you can refer to https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt
Since no-one else has mentioned it, note that del
(unlike pop
) allows the removal of a range of indexes because of list slicing:
>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]
This also allows avoidance of an IndexError
if the index is not in the list:
>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]
Any operation/function on different data structures is defined for particular actions. Here in your case i.e. removing an element, delete, Pop and remove. (If you consider sets, Add another operation – discard)
Other confusing case is while adding. Insert/Append.
For Demonstration, Let us Implement deque. deque is a hybrid linear data structure, where you can add elements / remove elements from both ends.(Rear and front Ends)
class Deque(object):
def __init__(self):
self.items=[]
def addFront(self,item):
return self.items.insert(0,item)
def addRear(self,item):
return self.items.append(item)
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
def returnAll(self):
return self.items[:]
In here, see the operations:
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
Operations have to return something. So, pop – With and without an index.
If I don’t want to return the value:
del self.items[0]
Delete by value not Index:
-
remove :
list_ez=[1,2,3,4,5,6,7,8]
for i in list_ez:
if i%2==0:
list_ez.remove(i)
print list_ez
Returns [1,3,5,7]
let us consider the case of sets.
set_ez=set_ez=set(range(10))
set_ez.remove(11)
# Gives Key Value Error.
##KeyError: 11
set_ez.discard(11)
# Does Not return any errors.
The remove operation on a list is given a value to remove. It searches the list to find an item with that value and deletes the first matching item it finds. It is an error if there is no matching item, raises a ValueError.
>>> x = [1, 0, 0, 0, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5]
>>> del x[7]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[7]
IndexError: list assignment index out of range
The del statement can be used to delete an entire list. If you have a specific list item as your argument to del (e.g. listname[7] to specifically reference the 8th item in the list), it’ll just delete that item. It is even possible to delete a “slice” from a list. It is an error if there index out of range, raises a IndexError.
>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]
>>> del x[4]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[4]
IndexError: list assignment index out of range
The usual use of pop is to delete the last item from a list as you use the list as a stack. Unlike del, pop returns the value that it popped off the list. You can optionally give an index value to pop and pop from other than the end of the list (e.g listname.pop(0) will delete the first item from the list and return that first item as its result). You can use this to make the list behave like a queue, but there are library routines available that can provide queue operations with better performance than pop(0) does. It is an error if there index out of range, raises a IndexError.
>>> x = [1, 2, 3]
>>> x.pop(2)
3
>>> x
[1, 2]
>>> x.pop(4)
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
x.pop(4)
IndexError: pop index out of range
See collections.deque for more details.
Many good explanations are here but I will try my best to simplify more.
Among all these methods, remove
& pop
are postfix while delete is prefix.
remove()
: Is used to remove first occurrence of element.
remove(n)
=> first occurrence of n
in the list.
>>> a = [0, 2, 3, 2, 1, 4, 6, 5, 7]
>>> a.remove(2) # where i = 2
>>> a
[0, 3, 2, 1, 4, 6, 5, 7]
pop()
: Is used to remove element …
- if no index is specified:
pop()
=> from end of list
>>> a.pop()
>>> a
[0, 3, 2, 1, 4, 6, 5]
- if an index is specified:
pop(index)
=> of index
>>> a.pop(2)
>>> a
[0, 3, 1, 4, 6, 5]
WARNING: Dangerous Method Ahead
del()
: It’s a prefix method.
Keep an eye on two different syntaxes for same method: with []
and without. It possesses power to:
- Delete index
del a[index]
=> used to delete by index and its associated value just like pop
.
>>> del a[1]
>>> a
[0, 1, 4, 6, 5]
- Delete values in range
[index_1:index_N]
:
del a[0:3]
=> multiple values in range.
>>> del a[0:3]
>>> a
[6, 5]
- Last but not least, to delete whole list in one shot.
del (a)
=> as said above.
>>> del (a)
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
Hope this clarifies the confusion.
Here is a detailed answer.
del can be used for any class object whereas pop and remove and bounded to specific classes.
For del
Here are some examples
>>> a = 5
>>> b = "this is string"
>>> c = 1.432
>>> d = myClass()
>>> del c
>>> del a, b, d # we can use comma separated objects
We can override __del__
method in user-created classes.
Specific uses with list
>>> a = [1, 4, 2, 4, 12, 3, 0]
>>> del a[4]
>>> a
[1, 4, 2, 4, 3, 0]
>>> del a[1: 3] # we can also use slicing for deleting range of indices
>>> a
[1, 4, 3, 0]
For pop
pop
takes the index as a parameter and removes the element at that index
Unlike del
, pop
when called on list object returns the value at that index
>>> a = [1, 5, 3, 4, 7, 8]
>>> a.pop(3) # Will return the value at index 3
4
>>> a
[1, 5, 3, 7, 8]
For remove
remove takes the parameter value and remove that value from the list.
If multiple values are present will remove the first occurrence
Note
: Will throw ValueError if that value is not present
>>> a = [1, 5, 3, 4, 2, 7, 5]
>>> a.remove(5) # removes first occurence of 5
>>> a
[1, 3, 4, 2, 7, 5]
>>> a.remove(5)
>>> a
[1, 3, 4, 2, 7]
Hope this answer is helpful.
remove(), del and pop() are slow… What about ‘None’?
In the midst of so many responses, I didn’t see anyone talking about performance. So I have an performance tip:
remove(), del and pop() after deletion move all remaining values ββto the left…
1, 2, 3, 4, 5, 6
remove(3)
1, 2, <- 4, 5, 6
…making processing slow!
Changing the desired value to a null for further processing of deletions only can add a lot of speed to your program, especially when dealing with a large volume of data:
my_array[2] = None
Of course, setting a null value is different from removing it, but if you want to understand a little more about deletion, thinking about the performance of this operation also seems interesting to me.
Difference among del, pop & remove in terms of execution speed:
While removing any intermediate item:
import timeit
print(timeit.timeit("a=[1,2,3,4,5]ndel a[3]",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.pop(3)",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.remove(3)",number=100000))
del
vs pop
vs remove
:
0.019387657986953855
0.02506213402375579
0.033232167130336165
del() seems significantly faster than the other two, while remove() being the slowest.
While removing the last item:
print(timeit.timeit("a=[1,2,3,4,5]ndel a[-1]",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.pop()",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.remove(5)",number=100000))
del
vs pop
vs remove
:
0.01974551402963698
0.020333584863692522
0.03434014297090471
del() and pop() take similar time removing last item.
Is there any difference between these three methods to remove an element from a list?
>>> a = [1, 2, 3]
>>> a.remove(2)
>>> a
[1, 3]
>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]
>>> a = [1, 2, 3]
>>> a.pop(1)
2
>>> a
[1, 3]
The effects of the three different methods to remove an element from a list:
remove
removes the first matching value, not a specific index:
>>> a = [0, 2, 3, 2]
>>> a.remove(2)
>>> a
[0, 3, 2]
del
removes the item at a specific index:
>>> a = [9, 8, 7, 6]
>>> del a[1]
>>> a
[9, 7, 6]
and pop
removes the item at a specific index and returns it.
>>> a = [4, 3, 5]
>>> a.pop(1)
3
>>> a
[4, 5]
Their error modes are different too:
>>> a = [4, 5, 6]
>>> a.remove(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> del a[7]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> a.pop(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: pop index out of range
Use del
to remove an element by index, pop()
to remove it by index if you need the returned value, and remove()
to delete an element by value. The last requires searching the list, and raises ValueError
if no such value occurs in the list.
When deleting index i
from a list of n
elements, the computational complexities of these methods are
del O(n - i)
pop O(n - i)
remove O(n)
You can also use remove to remove a value by index as well.
n = [1, 3, 5]
n.remove(n[1])
n would then refer to [1, 5]
pop
Takes index (when given, else take last), removes value at that index, and returns value
remove
Takes value, removes first occurrence, and returns nothing
delete
Takes index, removes value at that index, and returns nothing
While pop and delete both take indices to remove an element as stated in above comments. A key difference is the time complexity for them. The time complexity for pop() with no index is O(1) but is not the same case for deletion of last element.
If your use case is always to delete the last element, it’s always preferable to use pop() over delete(). For more explanation on time complexities, you can refer to https://www.ics.uci.edu/~pattis/ICS-33/lectures/complexitypython.txt
Since no-one else has mentioned it, note that del
(unlike pop
) allows the removal of a range of indexes because of list slicing:
>>> lst = [3, 2, 2, 1]
>>> del lst[1:]
>>> lst
[3]
This also allows avoidance of an IndexError
if the index is not in the list:
>>> lst = [3, 2, 2, 1]
>>> del lst[10:]
>>> lst
[3, 2, 2, 1]
Any operation/function on different data structures is defined for particular actions. Here in your case i.e. removing an element, delete, Pop and remove. (If you consider sets, Add another operation – discard)
Other confusing case is while adding. Insert/Append.
For Demonstration, Let us Implement deque. deque is a hybrid linear data structure, where you can add elements / remove elements from both ends.(Rear and front Ends)
class Deque(object):
def __init__(self):
self.items=[]
def addFront(self,item):
return self.items.insert(0,item)
def addRear(self,item):
return self.items.append(item)
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
def returnAll(self):
return self.items[:]
In here, see the operations:
def deleteFront(self):
return self.items.pop(0)
def deleteRear(self):
return self.items.pop()
Operations have to return something. So, pop – With and without an index.
If I don’t want to return the value:
del self.items[0]
Delete by value not Index:
-
remove :
list_ez=[1,2,3,4,5,6,7,8] for i in list_ez: if i%2==0: list_ez.remove(i) print list_ez
Returns [1,3,5,7]
let us consider the case of sets.
set_ez=set_ez=set(range(10))
set_ez.remove(11)
# Gives Key Value Error.
##KeyError: 11
set_ez.discard(11)
# Does Not return any errors.
The remove operation on a list is given a value to remove. It searches the list to find an item with that value and deletes the first matching item it finds. It is an error if there is no matching item, raises a ValueError.
>>> x = [1, 0, 0, 0, 3, 4, 5]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5]
>>> del x[7]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[7]
IndexError: list assignment index out of range
The del statement can be used to delete an entire list. If you have a specific list item as your argument to del (e.g. listname[7] to specifically reference the 8th item in the list), it’ll just delete that item. It is even possible to delete a “slice” from a list. It is an error if there index out of range, raises a IndexError.
>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]
>>> del x[4]
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
del x[4]
IndexError: list assignment index out of range
The usual use of pop is to delete the last item from a list as you use the list as a stack. Unlike del, pop returns the value that it popped off the list. You can optionally give an index value to pop and pop from other than the end of the list (e.g listname.pop(0) will delete the first item from the list and return that first item as its result). You can use this to make the list behave like a queue, but there are library routines available that can provide queue operations with better performance than pop(0) does. It is an error if there index out of range, raises a IndexError.
>>> x = [1, 2, 3]
>>> x.pop(2)
3
>>> x
[1, 2]
>>> x.pop(4)
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
x.pop(4)
IndexError: pop index out of range
See collections.deque for more details.
Many good explanations are here but I will try my best to simplify more.
Among all these methods, remove
& pop
are postfix while delete is prefix.
remove()
: Is used to remove first occurrence of element.
remove(n)
=> first occurrence of n
in the list.
>>> a = [0, 2, 3, 2, 1, 4, 6, 5, 7]
>>> a.remove(2) # where i = 2
>>> a
[0, 3, 2, 1, 4, 6, 5, 7]
pop()
: Is used to remove element …
- if no index is specified:
pop()
=> from end of list
>>> a.pop()
>>> a
[0, 3, 2, 1, 4, 6, 5]
- if an index is specified:
pop(index)
=> of index
>>> a.pop(2)
>>> a
[0, 3, 1, 4, 6, 5]
WARNING: Dangerous Method Ahead
del()
: It’s a prefix method.
Keep an eye on two different syntaxes for same method: with []
and without. It possesses power to:
- Delete index
del a[index]
=> used to delete by index and its associated value just likepop
.
>>> del a[1]
>>> a
[0, 1, 4, 6, 5]
- Delete values in range
[index_1:index_N]
:
del a[0:3]
=> multiple values in range.
>>> del a[0:3]
>>> a
[6, 5]
- Last but not least, to delete whole list in one shot.
del (a)
=> as said above.
>>> del (a)
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
Hope this clarifies the confusion.
Here is a detailed answer.
del can be used for any class object whereas pop and remove and bounded to specific classes.
For del
Here are some examples
>>> a = 5
>>> b = "this is string"
>>> c = 1.432
>>> d = myClass()
>>> del c
>>> del a, b, d # we can use comma separated objects
We can override __del__
method in user-created classes.
Specific uses with list
>>> a = [1, 4, 2, 4, 12, 3, 0]
>>> del a[4]
>>> a
[1, 4, 2, 4, 3, 0]
>>> del a[1: 3] # we can also use slicing for deleting range of indices
>>> a
[1, 4, 3, 0]
For pop
pop
takes the index as a parameter and removes the element at that index
Unlike del
, pop
when called on list object returns the value at that index
>>> a = [1, 5, 3, 4, 7, 8]
>>> a.pop(3) # Will return the value at index 3
4
>>> a
[1, 5, 3, 7, 8]
For remove
remove takes the parameter value and remove that value from the list.
If multiple values are present will remove the first occurrence
Note
: Will throw ValueError if that value is not present
>>> a = [1, 5, 3, 4, 2, 7, 5]
>>> a.remove(5) # removes first occurence of 5
>>> a
[1, 3, 4, 2, 7, 5]
>>> a.remove(5)
>>> a
[1, 3, 4, 2, 7]
Hope this answer is helpful.
remove(), del and pop() are slow… What about ‘None’?
In the midst of so many responses, I didn’t see anyone talking about performance. So I have an performance tip:
remove(), del and pop() after deletion move all remaining values ββto the left…
1, 2, 3, 4, 5, 6
remove(3)
1, 2, <- 4, 5, 6
…making processing slow!
Changing the desired value to a null for further processing of deletions only can add a lot of speed to your program, especially when dealing with a large volume of data:
my_array[2] = None
Of course, setting a null value is different from removing it, but if you want to understand a little more about deletion, thinking about the performance of this operation also seems interesting to me.
Difference among del, pop & remove in terms of execution speed:
While removing any intermediate item:
import timeit
print(timeit.timeit("a=[1,2,3,4,5]ndel a[3]",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.pop(3)",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.remove(3)",number=100000))
del
vs pop
vs remove
:
0.019387657986953855
0.02506213402375579
0.033232167130336165
del() seems significantly faster than the other two, while remove() being the slowest.
While removing the last item:
print(timeit.timeit("a=[1,2,3,4,5]ndel a[-1]",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.pop()",number=100000))
print(timeit.timeit("a=[1,2,3,4,5]na.remove(5)",number=100000))
del
vs pop
vs remove
:
0.01974551402963698
0.020333584863692522
0.03434014297090471
del() and pop() take similar time removing last item.