What is the runtime complexity of python list functions?

Question

I was writing a python function that looked something like this

def foo(some_list):
   for i in range(0, len(some_list)):
       bar(some_list[i], i)

so that it was called with

x = [0, 1, 2, 3, ... ]
foo(x)

I had assumed that index access of lists was O(1), but was surprised to find that for large lists this was significantly slower than I expected.

My question, then, is how are python lists are implemented, and what is the runtime complexity of the following

Indexing: list[x]
Popping from the end: list.pop()
Popping from the beginning: list.pop(0)
Extending the list: list.append(x)

For extra credit, splicing or arbitrary pops.

Asked By: Marquis Wang

||

Source

Answer 1

The answer is “undefined”. The Python language doesn’t define the underlying implementation. Here are some links to a mailing list thread you might be interested in.

It is true that Python’s lists have
been implemented as contiguous
vectors in the C implementations of
Python so far.
I’m not saying that the O()
behaviours of these things should be
kept a secret or anything. But you
need to interpret them in the context
of how Python works generally.

Also, the more Pythonic way of writing your loop would be this:

def foo(some_list):
   for item in some_list:
       bar(item)

Answered By: anthony

Answer 2

if you need index and value then use enumerate:

for idx, item in enumerate(range(10, 100, 10)):
    print idx, item

Answered By: Maxim Kim

Answer 3

there is a very detailed table on python wiki which answers your question.

However, in your particular example you should use enumerate to get an index of an iterable within a loop. like so:

for i, item in enumerate(some_seq):
    bar(item, i)

Answered By: SilentGhost

Answer 4

Lists are indeed O(1) to index – they are implemented as a vector with proportional overallocation, so perform much as you’d expect. The likely reason you were finding this code slower than you expected is the call to “range(0, len(some_list))“.

range() creates a new list of the specified size, so if some_list has 1,000,000 items, you will create a new million item list up front. This behaviour changes in python3 (range is an iterator), to which the python2 equivalent is xrange, or even better for your case, enumerate

Answered By: Brian

Answer 5

Python list actually nothing but arrays. Thus,

indexing takes O(1)

for pop and append again it should be O(1) as per the docs

Check out following link for details:

http://dustycodes.wordpress.com/2012/03/31/pythons-data-structures-complexity-analysis/

Answered By: codersofthedark

What is the runtime complexity of python list functions?

Question:

Answers: