Convert (many) integer-valued rows into binary indicator columns using Pandas

This post is intended to simply add a bit of extra detail to the answer supplied by PaulS. His solution is great, but for my use case, I need to include rows for every integer in a given range beginning from zero (not just which integers happen to appear as elements in the given DataFrame old_df). To address this, simply set a value of max_col_index and perform:

dummies = pandas.get_dummies(old_df.stack())
missing_indices = set(range(max_col_index)) - set(dummies.columns)

new_df = pandas.concat([
dummies.groupby(level=0).sum(),
pandas.DataFrame(dict.fromkeys(list(map(str,missing_indices)),0), index=dummies.groupby(level=0).sum().index)
], axis=1).T

I'm not sure if there is a more concise way to do this using the DataFrame index property (that is, fill a DataFrame with null rows on missing index values up to a given maximum value), but this works well enough for me.

Edit:

It turns out I was correct in my above intuition. A slightly slicker (more "pythonic") version can be given as:

new_df = pandas.get_dummies(old_df.stack()).groupby(level=0).sum().T.reindex(range(max_col_index), fill_value=0)

Assuming a range index in the input DataFrame (if not, run df = df.reset_index(drop=True)).

You could melt and pivot:

out = (df.rename(lambda x: x/10) # optional, just to get the 0.0/0.1/0.2
         .reset_index().melt('index').assign(x=1)
         .pivot_table(index='value', columns='index', values='x', fill_value=0)
         .convert_dtypes().rename_axis(index=None, columns=None)
      )

Or melt and join+pd.get_dummies:

tmp = (
    df.rename(lambda x: x / 10) # optional, just to get the 0.0/0.1/0.2
    .reset_index()
    .melt('index').drop(columns='variable')
)
out = (pd.get_dummies(tmp['index'], dtype='int')
         .set_axis(tmp['value'].rename(None))
      )

Or a more minimal version with unstack and pd.get_dummies:

tmp = df.unstack()
out = (pd.get_dummies(tmp.index.get_level_values(1)/10, dtype='int')
         .set_axis(tmp)
      )

Or with unstack and pd.crosstab:

tmp = df.unstack()
out = (pd.crosstab(tmp, tmp.index.get_level_values(1)/10)
         .rename_axis(index=None, columns=None)
      )

Output:

   0.0  0.1  0.2
1    1    0    0
2    0    1    0
3    0    0    1
4    1    0    0
5    0    1    0
6    0    0    1
7    1    0    0
8    0    1    0
9    0    0    1

Sklearn's OneHotEncoder supports this type of one-hot encoding directly when specifying dense 2D output (sparse_output=False)

enc = OneHotEncoder(sparse_output=False)
e = enc.fit_transform(df)

# [[1. 0. 0. 1. 0. 0. 1. 0. 0.]
#  [0. 1. 0. 0. 1. 0. 0. 1. 0.]
#  [0. 0. 1. 0. 0. 1. 0. 0. 1.]]

This can be turned into the desired DataFrame by transposing the output and assigning the index to the categories_ created during the fit_transform then reindexed to match the desired output range (0 to max value inclusive)

out_df = pd.DataFrame(
    e.T,
    index=np.hstack(enc.categories_),
    dtype='int'
).reindex(pd.RangeIndex(start=0, stop=df.max(axis=None) + 1), fill_value=0)

   0  1  2
0  0  0  0
1  1  0  0
2  0  1  0
3  0  0  1
4  1  0  0
5  0  1  0
6  0  0  1
7  1  0  0
8  0  1  0
9  0  0  1

import numpy as np  # version 2.3.2
import pandas as pd  # version 2.3.1
from sklearn.preprocessing import OneHotEncoder  # scikit-learn version 1.7.1

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})

enc = OneHotEncoder(sparse_output=False)

e = enc.fit_transform(df)

out_df = pd.DataFrame(
    e.T,
    index=np.hstack(enc.categories_),
    dtype='int'
).reindex(pd.RangeIndex(start=0, stop=df.max(axis=None) + 1), fill_value=0)

print(out_df)

Note that the same values in different columns will be considered different features. The number 4 in column A and the number 4 in column B will be split into two rows with index 4 (representing the features A_4 and B_4).

Reindexing will not work if there are duplicate indexes. It is possible to get a count with .groupby(level=0).sum() or keep the indicator with groupby(level=0).max() before reindexing.

Alternatively, if just checking if the value is present in each row (without considering which source column it came from) then use MultiLabelBinarizer on the DataFrame's underlying numpy array.

For the given (modified) sample DataFrame:

enc = MultiLabelBinarizer()
e = enc.fit_transform(df.to_numpy())
# [[1 0 1 0 0 0 0]
#  [0 0 1 1 0 1 0]
#  [0 1 0 0 1 0 1]]

Similar to OneHotEncoder, this can be turned into the desired DataFrame by transposing the output and assigning the index to the classes_ created during the fit_transform and reindexed to include all values in the specified range:

out_df = pd.DataFrame(
    e.T,
    index=enc.classes_
).reindex(pd.RangeIndex(start=0, stop=df.max(axis=None) + 1), fill_value=0)

   0  1  2
0  0  0  0
1  1  0  0
2  0  0  0
3  0  0  1
4  1  1  0
5  0  1  0
6  0  0  1
7  0  0  0
8  0  1  0
9  0  0  1

import pandas as pd  # version 2.3.1
from sklearn.preprocessing import MultiLabelBinarizer  # scikit-learn version 1.7.1

df = pd.DataFrame({'A': [1, 4, 3], 'B': [4, 5, 6], 'C': [4, 8, 9]})

enc = MultiLabelBinarizer()
e = enc.fit_transform(df.to_numpy())

out_df = pd.DataFrame(
    e.T,
    index=enc.classes_
).reindex(pd.RangeIndex(start=0, stop=df.max(axis=None) + 1), fill_value=0)

print(out_df)

Firstly, you should create new dataframe whose index contains the values from old dataframe values on different columns. Also the columns of the new dataframe should have values from your old dataframe index.

import pandas as pd
df = pd.DataFrame({'A':[1,2,3], 'B':[4,5,6], "C":[7,8,9], 'D':[10, 11,12]})

new_df = df.melt().set_index('value').drop('variable', axis = 1)
new_df[df.index.astype(str)] = 0
# I am just filling with zero; later will change necessary ones to 1 and keep the rest as 0.

Now we will match the index of the new_df the values from entire df and take it's row location. Then we will find that row location number from new_df columns (as strings) then assign 1 there. The rest is already 0.

for value in new_df.index:
    original_indices = df.isin([value]).any(axis=1)
    for idx in original_indices[original_indices].index:
        new_df.loc[value, str(idx)] = 1

Note this code works only if your values from df do not repeat (not have duplicate).