Star operator (*) applied to lists and integers [duplicate]

Answer 1

The syntax:

list=[any_object]*n

is a short-cut of making a list of n same objects.As you can see the following:

>>> l=[foo()]*3
>>> l
[<__main__.foo instance at 0x02D64D28>, <__main__.foo instance at 0x02D64D28>, <__main__.foo instance at 0x02D64D28>]
>>> m=[ foo() for i in range(3)]
>>> m
[<__main__.foo instance at 0x02D64F08>, <__main__.foo instance at 0x02D613A0>, <__main__.foo instance at 0x02D611C0>]

In the above code the three objects are same in the

list l

as indicated by there memory locations or you can use id(object) but in the

list m

they are different. The point is when you use list comprehensions you actually do the process of creating three objects in one line rather than using a loop to instantiate objects and putting them in a list,but the former list=[any_object]*nis just again a shotcut of appending the same object in a list desired number of times.

Answer 2

It's not syntactic sugar at all, it's just multiplying a list. That is,

foo_list = [Foo()] * 3

is

foo_list = ( [Foo()] ) * 3

is

foo_instance = Foo()
bar_list = [foo_instance]
foo_list = bar_list * 3

No special syntax at all. It creates a list that has the same contents as the list being multiplied, three times.

One thing I use it for is when I get a list of unknown length and I want it to have exactly length n, then I add a list of n times a default value to it, then slice:

def set_to_length(l, n, defaultvalue=0):
    return (l + [defaultvalue] * n)[:n]

Of course doing that with mutable defaultvalues leads to trouble, as you've found.

Answer 3

You can use the star form, with any immutable type, like this

print [5] * 3
print "abc" * 3
print [1.1] * 3
print (8,) * 3

Lets say, for example

nums = [5] * 3
print map(id, nums)

Output on my machine

[41266184, 41266184, 41266184]

id function gives a unique id of the current object. As you can see, creating immutable objects this way is very simple, and efficient. Because all the elements in the created object, point to the same element. (Remember the objects used are immutable)

So, as a rule of thumb,

if the objects are mutable, use list comprehension form

[Foo() for i in range(3)]

if the objects are immutable, use can use the star form

[5] * 3