Appending item to lists within a list comprehension

list.append mutates the list itself and returns None. List comprehensions are for storing the result, which isn't what you want in this case if you want to just change the original lists.

>>> x = [[1, 2], [3, 4], [5, 6]]
>>> for sublist in x:
...     sublist.append('a')
...
>>> x
[[1, 2, 'a'], [3, 4, 'a'], [5, 6, 'a']]

As others have said, append mutates the list itself and you shouldn't assign it to a variable. Executing it changes it's data, effectively updating everyone pointing at it.

But, there's a trick I use when I want to do stuff in a functional* way while mutating existing objects (rather than constructing new ones, in this case using a=[x + ['a'] for x in a], or specifically the x + ['a']).

So, if you're brave enough you can also do this:

>>> a=[[1,2],[3,4],[5,6]]
>>> a=[x.append('a') or x for x in a]
>>> a
[[1, 2, 'a'], [3, 4, 'a'], [5, 6, 'a']]

This works because append returns None, and the or continues on to search for a truth-y value, which x is (it's a list with at least what was appended to it).

Why do I even need this?

Say you have a list and you want to insert some of it's members to a new list, and update the references accordingly:

So you have the list all:

>>> all = [[], [], [], []]

Some of it is inserted and updated to a new list x:

>>> x = [i.append('x') or i for i in all[:2]]
>>> x
[['x'], ['x']]

Some of all is also inserted and updated to a list y:

>>> y = [i.append('y') or i for i in all[1:3]]

all is updated:

>>> all
[['x'], ['x', 'y'], ['y'], []]

But x is also updated:

>>> x
[['x'], ['x', 'y']]

And y is generated as expected:

>>> y
[['x', 'y'], ['y']]

Overall, for simple tasks, I'd recommend using a for loop updating explicitly. This is what's considered pythonic.

Technically speaking, if you had access to the list class, you could make this a function:

def more_functional_append(self, x):
    self.append(x)
    return self

• functional programming is based on every statement doing essentially one thing, and not having side effects (so, not mutating and returning). append is not very functional since it mutates a list (pure functional programming has only immutable objects) and does not return a result to pass to other actions (functions). Using functional programming concepts you can create great big one-liners no one can read, also known as "job security" or "bad code".

For the first case, the reason it returns [None, None, None] is because the list.append function returns None, and that's what it stores in the list.

In the second case, it's because the list is mutable, and each time you append the value, the original list is modified.

What you need is a non-in-place append operator, such as +. i.e. [x + ['a'] for x in a].