pandas.core.groupby.DataFrameGroupBy.transform#

DataFrameGroupBy.transform(func, *args, engine=None, engine_kwargs=None, **kwargs)[源代码]#

调用函数，对每个组生成一个具有相同索引的 DataFrame。

返回一个 DataFrame，该 DataFrame 具有与原始对象相同的索引，并填充了转换后的值。

Parameters:
ffunction, str

要应用于每个组的函数。有关要求，请参见下方的“说明”部分。

可接受的输入包括：

  • String

  • Python function

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

只有在使用此引擎时才支持传递单个函数。如果选择“numba”引擎，则该函数必须是用户定义的函数，其函数签名中，values 和 index 分别作为第一个和第二个参数。每个组的索引都将传递给用户定义的函数，并可供选择使用。

如果选择字符串，则它需要是你想要使用的 groupby 方法的名称。

*args

传递给 func 的位置参数。

enginestr，默认 None

  • 'cython' : 通过 cython 的 C 扩展运行函数。

  • 'numba' : 通过 numba 的 JIT 编译代码运行函数。

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

engine_kwargsdict, 默认为 None

  • 对于 'cython' 引擎，没有可接受的 engine_kwargs

  • 对于 'numba' 引擎，该引擎可以接受 nopython、nogil 和 parallel 字典键。值必须是 True 或 False。 'numba' 引擎的默认 engine_kwargs 为 {'nopython': True, 'nogil': False, 'parallel': False}，并将应用于函数

**kwargs

要传递给 func 的关键字参数。

Returns:
DataFrame

参见

DataFrame.groupby.apply

按组应用函数 func 并将结果组合在一起。

DataFrame.groupby.aggregate

沿指定轴使用一个或多个操作进行聚合。

DataFrame.transform

在self上调用``func``，生成一个与self具有相同轴形状的DataFrame。

Notes

每个组都具有 ‘name’ 属性，以防你需要知道你正在处理哪个组。

当前的实现对 f 施加了三个要求：

  • f 必须返回一个值，该值要么具有与输入子帧相同的形状，要么可以广播到输入子帧的形状。例如，如果 f 返回一个标量，它将被广播到与输入子帧相同的形状。

  • 如果是 DataFrame，f 必须支持逐列应用于子帧。如果 f 还支持应用于整个子帧，则从第二个块开始使用快速路径。

  • f 不能修改组。不支持修改，并且可能产生意外结果。有关详细信息，请参见 使用用户定义函数 (UDF) 方法进行变异 。

使用 engine='numba' 时，内部不会有“回退”行为。组数据和组索引将作为 numpy 数组传递给 JITed 用户定义的函数，并且不会尝试其他执行。

在 1.3.0 版本发生变更: 结果的 dtype 将反映传递的 func 的返回值，请参阅下面的示例。

在 2.0.0 版本发生变更: 在对分组的 DataFrame 使用 .transform 时，如果转换函数返回一个 DataFrame，pandas 现在会将结果的索引与输入的索引对齐。你可以调用转换函数的结果上的 .to_numpy() 来避免对齐。

Examples

>>> 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

在 1.3.0 版本发生变更.

结果的 dtype 将反映所传入 func 的返回值，例如：

>>> 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
On this page
显示源代码