Python: array[x] in O(1) complexity - shall I use Dictionary or List? [duplicate]

I made a little benchmark and got into a conclusion that List works faster.

Here is the benchmark I've made:

Running with list: 198sec user time:

> time python /tmp/python_benchmark.py list
finished_building
198.816u 0.036s 3:18.97 99.9%   0+0k 0+0io 0pf+0w

Running with dictionary: 211sec user time:

> time python /tmp/python_benchmark.py dict
finished_building
211.065u 0.044s 3:31.19 99.9%   0+0k 0+8io 0pf+0w

I've printed the finished building string, to know how much approx. seconds it took to build the data structure, before starting to run the queries. In both times, it took less that 1 second.

This is the content of the benchmark script:

import sys
from random import randrange

NUM_OF_ITEMS = 100000
NUM_OF_ACCESSES = 200000000
data_structure = None

def exit_usage():
    print "Usage: python_benchmark.py <list | dict>"
    sys.exit(1)

def access_data_structure():
    for i in xrange(NUM_OF_ACCESSES):
        rnd_index = randrange(NUM_OF_ITEMS)
        dummy_assignment = data_structure[rnd_index]

if len(sys.argv) != 2:
    exit_usage()

work_type = sys.argv[1]
if work_type != 'list' and work_type != 'dict':
    exit_usage()

if work_type == 'list':
    data_structure = []
else:
    data_structure = {}

if work_type == 'list':
    for i in xrange(NUM_OF_ITEMS):
        data_structure.append(i)
else:
    for i in xrange(NUM_OF_ITEMS):
        data_structure[i] = i

print 'finished_building'

access_data_structure()

There are actually several array data types in Python; list is an array of object references, as is tuple, while bytearray and array.array are numeric arrays with specific types and range checks (more generic ones, including multidimensional, are added by NumPy), and aside from tuple these are all dynamic.

dict is a hash table, which is a more complex data type useful primarily when keys are disorganized but hashable and the mapping is queried many times. Its keys are unordered and may be non-numeric.

What the standard library doesn't have, however, is a linked list type. The collections.deque type exhibits the fast end access of a doubly linked list, though insertions in the middle require memory copies (but not linear scans). There are of course addon modules with linked lists also, such as llist.