Getting a slice is O(i_2 - i_1). This is because Python's internal representation of a list is an array, so you can start at i_1 and iterate to i_2.
For more information, see the Python Time Complexity wiki entry
You can also look at the implementation in the CPython source if you want to.
Answer from Sam Mussmann on Stack OverflowReddit
reddit.com โบ r/learnpython โบ what is the time complexity of slicing a list?
r/learnpython on Reddit: What is the time complexity of slicing a list?
January 4, 2021 -
I think it's O(1) but some sources online say O(n)
Top answer 1 of 4
6
O(n) where n is the length of the slice. Slicing is just "copy part of the list" so time complexity is the same as copy.
2 of 4
1
Different implementations can vary, but the CPython time complexities are all listed here: https://wiki.python.org/moin/TimeComplexity
[Python] Why does my program run faster when list slicing compared to normal list indexing? Sep 15, 2016
r/learnprogramming 10y ago
Does slicing in startswith and endswith make the time complexity O(n3), or is it O(n2) since nested loops dominate the operations? Jan 9, 2025
r/learnpython last yr.
If time complexity of pop (first item) is O(n) and the time complexity for a set slice is O(k), why is my slicing function so slow? Jan 12, 2025
r/learnpython last yr.
Top answer 1 of 4
68
Getting a slice is O(i_2 - i_1). This is because Python's internal representation of a list is an array, so you can start at i_1 and iterate to i_2.
For more information, see the Python Time Complexity wiki entry
You can also look at the implementation in the CPython source if you want to.
2 of 4
44
according to http://wiki.python.org/moin/TimeComplexity
it is O(k) where k is the slice size
04:21
Slicing a List in Python | Python Tutorial | Python Full Course ...
06:37
List Slicing in Python EXPLAINED - YouTube
03:30
python list slicing time complexity - YouTube
21:08
Python Lists for Beginners incl. List Slicing | Python Course #8 ...
02:02
What is list slicing in Python? - YouTube
08:55
How To Slice A List In Python 3 - YouTube
FavTutor
favtutor.com โบ blogs โบ python-list-slicing
Python List Slicing (with Examples)
September 23, 2024 - List slicing in Python has a time complexity of O(k), where k is the number of elements in the slice.
Coding Blocks
discuss.codingblocks.com โบ t โบ time-complexity-of-python-slice-operation โบ 99497
Time complexity of python slice operation - ๐ก-string-window - Coding Blocks Discussion Forum
August 1, 2020 - what is the time complexity of slicing in python. Example: lis[2:] I wrote a program in leetcode with lis slicing and without lis slicing and still got the same time result.
Reddit
reddit.com โบ r/learnpython โบ list-slicing
r/learnpython on Reddit: List-Slicing
October 3, 2017 -
What is meant by the assumption that "list-slicing takes constant-time"?
Top answer 1 of 4
4
It means the time it takes for something to happen doesn't depend on the size of the input. It deals with the subject of Time Complexity. As far as Python is concerned, list-slicing doesn't take constant time, it's bounded by a some kind of factor depending on the slice operation. You can refer to this page which documents the time complexity for common operations. Anything with O(1) is something that's completed in constant time. The time complexity for get, set, and del slice operations are affected by either n, k, or some combination of those two. The page itself explains what those variables mean more concisely than I can, so refer to the introduction section for more information on those.
2 of 4
2
Lists are just a set of references to items they hold. Much like a phone book, a contacts list or an ingredient list for a recipe. If you duplicate or slice the list in Python, you're just creating a new copy of the set of references, the list items themselves aren't handled. This means that the amount of work needed to perform the slice is that little (as it's just administrative), it will take practically the same amount of very little time, regardless of the list and slice sizes.
CodeRivers
coderivers.org โบ blog โบ list-slicing-time-complexity-python
Understanding List Slicing Time Complexity in Python - CodeRivers
February 22, 2026 - The basic syntax is list[start... between each element in the slice. The time complexity of basic list slicing list[start:stop] (when step is 1) is O(k), where k is the number of elements in the resulting slice....
Leyaa
leyaa.ai โบ codefly โบ learn โบ python โบ part-2 โบ python-list-indexing-and-slicing โบ complexity
List indexing and slicing in Python Time Complexity - Big O Analysis | Leyaa.ai
Getting one item by index takes the same time no matter how big the list is. Getting a slice takes time proportional to how many items are in the slice.
GeeksforGeeks
geeksforgeeks.org โบ python โบ python-alternate-range-slicing-in-list
Python | Alternate range slicing in list - GeeksforGeeks
April 18, 2023 - The original list : [2, 4, 6, 8, 9, 10, 12, 16, 18, 20, 7, 30] The alternate range sliced list : [8, 9, 10, 20, 7, 30] Time complexity: O(n), where n is the length of the list, as the list comprehension and the enumerate() function both have ...
Python
wiki.python.org โบ moin โบ TimeComplexity
TimeComplexity - Python Wiki
[2] = Popping the intermediate ... 1 moves. The average case for an average value of k is popping the element the middle of the list, which takes O(n/2) = O(n) operations....
Medium
medium.com โบ @dfashimpaur โบ writing-algorithms-in-python-d852d70759dc
The Power of List Slicing: Writing Better Algorithms In Python
November 10, 2025 - Concatenation (+) of the two slices is also O(N), because it creates a new list ยท This leaves a total time cost for the slicing approach is O(N) with respect to the input size. This is the best possible Time Complexity for a full-array rotation ...
Quora
quora.com โบ What-are-the-time-complexity-considerations-of-lists-in-Python
What are the time complexity considerations of lists in Python? - Quora
Answer: In a normal list on average: * Append : O(1) * Extend : O(k) - k is the length of the extension * Index : O(1) * Slice : O(k) * Sort : O(n log n) - n is the length of the list * Len : O(1) * Pop : O(1) - pop from end * Insert : O(n) - n is the length of the list * Del : O(n) - n...
Bradfield CS
bradfieldcs.com โบ algos โบ analysis โบ performance-of-python-types
Performance of Python Types
Slice operations require more thought. To access the slice [a:b] of a list, we must iterate over every element between indices a and b. So, slice access is ... O(n)O(n) since we must reposition each element. Finally (and least intuitively), sorting in Python is
Medium
medium.com โบ @ivanmarkeyev โบ understanding-python-list-operations-a-big-o-complexity-guide-49be9c00afb4
Understanding Python List Operations: A Big O Complexity Guide | by Ivan Markeev | Medium
June 4, 2023 - When inserting or deleting an element at the beginning or middle of a Python list, the remaining elements must be shifted to accommodate the change. As a result, these operations have a linear time complexity of O(n).
Python Reference
python-reference.readthedocs.io โบ en โบ latest โบ docs โบ brackets โบ slicing.html
[] (slicing) โ Python Reference (The Right Way) 0.1 documentation
>>> +---+---+---+---+ >>> |-4 |-3 |-2 |-1 | <= negative indexes >>> +---+---+---+---+ >>> | A | B | C | D | <= sequence elements >>> +---+---+---+---+ >>> | 0 | 1 | 2 | 3 | <= positive indexes >>> +---+---+---+---+ >>> |<- 0:3:1 ->| <= extent of the slice: "ABCD"[0:3:1]
Esaezgil
esaezgil.com โบ home โบ python lists pop vs slice performance
Python lists: pop vs slice performance - Enrique Saez
February 22, 2017 - t1 = timeit.Timer('a=50*[\'a\'];a.pop(0)') t2 = timeit.Timer('b=50*[\'b\'];b[1:]') t1.timeit(10000)/10000 6.973965995712205e-07 t2.timeit(10000)/10000 8.281046990305186e-07
Top answer 1 of 2
11
O(n+k) is the average case, which includes having to grow or shrink the list to adjust for the number of elements inserted to replace the original slice.
Your case, where you replace the slice with an equal number of new elements, the implementation only takes O(k) steps. But given all possible combinations of number of elements inserted and deleted, the average case has to move the n remaining elements in the list up or down.
See the list_ass_slice function for the exact implementation.
2 of 2
3
You're right, if you want to know the exact details it's best to use the source. The CPython implementation of setting a slice is in listobject.c.
If I read it correctly, it will...
- Count how many new elements you're inserting (or deleting!)
- Shift the n existing elements of the list over enough places to make room for the new elements, taking O(n) time in the worst case (when every element of the list has to be shifted).
- Copy over the new elements into the space that was just created, taking O(k) time.
That adds up to O(n+k).
Of course, your case is probably not that worst case: you're changing the last k elements of the list, so there might be no need for shifting at all, reducing the complexity to O(k) you expected. However, that is not true in general.
Stack Overflow
stackoverflow.com โบ questions โบ 75424380 โบ time-and-space-complexity-of-python-list-slicing-inside-recursive-calls
algorithm - Time and Space Complexity of Python list-slicing inside recursive calls - Stack Overflow
... Yes s[1:] is O(n). So it is O(n + n-1 + n-2 + ... + 2 + 1) = O(nยฒ) ... Save this answer. ... Show activity on this post. Yes, you are right. The space complexity is O(๐ยฒ) because each slice allocates a new string.
GeeksforGeeks
geeksforgeeks.org โบ python โบ python-sliced-product-in-list
Python | Sliced Product in List - GeeksforGeeks
April 22, 2023 - Time Complexity : O(K) K - length of sliced list ยท Auxiliary Space : O(1) since we used only one variable to store product. Method5: Using Recursive method: The idea to use the recursive method is based on the following two conditions: If K ...
Reddit
reddit.com โบ r/leetcode โบ time and space complexity of python list-slicing inside recursive calls
r/leetcode on Reddit: Time and Space complexity of Python list-slicing inside recursive calls
February 12, 2023 -
LeetCode 344
Consider the Python code attached that reverses a string recursively.
My thinking is that the list-slicing takes O(n-1) for both time and space in each of the O(n) recursive calls. Hence, both time and space complexities are O(n2) (the quadratic space complexity dominates the linear recursive space needed).
Is this correct?
Top answer 1 of 3
2
did you mean to write len(s) <= 1?
2 of 3
1
In terms of space, yes, because a pyramid of partial strings is stored due to the function calls. In terms of time, it depends. A smart python interpreter could potentially append a single character to a string re-allocating in place without copying. In that case, it would be O(1) amortized for each call and O(N) total, as with appending to a list. There has been some optimization in CPython along these lines but I am not sure if this exact case benefits from it.
Pythoncomplexity
pythoncomplexity.com โบ builtins โบ slice
Slice - Python Big-O: Time & Space Complexity
# Creating slice objects is cheap - O(1) slices = [slice(i, i+10) for i in range(100)] # O(100) # Applying slices is costly - depends on slice size lst = list(range(1000)) # Creating all results - O(100 * 10) = O(1000) results = [lst[s] for s in slices] # More efficient: use indices() and iterate results = [] for s in slices: start, stop, step = s.indices(len(lst)) results.append(lst[start:stop:step]) # Same complexity but clearer