Initializing empty Python data structures

Question

Is there any tangible difference between the two forms of syntax available for creating empty Python lists/dictionaries, i.e.

l = list()
l = []

and:

d = dict()
d = {}

I'm wondering if using one is preferable over the other.

• jamylak: [] and {} are faster and look better in my opinion.

Answer 1

The function form calls the constructor at runtime to return a new instance, whereas the literal form causes the compiler to "create" it (really, to emit bytecode that results in a new object) at compile time. The former can be useful if (for some reason) the classes have been locally rebound to different types.

>>> def f():
... []
... list()
... {}
... dict()
... 
>>> dis.dis(f)
 2 0 BUILD_LIST 0
 3 POP_TOP 
 3 4 LOAD_GLOBAL 0 (list)
 7 CALL_FUNCTION 0
 10 POP_TOP 
 4 11 BUILD_MAP 0
 14 POP_TOP 
 5 15 LOAD_GLOBAL 1 (dict)
 18 CALL_FUNCTION 0
 21 POP_TOP 
 22 LOAD_CONST 0 (None)
 25 RETURN_VALUE 

• robru: A fun side effect of this is that if you're writing a small function that needs to cache some data between calls (perhaps a simple memoizer), you can say def f(a, b, cache={}): and the dict created will actually persist between calls to f()
• Sven Marnach: @Robru: This is unrelated. Using def f(a, b, cache=dict()) also works.
• martineau: FWIW, for non-empty instances, the function form may be more flexible because it may support multiple ways of specifying the object's contents, such as is the case with dict.
• nutty about natty: How should I understand the output of dis.dis?

Answer 2

The main difference is that one form includes a name lookup, while the other doesn't. Example illustrating this difference:

def list():
 return {}
print []
print list()

prints

[]
{}

Of course you definitely should not be doing such nonsense.

Answer 3

My gut tells me that both are acceptable, so long as you're consistent.

Answer 4

I am not aware of any difference, would be mostly a stylistic preference.