Get all columns per id where the column is equal to a value

You can do what you are trying to do adding .tolist():

df['Result'] = df.apply(lambda row: row[row == 1].index.tolist(), axis=1)

Saying that, your approach of using lists as values inside a single column seems contradictory with the Pandas approach of keeping data tabular (only one value per cell). It will probably be better to use nested lists instead of pandas to do what you are trying to do.

Setup

I used a different set of ones and zeros to highlight skipping an entire row.

df = pd.DataFrame(
    [[0, 1, 0, 1], [1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 1, 0]],
    ['id1', 'id2', 'id3', 'id4'],
    ['A', 'B', 'C', 'D']
)

df

     A  B  C  D
id1  0  1  0  1
id2  1  0  0  1
id3  0  0  0  0
id4  0  0  1  0

Not Your Grampa's Reverse Binerizer

n = len(df)
i, j = np.nonzero(df.to_numpy())

col_names = df.columns[j]
positions = np.bincount(i).cumsum()[:-1]

result = np.split(col_names, positions)
df.assign(Result=[a.tolist() for a in result])

     A  B  C  D  Result
id                     
id1  0  1  0  1  [B, D]
id2  1  0  0  1  [A, D]
id3  0  0  0  0      []
id4  0  0  1  0     [C]

Explanations

Ohh, the details!

np.nonzero on a 2-D array will return two arrays of equal length. The first array will have the 1st dimensional position of each element that is not zero. The second array will have the 2nd dimensional position of each element that is not zero. I'll call the first array i and the second array j.

In the figure below, I label the columns with what j they represent and correspondingly, I label the rows with what i they represent.

For each non-zero element of the dataframe, I place above the value a tuple with the (ith, jth) dimensional positions and in brackets the [kth] non-zero element in the dataframe.

#        j → 0        1        2        3
#            A        B        C        D
# i
# ↓                 (0,1)[0]          (0,3)[1]
# 0  id1     0        1        0        1
#
#          (1,0)[2]                   (1,3)[3]
# 1  id2     1        0        0        1
#
#
# 2  id3     0        0        0        0
#
#                            (3,2)[4]
# 3  id4     0        0        1        0

In the figure below, I show what i and j look like. I label each row with the same k in the brackets in the figure above

#  i  j
#  ----
#  0  1  k=0
#  0  3  k=1
#  1  0  k=2
#  1  3  k=3
#  3  2  k=4

Now it's easy to slice the df.columns with the j array to get all the column labels in one big array.

# df.columns[j]
#   B
#   D
#   A
#   D
#   C

The plan is to use np.split to chop up df.columns[j] into the sub arrays for each row. Turns out that the information is embedded in the array i. I'll use np.bincount to count how many non-zero elements are in each row. I'll need to tell np.bincount the minimum number of bins we are assuming to have. That minimum is the number of rows in the dataframe. We assign it to n with n = len(df)

# np.bincount(i, minlength=n)
#   2  ← Two non-zero elements in the first row
#   2  ← Two more in the second row
#   0  ← None in this row
#   1  ← And one more in the fourth row

However, if we take the cumulative sum of this array, we get the positions we need to split at.

# np.bincount(i, minlength=n).cumsum()
#   2
#   4
#   4  ← This repeated value results in an empty array for the 3rd row
#   5

Let's look at how this matches up with df.columns[j]. We see below that the column slice gets split exactly where we need.

# B    D    A    D    D     ← df.columns[j]
#        2         44   5   ← np.bincount(i, minlength=n).cumsum()

One issue is that the 4 values in this array will result in splitting the df.columns[j] array into 5 sub-arrays. This isn't horrible because the last array will always be empty. so we slice it to appropriate size np.bincount(i, minlength=n).cumsum()[:-1]

col_names = df.columns[j]
positions = np.bincount(i, minlength=n).cumsum()[:-1]

result = np.split(col_names, positions)

#   result
#   [B, D]
#   [A, D]
#   []
#   [D]

The only thing left to do is assign it to a new columns and make the individual sub-arrays lists instead.

df.assign(Result=[a.tolist() for a in result])
#      A  B  C  D  Result
# id                     
# id1  0  1  0  1  [B, D]
# id2  1  0  0  1  [A, D]
# id3  0  0  0  0      []
# id4  0  0  1  0     [C]