python list remove last element time complexity

Most efficient way to remove last element of list?

stackoverflow.com › questions › 56419072 › most-efficient-way-to-remove-last-element-of-list

As per mentioned in the Python wiki. Time complexities are as follows:

Pop last O(1)
Delete Item O(n)
Set Slice O(k+n)

Experimental Study

import time

all_t = 0.
for i in range(1000):
    list_ = [i for i in range(100000)]
    start_ = time.time()
    list_.pop()
    all_t += time.time() - start_
print("Average Time for POP is {}".format(all_t/1000.))

all_t = 0.
for i in range(1000):
    list_ = [i for i in range(100000)]
    start_ = time.time()
    del list_[-1]
    all_t += time.time() - start_
print("Average Time for DEL is {}".format(all_t/1000.))

all_t = 0.
for i in range(1000):
    list_ = [i for i in range(100000)]
    start_ = time.time()
    list_ = list_[:-1]
    all_t += time.time() - start_
print("Average Time for SLICE is {}".format(all_t/1000.))

Results

Average Time for POP is 7.793903350830078e-07
Average Time for DEL is 9.80854034423828e-07
Average Time for SLICE is 0.0006206443309783935

Summary

pop() is the fastest when you do not specify an index.

Answer from Yahya on Stack Overflow

Stack Overflow

stackoverflow.com › questions › 56419072 › most-efficient-way-to-remove-last-element-of-list

python - Most efficient way to remove last element of list? - Stack Overflow

Top answer

1 of 1

As per mentioned in the Python wiki. Time complexities are as follows:

Pop last O(1)
Delete Item O(n)
Set Slice O(k+n)

Experimental Study

import time

all_t = 0.
for i in range(1000):
    list_ = [i for i in range(100000)]
    start_ = time.time()
    list_.pop()
    all_t += time.time() - start_
print("Average Time for POP is {}".format(all_t/1000.))

all_t = 0.
for i in range(1000):
    list_ = [i for i in range(100000)]
    start_ = time.time()
    del list_[-1]
    all_t += time.time() - start_
print("Average Time for DEL is {}".format(all_t/1000.))

all_t = 0.
for i in range(1000):
    list_ = [i for i in range(100000)]
    start_ = time.time()
    list_ = list_[:-1]
    all_t += time.time() - start_
print("Average Time for SLICE is {}".format(all_t/1000.))

Results

Average Time for POP is 7.793903350830078e-07
Average Time for DEL is 9.80854034423828e-07
Average Time for SLICE is 0.0006206443309783935

Summary

pop() is the fastest when you do not specify an index.

algorithm - Remove last matching value from a list in Python

python - Remove the last N elements of a list

removing element from a list in python

remove element by value in list Python fastest

Deleting elements from list or recreating new list (python)

More results from stackoverflow.com

GeeksforGeeks

geeksforgeeks.org › python › python-remove-rear-element-from-list

Python - Remove rear element from list - GeeksforGeeks

April 6, 2023 - Time complexity: O(1) - The pop() method takes constant time to remove the last element from the list. Auxiliary space: O(1) - No extra space is used in this code. Method #2: Using del list[-1] This is just the alternate method to perform the ...

Medium

thinklikeacto.medium.com › time-complexity-of-popping-elements-from-list-in-python-215ad3d9c048

Time complexity of popping elements from list in Python! | by Naresh Thakur | Medium

January 23, 2020 - Does it care about the time complexity? Consider we have following list. ... By doing a.pop() with no arguments it will remove and return the last element which has O(1) time complexity.

reddit.com › r/learnpython › why does remove() work slower for last elements of a list than for the first element?

r/learnpython on Reddit: Why does remove() work slower for last elements of a list than for the first element?

March 11, 2024 -

So I was performing an experiment on the execution speed of the remove function on different list lengths and on three different positions of the list.

plot of running times

Green, blue and red plots denote the running times of the operation for the last element, middle element and the first element respectively.

Since remove works by shifting the subsequent elements to the left, I'd assume it'd take more time for remove to execute on the first element, k = 0, as the element shifting would be expensive. Then why is removing the last element more time consuming, by a large margin?

Top answer

1 of 4

The remove method must search the list for the index of the element to remove. It does this probably by iterating from the beginning. This part is much more expensive than the actual removal. If you want to benchmark the actual removal use the pop method instead, which takes an index to remove and not the element to remove.

2 of 4

So, the reason for this is how remove() works. If you run your test with del instead and go by index, you'll get the opposite result, with last element being removed faster than first element. Why? The remove() function is actually quite simple, and you could recreate it with the following code (not actual code since the underlying implementation is in C, but works the same core way): lst = range(100) size = len(lst) target = 5 for i in range(size): if lst[i] == target: del[i] return raise ValueError In other words, remove() works by going through each element one by one from beginning to end and then deleting the value at the first index that has a match, and raises a ValueError if nothing is found. Given that information, the reason why the last elements are slower than earlier elements should be quite obvious...the sooner the match is found in the loop, the faster it deletes it and breaks out of the loop. Elements at the very end of the list mean you have to look through all the initial elements first, and it's all of those equivalency checks that actually takes the time. If you change your program to use del and go by index, you'll find that deleting lst[-1] is faster than deleting lst[0]. In both cases the middle deletion and removal are in the middle, again for hopefully obvious reasons. Hopefully that makes sense!

reddit.com › r/learnpython › why is removing elements from a list so slow, and is there a faster way?

r/learnpython on Reddit: Why is removing elements from a list so slow, and is there a faster way?

April 21, 2024 -

I was trying to write a simple application, which is ao supposed to filter a list of words down to a list of words of a certain length. For that I could either remove the words of the wrong length, or create a new list of words with the correct length.

I had a list of around 58000 words, and wanted to filter out all the 6 letter words, which are around 6900.

with open('words.txt') as f:
    words = f.readlines()
    for i in range(len(words)):
        words[i] = words[i].strip()

length = int(input("Desired word length "))

for i in reversed(words):
    if len(i) != length:
        words.remove(i)

This took 22 seconds.

Another way is to just create a new list with words of the correct length. I did this as follows:

with open('words.txt') as f:
    words = f.readlines()
    for i in range(len(words)):
        words[i] = words[i].strip()

length = int(input("Desired word length "))
clw = []

for i in words:
    if len(i) == length:
        clw.append(i)

This only took 0.03 seconds. How can it be that creating a list of 6900 words takes 0.03 seconds, but removing 51100 words takes 22? It's only 7 times as many words, but takes 700 times as long. And is there a better and faster way to quickly remove list elements?

Top answer

1 of 9

Each time you remove an element from the list, the elements "shift down" in position. This takes time, as you are essentially recreating (large portions of) the list after each removal. When you create a new list, you build it once. A more Pythonic way to do this is to use a list comprehension. clw = [word for word in words if len(word) == length]

2 of 9

Other comments explain why the remove approach isn't efficient. I also want to note that right now, you're reading through the words three times: once with readlines, once with your for loop that strips words, and once with your for loop that filters them. Instead, you can just get the words you need as you read the file for the first time. length = int(input("Desired word length: ")) words = [] with open("words.txt", "r") as f for line in f: word = line.strip() if len(word) == length: words.append(word) Another note, if words.txt has duplicates, so will your list. You could use a set instead to avoid this if that's undesirable.

LabEx

labex.io › tutorials › python-what-is-the-time-complexity-of-list-append-and-remove-operations-in-python-397728

What is the time complexity of list append and remove operations in Python | LabEx

The linear time complexity of the list.remove() operation means that it may not be the most efficient way to remove elements from a list, especially when dealing with large datasets. In such cases, it may be more efficient to use a different data structure, such as a set or a deque, which can provide more efficient removal operations. By the end of this tutorial, you will have a deep understanding of the time complexity of list append and remove operations in Python.

PyTutorial

pytutorial.com › python-list-remove-last-element

PyTutorial | Python List Remove Last Element

May 23, 2026 - All three methods have O(1) time complexity for removing the last element. Python lists are dynamic arrays.

Finxter

blog.finxter.com › home › learn python blog › what is the difference between remove(), pop() and del in lists in python?

What is The Difference Between remove(), pop() and del in Lists in Python? - Be on the Right Side of Change

December 17, 2021 - ... Note that the deleted value is returned when you call the pop() method. Example 2: Let us say, we pass a value to the pop() method, the element located in that index will be deleted.

linkedin.com › all › engineering › computer science

How can you remove an element from a Python list?

March 4, 2024 - The pop() method is not only useful for removing elements but also for implementing stacks in Python, where it represents the 'pop' operation in a Last In, First Out (LIFO) data structure. It's important to note that pop() modifies the list in place and can cause IndexError if you pop from an empty list or with an invalid index. Additionally, when considering performance, pop() is efficient as it runs in constant time, O(1), for the last element but can be O(n) for specific indices due to the need to shift the remaining elements.

Find elsewhere

Google Bing Mojeek

PyTutorial

pytutorial.com › python-list-remove-time-complexity

PyTutorial | Python List Remove Time Complexity

May 23, 2026 - If you need to remove many elements, always prefer a linear-time solution over a quadratic one. The list.remove() method has a time complexity of O(n) due to searching and shifting. This is acceptable for small lists but can be slow for large ones.

Stack Overflow

stackoverflow.com › questions › 41092759 › python-2-7-set-and-list-remove-time-complexity

python 2.7 set and list remove time complexity - Stack Overflow

Top answer

1 of 1

From the docs:

list.remove(x) Remove the first item from the list whose value is x. It is an error if there is no such item.

Without going into the details of the implementation, the item to remove can be anywhere in the list. A linear scan time is necessary in order to find the item before it can be removed. Once you find the index of the item to remove, you need to shift all the elements down by one index. In any case there's index amount of traversal and size - index amount of shifting involved. Therefore the removal time is equivalent to traversing the entire list: O(n).

You can find the source here: https://hg.python.org/cpython/file/tip/Objects/listobject.c#l2197 (also look for list_ass_slice(..)).

However, a set is different. It uses the hash value of the object being stored to locate it in its buckets. On an average, locating of objects using hash value is almost constant time. Note that it might not always be constant time where there's hash collision and a further search is required. But assuming a good hash function, it usually is.

UPDATE: I must thank Stefan Pochmann for pointing out the mistake.

Stack Overflow

stackoverflow.com › questions › 195625 › what-is-the-time-complexity-of-popping-elements-from-list-in-python › 46136638

What is the time complexity of popping elements from list in Python? - Stack Overflow

Top answer

1 of 4

Yes, it is O(1) to pop the last element of a Python list, and O(N) to pop an arbitrary element (since the whole rest of the list has to be shifted).

Here's a great article on how Python lists are stored and manipulated: An Introduction to Python Lists.

2 of 4

Pop() for the last element ought to be O(1) since you only need to return the element referred to by the last element in the array and update the index of the last element. I would expect pop() for an arbitrary element to be O(N) and require on average N/2 operations since you would need to move any elements beyond the element you are removing one position up in the array of pointers.

reddit.com › r/learnprogramming › why is it that removing an element from the start of an array o(n) while at the end o(1)?

r/learnprogramming on Reddit: Why is it that removing an element from the start of an array O(n) while at the end O(1)?

September 16, 2023 -

From my understanding the reason why removing the last element is O(1) is because you don't need to shift the array in memory. You simply remove the last element and leave the old space empty. So why is it that if you remove the first element that the Array HAS to to shift in memory (making it O(n))?

I don't understand the reasoning, if we are okay with leaving empty space in memory at the end of an array and not shifting all the other things surrounding the array in memory. Then why do we have to shift the array in memory if there is space that the start?

I am not understanding, if it's because the memory is trying to stay compact and no empty spaces are allowed. Then why don't all the other stuff in memory be shifted to the left after new space was cleared once we removed the last element from the array?

Top answer

1 of 5

There's no reason why you can't apply the optimization you suggest. That's implemented in some languages as a deque (double-ended queue). This has other drawbacks and benefits over regular arrays. In C, empty space is problematic since arrays are passed around as pointers to the first element. If you leave empty space at the start of the array, all of the existing pointers would still point to the original start.

2 of 5

If you're resizing an array by removing any element then it's o(n). If you want to set one to null it's o(1). Maybe you're confusing arrays with lists but even then it's backwards. Removing the first list element is o(1) and the last is o(n)

Stack Overflow

stackoverflow.com › questions › 41269044 › how-to-delete-an-element-in-python-list-in-o1-time › 41269274

algorithm - How to delete an element in python list, in O(1) time - Stack Overflow

Top answer

1 of 1

Actually, you don't have to swap; just copy the end element to the desired deletion position -- don't bother with the converse assignment -- and pop the last (now redundant) element. For removing element n,

my_list[n] = my_list.pop()

will do it in one line.

DataCamp

datacamp.com › tutorial › python-pop

How to Use the Python pop() Method | DataCamp

July 31, 2024 - When you use the pop() method without an argument or with -1 as the index to remove the last element, it operates in O(1) time because it only removes the last element in the list without changing the other elements. When we use the pop() method to remove the first or any other element, it ...

GeeksforGeeks

geeksforgeeks.org › python › python-front-and-rear-range-deletion-in-a-list

Python | Front and rear range deletion in a list - GeeksforGeeks

July 11, 2025 - Time complexity: O(n), where n is the length of the list, because we need to traverse the list twice, once for removing the first two elements and once for removing the last two elements Auxiliary space: O(1), because we are modifying the original ...

GeeksforGeeks

geeksforgeeks.org › python › python-remove-given-element-from-the-list

Python | Remove given element from the list - GeeksforGeeks

July 11, 2025 - Time Complexity: O(n) where n is the elements in the list Auxiliary Space: O(n), where n is the length of the list · Since the list is converted to set, all duplicates are removed, but the ordering of the list cannot be preserved.

LabEx

labex.io › tutorials › python-how-to-efficiently-remove-elements-from-the-left-side-of-a-python-list-397985

How to efficiently remove elements from the left side of a Python list | LabEx

The del statement and slicing with a step size of 1 have a time complexity of O(k), where k is the number of elements removed. For large lists or frequent left-side removals, using the del statement or slicing with a step size of 1 can be more ...

FavTutor

favtutor.com › blogs › remove-last-element-from-list-python

Remove Last Element from List in Python | FavTutor

October 12, 2023 - To delete the last element, we can use the negative index -1. The use of the negative index allows us to delete the last element, even without calculating the length of the list. This decreases the complexity of the program significantly.