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

I would not worry about the performance differences unless you have specific reason to believe that they are causing meaningful slowdowns in your program, which is unlikely.

The real reason you might choose to use del vs pop is because they have different behaviors. pop returns the value for the popped key, so you would use pop if you want to do something with that value at the same time as you remove it. If you don't need to do anything with the value, but just want to remove the item, use del.

Good question! A simple difference is pop() returns the item removed so it can be assigned a different label while del simply removes the item. If you use pop() and do not assign a new label to the returned object it is essentially performing the same function as del. The list of book title strings is actually a list of references that point to string objects stored in memory. Each string object "id" is the address in memory of the stored object. ```python b1 = "book title 1" b2 = "book title 2" b3 = "book title 3" b4 = "book title 4" book_list = [b1, b2, b3, b4] print(book_list) ['book title 1', 'book title 2', 'book title 3', 'book title 4'] print([id(b1), id(b2), id(b3, id(b4)]) [139996358750368, 139996358750256, 139996358750592, 139996358750648] print([id(book) for book in book_list]) [139996358750368, 139996358750256, 139996358750592, 139996358750648] saved = book_list.pop(0) print(saved) book title 1 print(id(saved)) 139996358750368 ``` In a more detailed look, pop() returns the "id" reference removed so that it can be assigned to another label or used in a subsequent statement. The label saved is assigned to the first book popped from the book list. So, use pop() when you want to have access to the removed item for another purpose, and use del when you no longer want the item. Edit: to comment on “garbage collection”. Garbage collection happens when an object is removed from memory and the memory freed for other uses. This occurs when all references to an object are removed. pop() removed the list’s reference to object (count goes down by 1). If count is now zero, object maybe garbage collected. If a label is assigned to the popped object, this adds a new reference (count goes up by 1). So labeling a pop becomes a wash (no net change in reference count). del removes the label (the count goes down by 1) but not the object. Using del b4 simply removes the label b4 but not the object referenced by b4 since the string “book title 4” is still referenced by the list. Post back if you have more questions. Good luck!!

Disclaimer Quick and dirty benchmark:

Using IPython on Python 3.7.6, it appears that del list[0] is faster as it takes only about 65% of the time spent by list.pop(0).

Commands used:

## Baseline to be subtracted
%timeit lst = list(range(10))
# >> 230 ns ± 1.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

## list.pop(0) time taken
%timeit lst = list(range(10)); lst.pop(0)
# >> 281 ns ± 0.926 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

## del list[0] time taken
%timeit lst = list(range(10)); del lst[0]
# >> 263 ns ± 1.11 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

(263-230)/(281-230) = 33/51 = 65%

Also, pop returns that value that was removed, remove doesn’t.

• d.pop(key) -- consider using this if you need the value for the item being deleted, and/or you want to specify a default value and don't want an exception raised if the key doesn't exist.
  e.g., value = d.pop(key, None)
• del key -- consider using this if you are certain that the key exists (or you expect an exception if it doesn't), and you don't need the value of the item being deleted.
  e.g., del key

From the official Python language documentation:

del d[key] Remove d[key] from d. Raises a KeyError if key is not in the map.

pop(key[, default]) If key is in the dictionary, remove it and return its value, else return default. If default is not given and key is not in the dictionary, a KeyError is raised.

https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

This is simply how lists work, nothing surprising here. Removing the first element requires moving all the elements after it one step to the left to fill that gap, which makes this operation run in linear time. It means that clearing the list this way is O(n2), so it unsurprisingly takes a long time, as bubble sorting the (shuffled) list could even be faster. This is why we think of alternatives when solving problems, such as using collections.deque, reversing the list (O(n) instead of O(n2)) or just using pop() from the end if it works.

Popping a dictionary element returns the value to which the key points to. It also deletes it afterward.