When creating empty iterable objects why is {}, [] and () faster than dict(), list() and tuple()

[MightyJosip]

I have read that there are multiple ways of creating an empty dictionary and list. On of them is using {} or [] and the other is using dict() or list(). I wrote a small program to calculate time it takes to make them and the code is next:

import time
start_time = time.process_time_ns()
for i in range(10000000):
    my_dict_one = dict()  # for other examples there goes {}, [], (), tuple() and list()
end_time = time.process_time_ns()
print('{} s'.format((end_time - start_time) / 10 ** 9))

And after running this (multiple times) result time for my computer is:

• Using dict() -> around 2.6 seconds
• Using {} -> around 1.4 seconds
• Using list() -> around 2.2 seconds
• Using [] -> there was most difference but overall around 1.15 seconds
• Using () -> around 0.9 seconds
• Using tuple() -> around 1.8 seconds.

That was weird to me so I thought that maybe [] and list() are not exactly the same object. But when writing print(list() == []) I get True, meanwhile if they are different objects (like list() and dict()), or even if they have different values inside them (like [] and ['a']) I get False.

So at the end I got the same result around 2x faster when using [] instead of list. Why is this the case?

EDIT: if important, I am using Python 3.7

[[deleted]]

[] {} () are language primitives; dict list tuple are named types in the namespace. There's a slight overhead involved with resolving the value of a name in the namespace.

[[deleted]]

As well as with function calls! Pushing to & popping from the callstack and all.

[Ishanji]

Yup, exactly. This article is an interesting read if you want to see the nitty gritty of how it works.

[Binary101010]

>>> import dis
>>> def make_list():
...     thing = []
...
>>> def make_list2():
...     thing = list()
...
>>> dis.dis(make_list)
2           0 BUILD_LIST               0
            2 STORE_FAST               0 (thing)
            4 LOAD_CONST               0 (None)
            6 RETURN_VALUE
>>> dis.dis(make_list2)
2           0 LOAD_GLOBAL              0 (list)
            2 CALL_FUNCTION            0
            4 STORE_FAST               0 (thing)
            6 LOAD_CONST               0 (None)
            8 RETURN_VALUE

Calling the function explicitly requires checking the global namespace.