DataFrameGroupBy.transform(f, *args, dtypes=None, dtype=None, name=None, index=None, output_types=None, skip_infer=False, **kwargs)#

Call function producing a same-indexed DataFrame on each group.

Returns a DataFrame having the same indexes as the original object filled with the transformed values.

  • f (function, str) –

    Function to apply to each group. See the Notes section below for requirements.

    Accepted inputs are:

    • String

    • Python function

    • Numba JIT function with engine='numba' specified.

    Only passing a single function is supported with this engine. If the 'numba' engine is chosen, the function must be a user defined function with values and index as the first and second arguments respectively in the function signature. Each group’s index will be passed to the user defined function and optionally available for use.

    If a string is chosen, then it needs to be the name of the groupby method you want to use.

  • *args – Positional arguments to pass to func.

  • engine (str, default None (Not supported yet)) –

    • 'cython' : Runs the function through C-extensions from cython.

    • 'numba' : Runs the function through JIT compiled code from numba.

    • None : Defaults to 'cython' or the global setting compute.use_numba

  • engine_kwargs (dict, default None (Not supported yet)) –

    • For 'cython' engine, there are no accepted engine_kwargs

    • For 'numba' engine, the engine can accept nopython, nogil and parallel dictionary keys. The values must either be True or False. The default engine_kwargs for the 'numba' engine is {'nopython': True, 'nogil': False, 'parallel': False} and will be applied to the function

  • **kwargs – Keyword arguments to be passed into func.

Return type


See also


Apply function func group-wise and combine the results together.


Aggregate using one or more operations over the specified axis.


Call func on self producing a DataFrame with the same axis shape as self.


Each group is endowed the attribute ‘name’ in case you need to know which group you are working on.

The current implementation imposes three requirements on f:

  • f must return a value that either has the same shape as the input subframe or can be broadcast to the shape of the input subframe. For example, if f returns a scalar it will be broadcast to have the same shape as the input subframe.

  • if this is a DataFrame, f must support application column-by-column in the subframe. If f also supports application to the entire subframe, then a fast path is used starting from the second chunk.

  • f must not mutate groups. Mutation is not supported and may produce unexpected results. See gotchas.udf-mutation for more details.

When using engine='numba', there will be no “fall back” behavior internally. The group data and group index will be passed as numpy arrays to the JITed user defined function, and no alternative execution attempts will be tried.

Changed in version 1.3.0(pandas): The resulting dtype will reflect the return value of the passed func, see the examples below.

Changed in version 2.0.0(pandas): When using .transform on a grouped DataFrame and the transformation function returns a DataFrame, pandas now aligns the result’s index with the input’s index. You can call .to_numpy() on the result of the transformation function to avoid alignment.


>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',  
...                           'foo', 'bar'],
...                    'B' : ['one', 'one', 'two', 'three',
...                           'two', 'two'],
...                    'C' : [1, 5, 5, 2, 5, 5],
...                    'D' : [2.0, 5., 8., 1., 2., 9.]})
>>> grouped = df.groupby('A')[['C', 'D']]  
>>> grouped.transform(lambda x: (x - x.mean()) / x.std())  
        C         D
0 -1.154701 -0.577350
1  0.577350  0.000000
2  0.577350  1.154701
3 -1.154701 -1.000000
4  0.577350 -0.577350
5  0.577350  1.000000

Broadcast result of the transformation

>>> grouped.transform(lambda x: x.max() - x.min())  
    C    D
0  4.0  6.0
1  3.0  8.0
2  4.0  6.0
3  3.0  8.0
4  4.0  6.0
5  3.0  8.0
>>> grouped.transform("mean")  
    C    D
0  3.666667  4.0
1  4.000000  5.0
2  3.666667  4.0
3  4.000000  5.0
4  3.666667  4.0
5  4.000000  5.0

Changed in version 1.3.0(pandas).

The resulting dtype will reflect the return value of the passed func, for example:

>>> grouped.transform(lambda x: x.astype(int).max())  
C  D
0  5  8
1  5  9
2  5  8
3  5  9
4  5  8
5  5  9
Extra Parameters
f : function
    Function to apply to each group.
dtypes : Series, default None
    Specify dtypes of returned DataFrames. See `Notes` for more details.
dtype : numpy.dtype, default None
    Specify dtype of returned Series. See `Notes` for more details.
name : str, default None
    Specify name of returned Series. See `Notes` for more details.
skip_infer: bool, default False
    Whether infer dtypes when dtypes or output_type is not specified.

This docstring was copied from pandas.core.groupby.generic.DataFrameGroupBy.