Understanding DataFrame.transform() method in Pandas (5 examples)

Updated: February 20, 2024 By: Guest Contributor Post a comment


Pandas is one of the most powerful and widely used libraries for data manipulation and analysis in Python. It provides numerous functionalities to work with structured data, especially with tabular data. Among its numerous methods, transform() holds a unique place for its ability to perform operations on a DataFrame or Series while retaining the original index. This tutorial delves into the transform() method, elucidating its utility with 5 progressively complex examples.

What is transform() Used for?

The transform() function in Pandas applies a function to each element of a DataFrame or Series, returning a result with the same shape as the original data. This is particularly useful when you need to apply a transformation function that returns a result for each element, and you want to maintain the structure (rows and indexes) of the original DataFrame. Unlike apply(), which can return results with different dimensions, transform() maintains the dimensions of the data, making it more suitable for certain types of operations.

Example 1: Applying a Simple Function

First, let’s start with a basic example where we apply a simple function to all elements in a column of a DataFrame:

import pandas as pd

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

df['A_transformed'] = df['A'].transform(lambda x: x * 2)

This will output:

   A  B  A_transformed
0  1  5             2
1  2  6             4
2  3  7             6
3  4  8             8

Here, we used a lambda function to multiply each element in column ‘A’ by 2, and the result is a new column that maintains the same index as the original DataFrame.

Example 2: Using Predefined Functions

In addition to lambda functions, predefined functions can also be utilized with transform(). For instance, consider normalizing data in a column:

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
df['A_normalized'] = df['A'].transform(scaler.fit_transform)

Note: This requires the sklearn library (run pip install scikit-learn).

This will output a DataFrame where the ‘A’ column has been normalized.

Example 3: Applying Transform on Multiple Columns

You can apply a transform operation on multiple columns at once, which can be particularly useful for applying the same transformation to several columns. Here’s how:

def multiply_by_two(x):
    return x * 2

df[['A', 'B']] = df[['A', 'B']].transform(multiply_by_two)

This operation multiplies every element in columns ‘A’ and ‘B’ by 2, maintaining the original DataFrame’s structure.

Example 4: Complex Transformations

For more complex operations, you can combine transform() with other methods. For instance, you can use it to perform row-wise operations:

df['sum'] = df.transform(lambda x: x.sum(), axis=1)

This adds a new column to the DataFrame that contains the sum of each row. Note: The axis parameter is set to 1 to indicate row-wise operation.

Example 5: Conditional Transformations

Finally, we’ll look at applying conditional transformations, where the function applied depends on some condition. For example:

df['A_double_if_even'] = df['A'].transform(lambda x: x*2 if x % 2 == 0 else x)

This will double the values in column ‘A’ if they are even, otherwise, the original value is retained. This showcases the flexibility of transform() in applying customized operations while preserving the DataFrame structure.


The transform() method in Pandas is a powerful tool for applying functions to your data, enabling both simple and complex transformations while maintaining your data’s original structure. Understanding how to effectively use this method can greatly enhance your data manipulation capabilities in Python.