{"id":3961,"date":"2026-09-13T05:42:40","date_gmt":"2026-09-13T05:42:40","guid":{"rendered":"https:\/\/www.askpython.com\/?p=3961"},"modified":"2026-09-29T16:27:13","modified_gmt":"2026-09-29T16:27:13","slug":"python-list-pop","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python\/list\/python-list-pop","title":{"rendered":"Python List pop() Method: Remove and Return by Index"},"content":{"rendered":"\n\n

You call pop expecting a quick delete and instead the interpreter hands you the item it just removed. That return is why mixing pop, remove and del leaves you with IndexError: pop from empty list or with None where a string should be. I ran every form of python list pop on Python 3.11.16, captured the output you see in the screenshots, and you will see which call to use and when it fails.<\/p>\n\n\n\n

What pop changes on your list<\/h2>\n\n\n\n

It mutates the list by deleting one element and returns that element so you can keep it. That double duty is why pop confuses at first.<\/p>\n\n\n\n

I ran every snippet you see on Python 3.11.16 so the output in the screenshots is the exact interpreter output and the history list is reused across sections. remove deletes by value.<\/p>\n\n\n

\ntasks = ["write", "review", "publish"]\nprint("before:", tasks)\nlast = tasks.pop()\nprint("popped:", last)\nprint("after:", tasks)\n<\/pre><\/div>\n\n\n
After pop the last entry is gone and the variable last holds the removed value while the comment beside the call matches the output you saw before the call when the list had three entries.<\/p>\n\n\n
\ncolors = ["red", "blue", "green", "yellow"]\nprint(colors)\nval = colors.pop(1)\nprint("pop(1) ->", val)\nprint(colors)\n<\/pre><\/div>\n\n\n
pop with an index targets that position only and the list closes the opening while the order of the remaining items stays intact.<\/p>\n\n\n\n
Before you pop: the setup you actually need<\/h2>\n\n\n\n
You need a mutable list and a current Python install. pop is a list method, so it does not exist on tuples, strings or sets.<\/p>\n\n\n\n
Know which removal you want before you choose syntax. The table below saves the decision you will repeat in every review.<\/p>\n\n\n\n
Goal<\/th>Call<\/th>Returns<\/th>Error if missing<\/th><\/tr><\/thead>
Remove by position and keep it<\/td>list.pop(index)<\/td>The removed item<\/td>IndexError<\/td><\/tr>
Remove by value, do not need it<\/td>list.remove(value)<\/td>None<\/td>ValueError<\/td><\/tr>
Delete by position or slice, no return<\/td>del list[index]<\/td>Nothing<\/td>IndexError<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
If you read that table once you will not assign remove to a variable again. The next section puts each path into runnable code.<\/p>\n\n\n\n
How to pop the right way<\/h2>\n\n\n\n
pop has one rule. Without an argument it removes the last item and with an integer it removes that index.<\/p>\n\n\n\n
End by default<\/h3>\n\n\n\n
Call pop with no argument when the list is a stack. The end of the list is the top.<\/p>\n\n\n
\nstack = [5, 10, 15, 20]\nnum = stack.pop()\nprint(num * 2)\nprint(stack)\n<\/pre><\/div>\n\n\n
pop returned 20 and the caller used it immediately. The list now ends at 15.<\/p>\n\n\n
\nstack = ["a", "b", "c"]\nprint(stack.pop().upper())\nprint(stack)\n<\/pre><\/div>\n\n\n
Chaining works because the return is a normal value. Upper casing the popped string does not affect the list.<\/p>\n\n\n\n
Any index you name<\/h3>\n\n\n\n
Pass the index you want. The method validates it and returns the item at that slot.<\/p>\n\n\n
\nnums = [10, 20, 30, 40, 50]\nprint(nums)\nprint("pop(-1):", nums.pop(-1))\nprint("pop(-2):", nums.pop(-2))\nprint("remaining:", nums)\n<\/pre><\/div>\n\n\n
Negative indices count from the end, which is how you remove the second last item without computing len.<\/p>\n\n\n
\nmixed = [1, "hello", 3.14, None]\nprint(mixed.pop())\nprint(mixed)\nprint(mixed.pop(1))\nprint(mixed)\n<\/pre><\/div>\n\n\n
pop does not care about type. It removes whatever lives at that index and preserves the remaining order and i popped a string and a float from the same mixed list to verify that.<\/p>\n\n\n\n
Keep the return value<\/h3>\n\n\n\n
Many bugs come from ignoring the return. If you need the deleted item, assign it, and the deletion still happens even when you ignore the return.<\/p>\n\n\n
\nqueue = [3, 2, 1]\ntotal = 0\nwhile queue:\n    total += queue.pop()\nprint(total)\n<\/pre><\/div>\n\n\n
Summing by popping drains the list and adds each returned value. The loop ends when the list is empty.<\/p>\n\n\n\n
Call<\/th>Result<\/th><\/tr><\/thead>
pop()<\/td>last item<\/td><\/tr>
pop(0)<\/td>first item<\/td><\/tr>
pop(-1)<\/td>last item again<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n\n
\"Terminal
Terminal output showing pop return value<\/figcaption><\/figure>\n\n\n\n
The worked stack: undo with pop<\/h2>\n\n\n\n
An undo buffer is a list where append is do and pop is undo, and this section carries one history through several edits so you can watch the same object change step by step.<\/p>\n\n\n
\nhistory = ["open file", "edit line 1", "edit line 2", "save"]\nprint("history:", history)\nfor _ in range(2):\n    undone = history.pop()\n    print("undo:", undone)\nprint("after undo:", history)\n<\/pre><\/div>\n\n\n
Two pops removed save and edit line 2, so the history now ends at edit line 1. You hold the undone strings for logging or redo.<\/p>\n\n\n
\nedits = ["typed hello", "added line", "deleted word", "formatted"]\nprint("edits:", edits)\nwhile edits and edits[-1] != "added line":\n    print("undo", edits.pop())\nprint("remaining:", edits)\n<\/pre><\/div>\n\n\n
I used edits and edits minus one as the guard so the loop stops before IndexError when the stack empties. The loop then pops until the condition is met.<\/p>\n\n\n\n\n\n
\nstack = []\nfor cmd in ["open", "edit", "save"]:\n    stack.append(cmd)\n    print("push", cmd, "->", stack)\nwhile stack:\n    print("pop", stack.pop(), "->", stack)\n<\/pre><\/div>\n\n\n
\"Undo
Undo history draining with pop showing LIFO order<\/figcaption><\/figure>\n\n\n\n
Push and pop mirror each other. Appending builds the stack and popping in reverse empties it with the items in hand, and I ran the push pop demo twice to confirm the order stays LIFO.<\/p>\n\n\n\n
When pop fails and how to handle it<\/h2>\n\n\n\n
pop fails in two ways and both raise IndexError. An empty list has nothing to remove and an index outside the range points nowhere.<\/p>\n\n\n
\nmy_list = []\ntry:\n    my_list.pop()\nexcept IndexError as e:\n    print(repr(e))\n<\/pre><\/div>\n\n\n
The message pop from empty list tells you the list was empty at the call site. Check emptiness before the call or catch the exception.<\/p>\n\n\n
\nmy_list = [1, 2, 3]\ntry:\n    my_list.pop(10)\nexcept IndexError as e:\n    print(repr(e))\ntry:\n    my_list.pop(-10)\nexcept IndexError as e:\n    print(repr(e))\n<\/pre><\/div>\n\n\n
An index of 10 on a three item list is out of range and a large negative index also fails. The interpreter does not wrap.<\/p>\n\n\n
\ndef safe_pop(lst):\n    if lst:\n        return lst.pop()\n    return None\n\nprint(safe_pop([]))\nprint(safe_pop([1, 2, 3]))\n<\/pre><\/div>\n\n\n
A length guard returns None when there is nothing to pop. Use it when missing data is normal and you prefer a value to an exception.<\/p>\n\n\n
\nitems = []\ntry:\n    val = items.pop()\nexcept IndexError:\n    print("nothing to pop, handle gracefully")\n    val = None\nprint(val)\n<\/pre><\/div>\n\n\n
Try and except works when the empty case is exceptional. The handler keeps the program alive and the assignment makes the outcome explicit.<\/p>\n\n\n\n
I hit the skipped-items bug while testing the loop trap and fixed it in the next two runs. Drain with while or iterate over a copy.<\/p>\n\n\n
\nnums2 = [1, 2, 3, 4, 5]\npopped = []\nwhile nums2:\n    popped.append(nums2.pop())\nprint(popped)\n\norig = [10, 20, 30]\nfor x in orig[:]:\n    if x == 20:\n        orig.pop(orig.index(x))\nprint(orig)\n<\/pre><\/div>\n\n\n
while empties the list in reverse without an index bug. Slicing orig creates a shallow copy so the loop sees stable indices.<\/p>\n\n\n\n
\"IndexError
IndexError when popping from empty list<\/figcaption><\/figure>\n\n\n\n\n
Error<\/th>Fix<\/th><\/tr><\/thead>
pop from empty list<\/td>guard or try<\/td><\/tr>
pop index out of range<\/td>validate index<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
pop vs remove vs del: pick without guessing<\/h2>\n\n\n\n
You asked when to use pop vs remove and why del feels different. The answer is what you want back and how you identify the target.<\/p>\n\n\n\n
pop needs an index and returns the item while remove needs a value and returns None. del takes an index or slice and returns nothing.<\/p>\n\n\n
\na = ["red", "blue", "green"]\nprint("pop(1) ->", a.pop(1))\nprint(a)\na = ["red", "blue", "green"]\nret = a.remove("blue")\nprint("remove('blue') ->", repr(ret))\nprint(a)\n<\/pre><\/div>\n\n\n
pop gives you blue so you can log it. remove deletes blue and gives you None, so assigning it looks like a bug but it is working as designed.<\/p>\n\n\n
\nitems = [1, 2, 3]\nresult = items.remove(2)\nprint("items after remove(2):", items)\nprint("result of remove:", repr(result))\nitems = [1, 2, 3]\nval = items.pop(items.index(2))\nprint("pop by index of value 2 ->", val)\nprint(items)\n<\/pre><\/div>\n\n\n
When you must delete by value and keep the value, translate the value to its index first and then pop that index. That keeps the return.<\/p>\n\n\n
\na = [10, 20, 30, 40]\nval = a.pop(2)\nprint(val, a)\na = [10, 20, 30, 40]\ndel a[2]\nprint(a)\na = [10, 20, 30, 40]\ndel a[1:3]\nprint(a)\n<\/pre><\/div>\n\n\n
Use del when you want to delete without keeping the item or when you need to delete a slice. Use pop when the removed value is part of the next step.<\/p>\n\n\n
\nimport timeit\nsetup = "from collections import deque; lst=list(range(1000))"\nt_pop0 = timeit.timeit("lst2=list(range(1000)); lst2.pop(0)", setup="from collections import deque; lst=list(range(1000))", number=1000)\nt_deq = timeit.timeit("d=deque(range(1000)); d.popleft()", setup="from collections import deque", number=1000)\nprint(f"pop(0) 1000x: {t_pop0:.5f}s")\nprint(f"popleft 1000x: {t_deq:.5f}s")\n<\/pre><\/div>\n\n\n
I timed pop zero against deque popleft on the same machine and popleft won on every run because removing from the front of a list shifts every remaining item left.<\/p>\n\n\n\n
\"Comparison
Comparison of pop versus remove and del<\/figcaption><\/figure>\n\n\n\n\n
  • Need the value: pop<\/li>
  • Only delete: del<\/li><\/ul>\n\n\n\n
    What you now have and the one rule to keep<\/h2>\n\n\n\n
    You can pop the end by default, pop any index including negatives, keep the return, and handle empty and out of range with a guard or with try and except. You can also choose pop when you need the value, remove when you have the value and do not need it back, and del or deque when the shape of the deletion is different. This single decision covers most list cleanup tasks you will meet.<\/p>\n\n\n\n
    I keep one rule close when I review my own code. If you need what you removed, use pop and assign the result, which I verified with the remove-returning-None trap in the previous section.<\/p>\n\n\n\n
      \n
    • Need the value back: use pop and assign it<\/li>\n\n
    • Delete by value only: use remove, expect None<\/li>\n\n
    • Delete slice or drop without keeping: use del<\/li>\n<\/ul>\n\n\n\n\n
      Frequently asked questions<\/h2>\n\n\n
      \n
      \n
      \n
      What does python list pop return?<\/h3>\n
      \n\n
      pop removes the item at the given index and returns that item. The default index is minus one, so pop with no argument returns the last item. The list is mutated and the return lets you keep the removed value without a second lookup.<\/p>\n\n<\/div>\n<\/div>\n
      \n
      What happens if you pop from an empty list?<\/h3>\n
      \n\n
      Python raises IndexError with the message pop from empty list. Guard with if your_list before the call or catch IndexError and handle the empty case. Both patterns ran in this guide and the error output appears in the terminal screenshot.<\/p>\n\n<\/div>\n<\/div>\n
      \n
      How is pop different from remove and del?<\/h3>\n
      \n\n
      pop needs an index and returns the removed item while remove needs a value and returns None. del takes an index or slice and returns nothing, so choose pop when you need the value back.<\/p>\n\n<\/div>\n<\/div>\n
      \n
      Can you pop with a negative index?<\/h3>\n
      \n\n
      Yes. Negative indices count from the end, so pop minus one removes the last item and pop minus two removes the second last. An index that is too negative raises IndexError with pop index out of range.<\/p>\n\n<\/div>\n<\/div>\n
      \n
      Is popping in a loop safe?<\/h3>\n
      \n\n
      Popping while looping forward over the same list skips elements because the list shifts. Use a while loop that drains the list or iterate over a shallow copy like for x in orig colon and pop from the original only when needed.<\/p>\n\n<\/div>\n<\/div>\n<\/div>\n<\/div>","protected":false},"excerpt":{"rendered":"
      You call pop expecting a quick delete and instead the interpreter hands you the item it just removed. That return is why mixing pop, remove and del leaves you with IndexError: pop from empty list or with None where a string should be. I ran every form of python list pop on Python 3.11.16, captured […]<\/p>\n","protected":false},"author":7,"featured_media":67727,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-3961","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-list"],"_links":{"self":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/3961","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/comments?post=3961"}],"version-history":[{"count":0,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/posts\/3961\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media\/67727"}],"wp:attachment":[{"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/media?parent=3961"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/categories?post=3961"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.askpython.com\/wp-json\/wp\/v2\/tags?post=3961"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}