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

What are the key differences between using list() and []?

The most obvious and visible key difference between list() and [] is the syntax. Putting the syntax aside for a minute here, someone whose new or intermediately exposed to python might argue that they’re both lists or derive from the same class; that is true. Which furthermore increases the importance of understanding the key differences of both, most of which are outlined below.

list() is a function and [] is literal syntax.

Let’s take a look at what happens when we call list() and [] respectively through the disassembler.

>>> import dis
>>> print(dis.dis(lambda: list()))
  1           0 LOAD_GLOBAL              0 (list)
              3 CALL_FUNCTION            0 (0 positional, 0 keyword pair)
              6 RETURN_VALUE
None
>>> print(dis.dis(lambda: []))
  1           0 BUILD_LIST               0
              3 RETURN_VALUE
None

The output from the disassembler above shows that the literal syntax version doesn’t require a global lookup, denoted by the op code LOAD_GLOBAL or a function call, denoted by the op code CALL_FUNCTION.

As a result, literal syntax is faster than it’s counterpart. – Let’s take a second and look at the timings below.

import timeit
>>> timeit.timeit('[]', number=10**4)
0.0014592369552701712
>>> timeit.timeit('list()', number=10**4)
0.0033833282068371773

On another note it’s equally important and worth pointing out that literal syntax, [] does not unpack values. An example of unpacking is shown below.

>>> list('abc') # unpacks value
['a', 'b', 'c']
>>> ['abc'] # value remains packed
['abc']

What’s a literal in python?

Literals are notations or a way of writing constant or raw variable values which python recognises as built-in types.

Sourced from my post on PythonRight - what's the difference between list and [].

Answer 5

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 6

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.

Answer 7

Since :

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """

If the element in your lists is an iterable (i.e. a str), the list() and [] don't work the same way.

So

>>> a = ['ab']
>>> b = list('ab')
>>> a[0]
'ab'
>>> b[0]
'a'