conditionally append value to list of lists in pandas

I'm trying to conditionally append a list of lists in pandas:

import pandas as pd
df = pd.DataFrame(data={'A': [1, 2, 3]})
df['B'] = [[[1],[1],[1]]] * df.shape[0] 
df

       A                B
    0  1  [[1], [1], [1]]
    1  2  [[1], [1], [1]]
    2  3  [[1], [1], [1]]

# attempting to append 1st list of lists in B column with 2
df['B'] = df['B'].mask(df.A == 2, df['B'].apply(lambda x: x[0].append(2)))
df
       A                         B
    0  1  [[1, 2, 2, 2], [1], [1]]
    1  2                      None
    2  3  [[1, 2, 2, 2], [1], [1]]

#expected result I'm hoping for is: 
df['B'] = [[[1],[1],[1]],[[1,2],[1],[1]],[[1],[1],[1]]]
df

       A                   B
    0  1     [[1], [1], [1]]
    1  2  [[1, 2], [1], [1]]
    2  3     [[1], [1], [1]]

try using a lambda function to conditionally modify the list of lists like this:

import pandas as pd

df = pd.DataFrame(data={'A': [1, 2, 3]})
df['B'] = [[[1],[1],[1]]] * df.shape[0] 

df['B'] = df.apply(lambda row: row['B'] if row['A'] != 2 else [row['B'][0] + [2]] + row['B'][1:], axis=1)

print(df)

here we create a new list of lists that includes the modified list and then return that. apply method is called on the entire DataFrame with axis=1 to apply the lambda function row-wise.

list.append works in place, so it actually returns None instead of a list. This is why your new df has None on the second row.

Below is a way to add 2 to the list. We take the first list in the second row and add [2], then unpack the rest of the lists to form the expected output:

df['B'].mask(df['A'].eq(2),lambda x: x.map(lambda x: [x[0] + [2],*x[1:]]))

Output:

0       [[1], [1], [1]]
1    [[1, 2], [1], [1]]
2       [[1], [1], [1]]

The problem is the way how you generate your data frame:

import pandas as pd
df = pd.DataFrame(data={'A': [1, 2, 3]})
df['B'] = [[[1],[1],[1]]] * df.shape[0] 
df

The [[[1],[1],[1]]] * df.shape[0] is a tricky thing in Python.
Because all [[1],[1],[1]] in the different rows of you df point to the
same object, a list [[1], [1], [1]].

Try this:

df.at[1, 'B'][0] = [1, 2] 

.at[ ] allows you to access using index number and column name at the same time. the [0] chooses the first element of the list returned after access.
So no lambda needed here.

One thinks that only the first element in the second row's 'B' columns' list
[[1], [1], [1]] is changed to [[1, 2], [1], [1]].
but if you look at the entire data frame:

df

it returns:

   A                   B
0  1  [[1, 2], [1], [1]]
1  2  [[1, 2], [1], [1]]
2  3  [[1, 2], [1], [1]]

Because the elements in B point all to the identical object, they all get mutated at once.

That is why you should avoid [ ] * <number> when generating such constructs.

Instead, use e.g. a list comprehension:

import pandas as pd
df = pd.DataFrame(data={'A': [1, 2, 3]})
df['B'] = [[[1],[1],[1]] for _ in range(df.shape[0])] 
df

# and mutate by:
df.at[1, 'B'][0] = [1, 2]

df

   A                   B
0  1     [[1], [1], [1]]
1  2  [[1, 2], [1], [1]]
2  3     [[1], [1], [1]]

Avoid append in your lambda

How about:

import pandas as pd
df = pd.DataFrame(data={'A': [1, 2, 3]})
df['B'] = [[[1],[1],[1]] for _ in range(df.shape[0])] 
df


import copy

def myfun(x):
    l = copy.deepcopy(x)
    l[0] = l[0] + [2]
    return l
    
df.at[1, 'B'] = myfun(df.at[1, 'B']) 

df

   A                   B
0  1     [[1], [1], [1]]
1  2  [[1, 2], [1], [1]]
2  3     [[1], [1], [1]]

One could use np.where() to get row index:

df.at[np.where(df['A'] == 2)[0][0], 'B'] = myfun(df.at[np.where(df['A'] == 2)[0][0], 'B'])

import pandas as pd
import copy

df = pd.DataFrame(data={'A': [1, 2, 3]})
df['B'] = [[[1],[1],[1]]] * df.shape[0] 


i,j = 1,1
l = copy.deepcopy(df.iat[i, j]) # Deepcopy to avoid pointer problem
l[0] = [1,2]
df.iat[i, j] = l

print(df)

   A                   B
0  1     [[1], [1], [1]]
1  2  [[1, 2], [1], [1]]
2  3     [[1], [1], [1]]