What's the difference between dict() and {}?

Question

So let\'s say I wanna make a dictionary. We\'ll call it d. But there are multiple ways to initialize a dictionary in Python! For example, I could do this:

Answer 1

@Jacob: There is a difference in how the objects are allocated, but they are not copy-on-write. Python allocates a fixed-size "free list" where it can quickly allocate dictionary objects (until it fills). Dictionaries allocated via the {} syntax (or a C call to PyDict_New) can come from this free list. When the dictionary is no longer referenced it gets returned to the free list and that memory block can be reused (though the fields are reset first).

This first dictionary gets immediately returned to the free list, and the next will reuse its memory space:

>>> id({})
340160
>>> id({1: 2})
340160

If you keep a reference, the next dictionary will come from the next free slot:

>>> x = {}
>>> id(x)
340160
>>> id({})
340016

But we can delete the reference to that dictionary and free its slot again:

>>> del x
>>> id({})
340160

Since the {} syntax is handled in byte-code it can use this optimization mentioned above. On the other hand dict() is handled like a regular class constructor and Python uses the generic memory allocator, which does not follow an easily predictable pattern like the free list above.

Also, looking at compile.c from Python 2.6, with the {} syntax it seems to pre-size the hashtable based on the number of items it's storing which is known at parse time.

Answer 2

Basically, {} is syntax and is handled on a language and bytecode level. dict() is just another builtin with a more flexible initialization syntax. Note that dict() was only added in the middle of 2.x series.

Answer 3

In order to create an empty set we should use the keyword set before it i.e set() this creates an empty set where as in dicts only the flower brackets can create an empty dict

Lets go with an example

print isinstance({},dict) 
True 
print isinstance({},set) 
False 
print isinstance(set(),set) 
True

Answer 4

As far as performance goes:

>>> from timeit import timeit
>>> timeit("a = {'a': 1, 'b': 2}")
0.424...
>>> timeit("a = dict(a = 1, b = 2)")
0.889...

Answer 5

Update: thanks for the responses. Removed speculation about copy-on-write.

One other difference between {} and dict is that dict always allocates a new dictionary (even if the contents are static) whereas {} doesn't always do so (see mgood's answer for when and why):

def dict1():
    return {'a':'b'}

def dict2():
    return dict(a='b')

print id(dict1()), id(dict1())
print id(dict2()), id(dict2())

produces:

$ ./mumble.py
11642752 11642752
11867168 11867456

I'm not suggesting you try to take advantage of this or not, it depends on the particular situation, just pointing it out. (It's also probably evident from the disassembly if you understand the opcodes).

Answer 6

dict() is used when you want to create a dictionary from an iterable, like :

dict( generator which yields (key,value) pairs )
dict( list of (key,value) pairs )