How flattening a nested list using `sum(iterable,[])` works? [duplicate]

Answer 1

The start argument gives the function the starting point. It's what is being added to. So sum([1,2,3]) returns 6 and sum([1,2,3],5) returns 11. In your case, because you're passing in an 2-d list and an empty list, the function is going to add everything in the first argument to the second argument. Essentially, you're doing this:

[]+[1,2]+[3,4]+[5,6]

It's a bit of a quirk of python's operator overloading.

Answer 2

This is just a result of how Python interprets addition of lists. From the docs

sum(iterable[, start])

Sums start and the items of an iterable from left to right and returns the total.

Since sum starts by adding the first element of the iterable to the start argument, you have:

[] + [1, 2] = [1, 2]

Then it continues adding items from the iterable:

[1, 2] + [3, 4] = [1, 2, 3, 4]
[1, 2, 3, 4] + [5, 6] = [1, 2, 3, 4, 5, 6]

Answer 3

As the sum(iterable[, start]) document says:

Sums start and the items of an iterable from left to right and returns the total. start defaults to 0. The iterable’s items are normally numbers, and the start value is not allowed to be a string.

So, in the example you shared:

sum(a,[])

Here, iterable is a (which is [[1, 2], [3, 4], [5, 6]]) and start is []. Hence, the resultant is equivalent to:

[] + [1, 2] + [3, 4] + [5, 6]

# i.e. you flatten list --> [1, 2, 3, 4, 5, 6] 

Answer 4

sum([a, b, c], d) produces d + a + b + c.

In your example, a, b, c, and d are [1, 2], [3, 4], [5, 6], and [].

sum([[1, 2], [3, 4], [5, 6]], []) produces [] + [1, 2] + [3, 4] + [5, 6], which is [1, 2, 3, 4, 5, 6] because + is concatenation for lists.

This is absurdly inefficient, because every + operation involved requires copying all the data from each of its arguments:

In [7]: x = [[i] for i in range(30000)]

In [8]: %timeit sum(x, [])
1 loop, best of 3: 2.06 s per loop

In [9]: %timeit [elem for sublist in x for elem in sublist]
1000 loops, best of 3: 1.91 ms per loop

sum(x, []) takes quadratic time, whereas a more efficient implementation takes linear time. Never do sum(x, []).