Creating a list in Python- something sneaky going on?

Question

Apologies if this doesn't make any sense, I'm very new to Python!

From testing in an interpreter, I can see that list() and [] both produce an empty list:

>>> list()
[]
>>> []
[]

From what I've learned so far, the only way to create an object is to call its constructor (__init__), but I don't see this happening when I just type []. So by executing [], is Python then mapping that to a call to list()?

Answer 1

Those two constructs are handled quite differently:

>>> import dis
>>> def f(): return []
... 
>>> dis.dis(f)
  1           0 BUILD_LIST               0
              3 RETURN_VALUE        
>>> def f(): return list()
... 
>>> dis.dis(f)
  1           0 LOAD_GLOBAL              0 (list)
              3 CALL_FUNCTION            0
              6 RETURN_VALUE        
>>> 

The [] form constructs a list using the opcode BUILD_LIST, whereas the list() form calls the list object's constructor.

Answer 2

No, Python does not call list(), or you could affect what type [] creates by assigning to list, which you cant:

>>> import __builtin__
>>> __builtin__.list = set
>>> list()
set([])
>>> []
[]

[] is syntax for creating a list. It's a builtin type and it has special syntax, just like dicts and strings and ints and floats and lots of other types.

Creating instances of types can also be done by calling the type, like list() -- which will in turn call the type's constructor and initializer for you. Calling the initializer (__init__) directly does not create a new instance of the type. Calling the constructor (__new__) does, but you should not be calling it directly.

Answer 3

I started learning python yesterday.... I guess you would have to say its internally mapped

>>> a = []
>>> type(a)
<type 'list'>
>>> a = list()
>>> type(a)
<type 'list'>

Answer 4

In addition to the other answers, from the Language Reference:

A list display is a possibly empty series of expressions enclosed in square brackets:

list_display        ::=  "[" [expression_list | list_comprehension] "]"
...

A list display yields a new list object.

It does not explicitly mention how "yielding a new list object" is implemented. It could well be a call to the list() constructor, like you mentioned. Or maybe lists, being so elementary, get special treatment, and list() is actually mapped to something different entirely.

Either way, [] is certainly not mapped to a call to the constructor of the type named __builtins__.list, because redefining that type still causes [] to return an actual list, as other answerers have shown.

Answer 5

Python, like most programming langauges, has something called literals, meaning that special syntax can be used to write out some of the most important types of values. Very little of this is necessary, but it makes it easier to use Python that we can write literals.

>>> 0
0
>>> int()
0
>>> 5
5
>>> int('5') # I'm using a string literal here though!
5
>>> 0.0
0.0
>>> float()
0.0
>>> "" 
''
>>> str()
''
>>> u""
u''
>>> unicode()
u''
>>> ()
()
>>> tuple()
()
>>> {}
{}
>>> dict()
{}     

When we make our own types (classes), we create instances of them using their constructors, like list for lists. When we use literals, it's sort of like syntactic sugar for calling list, but in reality it calls that same basic things behind the scene.