Pandas-2-2-中文文档-三十四-
Pandas 2.2 中文文档（三十四）
pandas.core.groupby.SeriesGroupBy.aggregate
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.aggregate.html
SeriesGroupBy.aggregate(func=None, *args, engine=None, engine_kwargs=None, **kwargs)
根据指定轴上的一个或多个操作进行聚合。
参数：
func 函数、str、列表、字典或 None
用于聚合数据的函数。如果是一个函数，必须在传递给 Series 或在 Series.apply 中使用时起作用。
可接受的组合有：
-
函数
-
字符串函数名称
-
函数和/或函数名称的列表，例如
[np.sum, 'mean'] -
None，则使用 Named Aggregation 和
**kwargs。此处的输出每个元素在**kwargs中有一列。列的名称是关键字，而值确定用于计算列中值的聚合。还可以接受一个 Numba JIT 函数，指定
engine='numba'。此引擎仅支持传递单个函数。如果选择了
'numba'引擎，则函数必须是具有函数签名中的values和index作为第一个和第二个参数的用户定义函数。将每个组的索引传递给用户定义的函数，并可选择用于使用。
从版本 2.1.0 开始弃用：传递字典已被弃用，将在 pandas 的将来版本中引发错误。请传递一个聚合列表。
*args
传递给 func 的位置参数。
engine 字符串，默认为 None
-
'cython'：通过 cython 的 C 扩展运行函数。 -
'numba'：通过 numba 的 JIT 编译代码运行函数。 -
None：默认为'cython'或全局设置compute.use_numba
engine_kwargs 字典，默认为 None
-
对于
'cython'引擎，不接受engine_kwargs -
对于
'numba'引擎，该引擎可以接受nopython、nogil和parallel字典键。值必须为True或False。'numba'引擎的默认engine_kwargs是{'nopython': True, 'nogil': False, 'parallel': False}，将应用于函数。
kwargs
-
如果
func为 None，则使用**kwargs来定义输出名称和聚合方式，通过命名聚合。请参见func条目。 -
否则，关键字参数将传递给 func。
返回：
Series
另请参见
Series.groupby.apply
对每个组应用函数 func 并将结果组合在一起。
Series.groupby.transform
根据给定函数对每个组上的 Series 进行转换。
Series.aggregate
根据指定轴上的一个或多个操作进行聚合。
注释
当使用 engine='numba' 时，内部不会有“回退”行为。将组数据和组索引作为 numpy 数组传递给 JITed 用户定义函数，且不会尝试其他执行尝试。
变异传递对象的函数可能会产生意外行为或错误，并且不受支持。有关更多详细信息，请参见使用用户定义函数（UDF）方法进行变异。
自版本 1.3.0 更改：结果 dtype 将反映传递的func的返回值，请参见下面的示例。
示例
>>> s = pd.Series([1, 2, 3, 4])
>>> s
0 1
1 2
2 3
3 4
dtype: int64
>>> s.groupby([1, 1, 2, 2]).min()
1 1
2 3
dtype: int64
>>> s.groupby([1, 1, 2, 2]).agg('min')
1 1
2 3
dtype: int64
>>> s.groupby([1, 1, 2, 2]).agg(['min', 'max'])
min max
1 1 2
2 3 4
可通过传递所需的列名和聚合作为关键字参数来控制输出列名。
>>> s.groupby([1, 1, 2, 2]).agg(
... minimum='min',
... maximum='max',
... )
minimum maximum
1 1 2
2 3 4
自版本 1.3.0 更改：结果 dtype 将反映聚合函数的返回值。
>>> s.groupby([1, 1, 2, 2]).agg(lambda x: x.astype(float).min())
1 1.0
2 3.0
dtype: float64
pandas.core.groupby.DataFrameGroupBy.aggregate
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.aggregate.html
DataFrameGroupBy.aggregate(func=None, *args, engine=None, engine_kwargs=None, **kwargs)
使用一个或多个操作在指定的轴上进行聚合。
参数：
func函数、字符串、列表、字典或 None
用于对数据进行聚合的函数。如果是一个函数，则必须能够在传递给 DataFrame 或传递给 DataFrame.apply 时正常工作。
接受的组合有：
-
函数
-
字符串函数名
-
函数和/或函数名的列表，例如
[np.sum, 'mean'] -
轴标签的字典 -> 函数、函数名或此类列表。
-
None，此时使用
**kwargs与命名聚合一起使用。这里的输出对应于**kwargs中的每个元素都有一列。列的名称是关键字，而值确定用于计算列中值的聚合。还可以接受一个带有指定
engine='numba'的 Numba JIT 函数。此引擎仅支持传递单个函数。如果选择了
'numba'引擎，则函数必须是一个用户定义的函数，其函数签名中的第一个参数为values，第二个参数为index。每个组的索引将被传递给用户定义的函数，并且可选择用于使用。
*args
传递给 func 的位置参数。
enginestr，默认为 None
-
'cython'：通过来自 cython 的 C 扩展运行该函数。 -
'numba'：通过来自 numba 的 JIT 编译代码运行该函数。 -
None：默认为'cython'或全局设置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是 None，则使用**kwargs来定义输出名称和聚合方式，通过命名聚合。请参阅func条目。 -
否则，要传递给 func 的关键字参数。
返回：
DataFrame
另请参阅
DataFrame.groupby.apply
对每个组应用函数 func，并将结果组合在一起。
DataFrame.groupby.transform
根据给定的函数在每个组上对 Series 进行变换。
DataFrame.aggregate
使用一个或多个操作在指定的轴上进行聚合。
注意事项
当使用 engine='numba' 时，内部不会有“回退”行为。组数据和组索引将作为 numpy 数组传递给 JIT 编译的用户定义函数，并且不会尝试任何其他执行尝试。
对传递的对象进行变异的函数可能会产生意外的行为或错误，并且不受支持。有关更多详细信息，请参阅 使用用户定义函数 (UDF) 方法进行变异。
1.3.0 版更改：结果 dtype 将反映传递的func的返回值，请参见下面的示例。
示例
>>> data = {"A": [1, 1, 2, 2],
... "B": [1, 2, 3, 4],
... "C": [0.362838, 0.227877, 1.267767, -0.562860]}
>>> df = pd.DataFrame(data)
>>> df
A B C
0 1 1 0.362838
1 1 2 0.227877
2 2 3 1.267767
3 2 4 -0.562860
聚合是针对每一列的。
>>> df.groupby('A').agg('min')
B C
A
1 1 0.227877
2 3 -0.562860
多个聚合
>>> df.groupby('A').agg(['min', 'max'])
B C
min max min max
A
1 1 2 0.227877 0.362838
2 3 4 -0.562860 1.267767
选择要进行聚合的列
>>> df.groupby('A').B.agg(['min', 'max'])
min max
A
1 1 2
2 3 4
用于聚合的用户定义函数
>>> df.groupby('A').agg(lambda x: sum(x) + 2)
B C
A
1 5 2.590715
2 9 2.704907
每列不同的聚合
>>> df.groupby('A').agg({'B': ['min', 'max'], 'C': 'sum'})
B C
min max sum
A
1 1 2 0.590715
2 3 4 0.704907
为了通过每列的不同聚合控制输出名称，pandas 支持“命名聚合”
>>> df.groupby("A").agg(
... b_min=pd.NamedAgg(column="B", aggfunc="min"),
... c_sum=pd.NamedAgg(column="C", aggfunc="sum")
... )
b_min c_sum
A
1 1 0.590715
2 3 0.704907
-
关键词是输出列的名称
-
值是元组，其第一个元素是要选择的列，第二个元素是要对该列应用的聚合函数。Pandas 提供了
pandas.NamedAgg命名元组，其中字段为['column', 'aggfunc']，以更清晰地表示这些参数是什么。通常情况下，聚合可以是可调用对象或字符串别名。
更多内容请参见命名聚合。
1.3.0 版更改：结果 dtype 将反映聚合函数的返回值。
>>> df.groupby("A")[["B"]].agg(lambda x: x.astype(float).min())
B
A
1 1.0
2 3.0
pandas.core.groupby.SeriesGroupBy.transform
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.transform.html
SeriesGroupBy.transform(func, *args, engine=None, engine_kwargs=None, **kwargs)
在每个组上调用函数，产生一个具有相同索引的 Series。
返回一个具有与原始对象相同索引的 Series，填充有转换后的值。
参数：
f函数，字符串
应用于每个组的函数。有关要求，请参阅下面的注意事项部分。
接受的输入为：
-
字符串
-
Python 函数
-
指定了
engine='numba'的 Numba JIT 函数。
该引擎仅支持传递单个函数。如果选择了'numba'引擎，则函数必须是用户定义的函数，函数签名中的第一个和第二个参数分别为values和index。每个组的索引将被传递给用户定义的函数，并可选择性地供使用。
如果选择了字符串，则需要是您想要使用的 groupby 方法的名称。
*args
传递给 func 的位置参数。
engine字符串，默认为 None
-
'cython'：通过 cython 的 C 扩展运行函数。 -
'numba'：通过 numba 的 JIT 编译代码运行函数。 -
None：默认为'cython'或全局设置compute.use_numba
engine_kwargs字典，默认为 None
-
对于
'cython'引擎，不接受engine_kwargs -
对于
'numba'引擎，引擎可以接受nopython、nogil和parallel字典键。值必须是True或False。'numba'引擎的默认engine_kwargs为{'nopython': True, 'nogil': False, 'parallel': False}，并将应用于函数。
**kwargs
要传递给 func 的关键字参数。
返回：
Series
另请参阅
Series.groupby.apply
逐组应用函数func，并将结果组合在一起。
Series.groupby.aggregate
使用一个或多个操作在指定轴上进行聚合。
Series.transform
在 self 上调用func，产生一个与 self 具有相同轴形状的 Series。
注意
每个组都被赋予属性‘name’，以便您知道正在处理哪个组。
当前实现对 f 有三个要求：
-
f 必须返回一个与输入子框架具有相同形状的值，或者可以广播到输入子框架的形状。例如，如果 f 返回一个标量，它将被广播为具有与输入子框架相同的形状。
-
如果这是一个 DataFrame，则 f 必须支持在子框架中逐列应用。如果 f 还支持对整个子框架的应用，则从第二个块开始使用快速路径。
-
f 不能改变组。不支持变异，可能会产生意外结果。有关更多详细信息，请参阅 Mutating with User Defined Function (UDF) methods。
当使用engine='numba'时，内部不会有“回退”行为。组数据和组索引将作为 numpy 数组传递给 JIT 用户定义的函数，并且不会尝试任何替代执行。
从版本 1.3.0 开始更改：结果的 dtype 将反映传递的func的返回值，请参见下面的示例。
从版本 2.0.0 开始更改：在对分组的 DataFrame 使用.transform时，如果转换函数返回一个 DataFrame，pandas 现在会将结果的索引与输入的索引对齐。您可以在转换函数的结果上调用.to_numpy()来避免对齐。
示例
>>> ser = pd.Series([390.0, 350.0, 30.0, 20.0],
... index=["Falcon", "Falcon", "Parrot", "Parrot"],
... name="Max Speed")
>>> grouped = ser.groupby([1, 1, 2, 2])
>>> grouped.transform(lambda x: (x - x.mean()) / x.std())
Falcon 0.707107
Falcon -0.707107
Parrot 0.707107
Parrot -0.707107
Name: Max Speed, dtype: float64
广播转换的结果
>>> grouped.transform(lambda x: x.max() - x.min())
Falcon 40.0
Falcon 40.0
Parrot 10.0
Parrot 10.0
Name: Max Speed, dtype: float64
>>> grouped.transform("mean")
Falcon 370.0
Falcon 370.0
Parrot 25.0
Parrot 25.0
Name: Max Speed, dtype: float64
从版本 1.3.0 开始更改。
结果的 dtype 将反映传递的func的返回值，例如：
>>> grouped.transform(lambda x: x.astype(int).max())
Falcon 390
Falcon 390
Parrot 30
Parrot 30
Name: Max Speed, dtype: int64
pandas.core.groupby.DataFrameGroupBy.transform
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.transform.html
DataFrameGroupBy.transform(func, *args, engine=None, engine_kwargs=None, **kwargs)
在每个组上调用产生具有相同索引的 DataFrame 的函数。
返回一个具有与原始对象相同索引的 DataFrame，填充转换后的值。
参数：
f函数，str
应用于每个组的函数。有关要求，请参阅下面的注意事项部分。
接受的输入为：
-
字符串
-
Python 函数
-
Numba JIT 函数，指定
engine='numba'。
只支持使用此引擎传递单个函数。如果选择了'numba'引擎，则函数必须是一个用户定义的函数，函数签名中的第一个和第二个参数分别为values和index。每个组的索引将传递给用户定义的函数，并可选择用于使用。
如果选择了字符串，则它需要是您想要使用的 groupby 方法的名称。
*args
传递给 func 的位置参数。
enginestr，默认为 None
-
'cython'：通过 cython 的 C 扩展运行函数。 -
'numba'：通过 numba 的 JIT 编译代码运行函数。 -
None：默认为'cython'或全局设置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 的关键字参数。
返回：
DataFrame
另请参见
DataFrame.groupby.apply
逐组应用函数func，并将结果组合在一起。
DataFrame.groupby.aggregate
使用一个或多个操作在指定轴上聚合。
DataFrame.transform
在 self 上调用func，生成一个与 self 具有相同轴���状的 DataFrame。
注意事项
每个分组都被赋予属性‘name’，以便您知道正在处理哪个分组。
当前实现对 f 有三个要求：
-
f 必须返回一个与输入子框架具有相同形状的值，或者可以广播到输入子框架的形状。例如，如果 f 返回一个标量，则将广播为具有与输入子框架相同形状。
-
如果这是一个 DataFrame，则 f 必须支持在子框架中逐列应用。如果 f 还支持对整个子框架的应用，则从第二个块开始使用快速路径。
-
f 不能改变组。不支持突变，可能会产生意外结果。有关更多详细信息，请参阅使用用户定义函数（UDF）方法进行突变。
当使用engine='numba'时，内部不会有“回退”行为。分组数据和分组索引将作为 numpy 数组传递给 JIT 用户定义的函数，并且不会尝试其他执行方式。
Changed in version 1.3.0: 结果的数据类型将反映传递的func的返回值，请参见下面的示例。
Changed in version 2.0.0: 在对分组的 DataFrame 使用.transform并且转换函数返回一个 DataFrame 时，pandas 现在会将结果的索引与输入的索引对齐。您可以在转换函数的结果上调用.to_numpy()以避免对齐。
示例
>>> 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
广播转换的结果
>>> 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.
结果的数据类型将反映传递的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
pandas.core.groupby.SeriesGroupBy.pipe
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.pipe.html
SeriesGroupBy.pipe(func, *args, **kwargs)
对此 GroupBy 对象应用带参数的 func 并返回其结果。
当您想要通过链接期望 Series、DataFrame、GroupBy 或 Resampler 对象的函数来提高可读性时，请使用 .pipe。而不是编写
>>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3
>>> g = lambda x, arg1: x * 5 / arg1
>>> f = lambda x: x ** 4
>>> df = pd.DataFrame([["a", 4], ["b", 5]], columns=["group", "value"])
>>> h(g(f(df.groupby('group')), arg1=1), arg2=2, arg3=3)
你可以写
>>> (df.groupby('group')
... .pipe(f)
... .pipe(g, arg1=1)
... .pipe(h, arg2=2, arg3=3))
这样更易读。
参数：
func可调用对象或 (可调用对象, 字符串) 元组
应用于此 GroupBy 对象的函数，或者是一个 (可调用对象, 数据关键字) 元组，其中数据关键字是一个字符串，指示可调用对象期望的 GroupBy 对象的关键字。
args可迭代对象，可选
传递给 func 的位置参数。
kwargs字典，可选
传递给 func 的关键字参数字典。
返回：
func 的返回类型。
另请参阅
Series.pipe
对系列应用带参数的函数。
DataFrame.pipe
对数据框应用带参数的函数。
apply
对每个组应用函数，而不是对整个 GroupBy 对象应用函数。
注意
更多信息请查看这里
示例
>>> df = pd.DataFrame({'A': 'a b a b'.split(), 'B': [1, 2, 3, 4]})
>>> df
A B
0 a 1
1 b 2
2 a 3
3 b 4
要一次获取每个组的最大值和最小值之间的差异，可以执行
>>> df.groupby('A').pipe(lambda x: x.max() - x.min())
B
A
a 2
b 2
pandas.core.groupby.DataFrameGroupBy.pipe
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.pipe.html
DataFrameGroupBy.pipe(func, *args, **kwargs)
将带有参数的 func 应用于此 GroupBy 对象并返回其结果。
当您想要通过链接期望 Series、DataFrames、GroupBy 或 Resampler 对象的函数来提高可读性时，请使用.pipe。而不是编写
>>> h = lambda x, arg2, arg3: x + 1 - arg2 * arg3
>>> g = lambda x, arg1: x * 5 / arg1
>>> f = lambda x: x ** 4
>>> df = pd.DataFrame([["a", 4], ["b", 5]], columns=["group", "value"])
>>> h(g(f(df.groupby('group')), arg1=1), arg2=2, arg3=3)
您可以编写
>>> (df.groupby('group')
... .pipe(f)
... .pipe(g, arg1=1)
... .pipe(h, arg2=2, arg3=3))
这样更易读。
参数：
funccallable 或(callable, str)元组
要应用于此 GroupBy 对象的函数，或者替代地，一个(callable, data_keyword)元组，其中 data_keyword 是一个字符串，指示 callable 期望 GroupBy 对象的关键字。
args可迭代，可选
传递给 func 的位置参数。
kwargs字典，可选
传递给 func 的关键字参数。
返回：
func 的返回类型。
另请参阅
Series.pipe
将带有参数的函数应用于系列。
DataFrame.pipe
将带有参数的函数应用于数据帧。
apply
将函数应用于每个组，而不是应用于完整的 GroupBy 对象。
注意
查看更多这里
示例
>>> df = pd.DataFrame({'A': 'a b a b'.split(), 'B': [1, 2, 3, 4]})
>>> df
A B
0 a 1
1 b 2
2 a 3
3 b 4
要在一次传递中获取每个组的最大值和最小值之间的差异，您可以执行
>>> df.groupby('A').pipe(lambda x: x.max() - x.min())
B
A
a 2
b 2
pandas.core.groupby.DataFrameGroupBy.filter
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.filter.html
DataFrameGroupBy.filter(func, dropna=True, *args, **kwargs)
从不满足条件的组中筛选元素。
如果不满足 func 指定的布尔条件，则从组中筛选元素。
参数：
func函数
应用于每个组的条件。应返回 True 或 False。
dropna布尔值
删除不符合筛选条件的组。默认为 True；如果为 False，则评估为 False 的组将填充为 NaN。
返回：
DataFrame
注意
每个子框架都被赋予属性‘name’，以便您知道正在处理哪个组。
对传递对象进行变异的函数可能会产生意外行为或错误，并且不受支持。有关更多详细信息，请参阅使用用户定义函数（UDF）方法进行变异。
示例
>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
... 'foo', 'bar'],
... 'B' : [1, 2, 3, 4, 5, 6],
... 'C' : [2.0, 5., 8., 1., 2., 9.]})
>>> grouped = df.groupby('A')
>>> grouped.filter(lambda x: x['B'].mean() > 3.)
A B C
1 bar 2 5.0
3 bar 4 1.0
5 bar 6 9.0
pandas.core.groupby.SeriesGroupBy.filter
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.filter.html
SeriesGroupBy.filter(func, dropna=True, *args, **kwargs)
从不满足条件的组中过滤元素。
如果组中的元素不满足 func 指定的布尔标准，则过滤掉这些元素。
参数：
func函数
应用于每个组的标准。应返回 True 或 False。
dropna布尔值
删除未通过过滤器的组。默认为 True；如果为 False，则评估为 False 的组将填充为 NaN。
返回：
Series
注意事项：
对传入对象进行变异的函数可能会产生意外行为或错误，并且不受支持。有关更多详细信息，请参阅使用用户定义函数（UDF）方法进行变异。
示例
>>> df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
... 'foo', 'bar'],
... 'B' : [1, 2, 3, 4, 5, 6],
... 'C' : [2.0, 5., 8., 1., 2., 9.]})
>>> grouped = df.groupby('A')
>>> df.groupby('A').B.filter(lambda x: x.mean() > 3.)
1 2
3 4
5 6
Name: B, dtype: int64
pandas.core.groupby.DataFrameGroupBy.all
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.all.html
DataFrameGroupBy.all(skipna=True)
如果组中的所有值都为真，则返回 True，否则返回 False。
参数:
skipnabool, 默认 True
标志，用于在测试真值时忽略 nan 值。
返回:
Series 或 DataFrame
DataFrame 或 Series 的布尔值，其中如果所有元素在其各自的组内都为真，则值为 True，否则为 False。
另请参阅
Series.groupby
将函数 groupby 应用于 Series。
DataFrame.groupby
将函数 groupby 应用于 DataFrame 的每一行或列。
示例
对于 SeriesGroupBy:
>>> lst = ['a', 'a', 'b']
>>> ser = pd.Series([1, 2, 0], index=lst)
>>> ser
a 1
a 2
b 0
dtype: int64
>>> ser.groupby(level=0).all()
a True
b False
dtype: bool
对于 DataFrameGroupBy:
>>> data = [[1, 0, 3], [1, 5, 6], [7, 8, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["ostrich", "penguin", "parrot"])
>>> df
a b c
ostrich 1 0 3
penguin 1 5 6
parrot 7 8 9
>>> df.groupby(by=["a"]).all()
b c
a
1 False True
7 True True
pandas.core.groupby.DataFrameGroupBy.any
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.any.html
DataFrameGroupBy.any(skipna=True)
如果组内的任何值为真，则返回 True，否则返回 False。
参数：
skipnabool，默认为 True
标志以在真值测试期间忽略 nan 值。
返回：
Series 或 DataFrame
DataFrame 或 Series 的布尔值，如果其各自组内的任何元素为 True，则该值为 True，否则为 False。
另请参阅
Series.groupby
对 Series 应用 groupby 函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用 groupby 函数。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b']
>>> ser = pd.Series([1, 2, 0], index=lst)
>>> ser
a 1
a 2
b 0
dtype: int64
>>> ser.groupby(level=0).any()
a True
b False
dtype: bool
对于 DataFrameGroupBy：
>>> data = [[1, 0, 3], [1, 0, 6], [7, 1, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["ostrich", "penguin", "parrot"])
>>> df
a b c
ostrich 1 0 3
penguin 1 0 6
parrot 7 1 9
>>> df.groupby(by=["a"]).any()
b c
a
1 False True
7 True True
pandas.core.groupby.DataFrameGroupBy.bfill
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.bfill.html
DataFrameGroupBy.bfill(limit=None)
向后填充值。
参数：
limitint，可选
要填充多少个值的限制。
返回：
Series 或 DataFrame
填充了缺失值的对象。
另请参阅
Series.bfill
在数据集中向后填充缺失的值。
DataFrame.bfill
在数据集中向后填充缺失的值。
Series.fillna
填充 Series 的 NaN 值。
DataFrame.fillna
填充 DataFrame 的 NaN 值。
示例
使用 Series：
>>> index = ['Falcon', 'Falcon', 'Parrot', 'Parrot', 'Parrot']
>>> s = pd.Series([None, 1, None, None, 3], index=index)
>>> s
Falcon NaN
Falcon 1.0
Parrot NaN
Parrot NaN
Parrot 3.0
dtype: float64
>>> s.groupby(level=0).bfill()
Falcon 1.0
Falcon 1.0
Parrot 3.0
Parrot 3.0
Parrot 3.0
dtype: float64
>>> s.groupby(level=0).bfill(limit=1)
Falcon 1.0
Falcon 1.0
Parrot NaN
Parrot 3.0
Parrot 3.0
dtype: float64
使用 DataFrame：
>>> df = pd.DataFrame({'A': [1, None, None, None, 4],
... 'B': [None, None, 5, None, 7]}, index=index)
>>> df
A B
Falcon 1.0 NaN
Falcon NaN NaN
Parrot NaN 5.0
Parrot NaN NaN
Parrot 4.0 7.0
>>> df.groupby(level=0).bfill()
A B
Falcon 1.0 NaN
Falcon NaN NaN
Parrot 4.0 5.0
Parrot 4.0 7.0
Parrot 4.0 7.0
>>> df.groupby(level=0).bfill(limit=1)
A B
Falcon 1.0 NaN
Falcon NaN NaN
Parrot NaN 5.0
Parrot 4.0 7.0
Parrot 4.0 7.0
pandas.core.groupby.DataFrameGroupBy.corr
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.corr.html
DataFrameGroupBy.corr(method='pearson', min_periods=1, numeric_only=False)
计算列的成对相关性，不包括 NA/null 值。
参数：
method或 callable
相关方法：
-
pearson：标准相关系数
-
kendall：肯德尔 Tau 相关系数
-
spearman：斯皮尔曼等级相关
-
callable：具有两个 1d ndarrays 输入的可调用函数
并返回一个浮点数。请注意，corr 返回的矩阵在对角线上为 1，无论 callable 的行为如何都将是对称的。
min_periodsint，可选
每对列所需的最小观测次数以获得有效结果。目前仅适用于皮尔逊和斯皮尔曼相关性。
numeric_onlybool，默认为 False
仅包括浮点、整数或布尔数据。
版本 1.5.0 中的新功能。
在版本 2.0.0 中更改：numeric_only的默认值现在为False。
返回：
DataFrame
相关矩阵。
另请参见
DataFrame.corrwith
与另一个 DataFrame 或 Series 计算成对相关性。
Series.corr
计算两个 Series 之间的相关性。
备注
目前使用成对完整观测值计算皮尔逊、肯德尔和斯皮尔曼相关性。
示例
>>> def histogram_intersection(a, b):
... v = np.minimum(a, b).sum().round(decimals=1)
... return v
>>> df = pd.DataFrame([(.2, .3), (.0, .6), (.6, .0), (.2, .1)],
... columns=['dogs', 'cats'])
>>> df.corr(method=histogram_intersection)
dogs cats
dogs 1.0 0.3
cats 0.3 1.0
>>> df = pd.DataFrame([(1, 1), (2, np.nan), (np.nan, 3), (4, 4)],
... columns=['dogs', 'cats'])
>>> df.corr(min_periods=3)
dogs cats
dogs 1.0 NaN
cats NaN 1.0
pandas.core.groupby.DataFrameGroupBy.corrwith
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.corrwith.html
DataFrameGroupBy.corrwith(other, axis=_NoDefault.no_default, drop=False, method='pearson', numeric_only=False)
计算成对相关性。
在计算相关性之前，首先沿着两个轴对齐 DataFrame 的行或列与 Series 或 DataFrame 的行或列。
参数：
otherDataFrame，Series
用于计算相关性的对象。
axis，默认为 0
要使用的轴。0 或‘index’表示按行计算，1 或‘columns’表示按列计算。
dropbool，默认为 False
从结果中删除缺失的索引。
method 或可调用对象
相关性方法：
-
pearson：标准相关系数
-
kendall：肯德尔 Tau 相关系数
-
spearman：斯皮尔曼等级相关性
-
callable：具有两个 1d ndarrays 输入的可调用对象
并返回一个浮点数。
numeric_onlybool，默认为 False
仅包括浮点数、整数或布尔值数据。
在 1.5.0 版本中新增。
在 2.0.0 版本中更改：numeric_only的默认值现在为False。
返回：
Series
成对相关性。
另请参阅
DataFrame.corr
计算列之间的成对相关性。
示例
>>> index = ["a", "b", "c", "d", "e"]
>>> columns = ["one", "two", "three", "four"]
>>> df1 = pd.DataFrame(np.arange(20).reshape(5, 4), index=index, columns=columns)
>>> df2 = pd.DataFrame(np.arange(16).reshape(4, 4), index=index[:4], columns=columns)
>>> df1.corrwith(df2)
one 1.0
two 1.0
three 1.0
four 1.0
dtype: float64
>>> df2.corrwith(df1, axis=1)
a 1.0
b 1.0
c 1.0
d 1.0
e NaN
dtype: float64
pandas.core.groupby.DataFrameGroupBy.count
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.count.html
DataFrameGroupBy.count()
计算组的计数，不包括缺失值。
返回：
Series 或 DataFrame
每个组内值的计数。
另请参阅
Series.groupby
对 Series 应用一个分组函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用一个分组函数。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b']
>>> ser = pd.Series([1, 2, np.nan], index=lst)
>>> ser
a 1.0
a 2.0
b NaN
dtype: float64
>>> ser.groupby(level=0).count()
a 2
b 0
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, np.nan, 3], [1, np.nan, 6], [7, 8, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["cow", "horse", "bull"])
>>> df
a b c
cow 1 NaN 3
horse 1 NaN 6
bull 7 8.0 9
>>> df.groupby("a").count()
b c
a
1 0 2
7 1 1
对于 Resampler：
>>> ser = pd.Series([1, 2, 3, 4], index=pd.DatetimeIndex(
... ['2023-01-01', '2023-01-15', '2023-02-01', '2023-02-15']))
>>> ser
2023-01-01 1
2023-01-15 2
2023-02-01 3
2023-02-15 4
dtype: int64
>>> ser.resample('MS').count()
2023-01-01 2
2023-02-01 2
Freq: MS, dtype: int64
pandas.core.groupby.DataFrameGroupBy.cov
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.cov.html
DataFrameGroupBy.cov(min_periods=None, ddof=1, numeric_only=False)
计算列的成对协方差，排除 NA/null 值。
计算 DataFrame 中系列之间的成对协方差。返回的数据帧是 DataFrame 列的协方差矩阵。
计算时会自动排除 NA 和 null 值（有关缺失值偏差的注意事项请参见下面的说明）。可以为每个创建的值设置最小观测次数的阈值。对于低于此阈值的观测值的比较将返回为NaN。
该方法通常用于分析时间序列数据，以了解不同测量值之间随时间的关系。
参数：
min_periodsint，可选
每对列所需的最小观测次数以获得有效结果。
ddofint，默认为 1
Delta 自由度。计算中使用的除数是N - ddof，其中N表示元素数量。当数据框中没有nan时，此参数才适用。
numeric_onlybool，默认为 False
仅包括浮点数、整数或布尔数据。
新版本 1.5.0 中新增。
2.0.0 版本更改：numeric_only的默认值现在为False。
返回：
DataFrame
DataFrame 系列的协方差矩阵。
另请参见
Series.cov
与另一个序列计算协方差。
core.window.ewm.ExponentialMovingWindow.cov
指数加权样本协方差。
core.window.expanding.Expanding.cov
扩展样本协方差。
core.window.rolling.Rolling.cov
滚动样本协方差。
注意
返回 DataFrame 时间序列的协方差矩阵。协方差由 N-ddof 标准化。
对于具有缺失数据的 Series 的 DataFrames（假设数据是随机缺失的），返回的协方差矩阵将是成员 Series 之间方差和协方差的无偏估计。
然而，对于许多应用程序，这种估计可能不可接受，因为估计的协方差矩阵不能保证是正半定的。这可能导致估计的相关性具有绝对值大于一，和/或不可逆的协方差矩阵。有关更多详细信息，请参见协方差矩阵的估计。
示例
>>> df = pd.DataFrame([(1, 2), (0, 3), (2, 0), (1, 1)],
... columns=['dogs', 'cats'])
>>> df.cov()
dogs cats
dogs 0.666667 -1.000000
cats -1.000000 1.666667
>>> np.random.seed(42)
>>> df = pd.DataFrame(np.random.randn(1000, 5),
... columns=['a', 'b', 'c', 'd', 'e'])
>>> df.cov()
a b c d e
a 0.998438 -0.020161 0.059277 -0.008943 0.014144
b -0.020161 1.059352 -0.008543 -0.024738 0.009826
c 0.059277 -0.008543 1.010670 -0.001486 -0.000271
d -0.008943 -0.024738 -0.001486 0.921297 -0.013692
e 0.014144 0.009826 -0.000271 -0.013692 0.977795
最小周期数
该方法还支持一个可选的min_periods关键字，指定每个列对中所需的非 NA 观测的最小数量以获得有效结果：
>>> np.random.seed(42)
>>> df = pd.DataFrame(np.random.randn(20, 3),
... columns=['a', 'b', 'c'])
>>> df.loc[df.index[:5], 'a'] = np.nan
>>> df.loc[df.index[5:10], 'b'] = np.nan
>>> df.cov(min_periods=12)
a b c
a 0.316741 NaN -0.150812
b NaN 1.248003 0.191417
c -0.150812 0.191417 0.895202
pandas.core.groupby.DataFrameGroupBy.cumcount
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.cumcount.html
DataFrameGroupBy.cumcount(ascending=True)
对每个组中的每个项目进行编号，从 0 到该组的长度-1。
本质上等同于
self.apply(lambda x: pd.Series(np.arange(len(x)), x.index))
参数：
ascending布尔值，默认为 True
如果为 False，则从组的长度-1 到 0 进行编号。
返回：
Series
每个元素在每个组内的序号。
另请参阅
ngroup
对组本身进行编号。
示例
>>> df = pd.DataFrame([['a'], ['a'], ['a'], ['b'], ['b'], ['a']],
... columns=['A'])
>>> df
A
0 a
1 a
2 a
3 b
4 b
5 a
>>> df.groupby('A').cumcount()
0 0
1 1
2 2
3 0
4 1
5 3
dtype: int64
>>> df.groupby('A').cumcount(ascending=False)
0 3
1 2
2 1
3 1
4 0
5 0
dtype: int64
pandas.core.groupby.DataFrameGroupBy.cummax
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.cummax.html
DataFrameGroupBy.cummax(axis=_NoDefault.no_default, numeric_only=False, **kwargs)
每个组的累积最大值。
返回：
Series 或 DataFrame
参见
Series.groupby
对 Series 应用一个 groupby 函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用一个 groupby 函数。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([1, 6, 2, 3, 1, 4], index=lst)
>>> ser
a 1
a 6
a 2
b 3
b 1
b 4
dtype: int64
>>> ser.groupby(level=0).cummax()
a 1
a 6
a 6
b 3
b 3
b 4
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 1, 0], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["cow", "horse", "bull"])
>>> df
a b c
cow 1 8 2
horse 1 1 0
bull 2 6 9
>>> df.groupby("a").groups
{1: ['cow', 'horse'], 2: ['bull']}
>>> df.groupby("a").cummax()
b c
cow 8 2
horse 8 2
bull 6 9
pandas.core.groupby.DataFrameGroupBy.cummin
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.cummin.html
DataFrameGroupBy.cummin(axis=_NoDefault.no_default, numeric_only=False, **kwargs)
每个组的累积最小值。
返回：
Series 或 DataFrame
另请参阅
Series.groupby
将函数 groupby 应用于 Series。
DataFrame.groupby
将函数 groupby 应用于 DataFrame 的每一行或列。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([1, 6, 2, 3, 0, 4], index=lst)
>>> ser
a 1
a 6
a 2
b 3
b 0
b 4
dtype: int64
>>> ser.groupby(level=0).cummin()
a 1
a 1
a 1
b 3
b 0
b 0
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 0, 2], [1, 1, 5], [6, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["snake", "rabbit", "turtle"])
>>> df
a b c
snake 1 0 2
rabbit 1 1 5
turtle 6 6 9
>>> df.groupby("a").groups
{1: ['snake', 'rabbit'], 6: ['turtle']}
>>> df.groupby("a").cummin()
b c
snake 0 2
rabbit 0 2
turtle 6 9
pandas.core.groupby.DataFrameGroupBy.cumprod
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.cumprod.html
DataFrameGroupBy.cumprod(axis=_NoDefault.no_default, *args, **kwargs)
每个组的累积乘积。
返回：
Series 或 DataFrame
另请参见
Series.groupby
对 Series 应用函数 groupby。
DataFrame.groupby
对 DataFrame 的每一行或列应用函数 groupby。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b']
>>> ser = pd.Series([6, 2, 0], index=lst)
>>> ser
a 6
a 2
b 0
dtype: int64
>>> ser.groupby(level=0).cumprod()
a 6
a 12
b 0
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 2, 5], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["cow", "horse", "bull"])
>>> df
a b c
cow 1 8 2
horse 1 2 5
bull 2 6 9
>>> df.groupby("a").groups
{1: ['cow', 'horse'], 2: ['bull']}
>>> df.groupby("a").cumprod()
b c
cow 8 2
horse 16 10
bull 6 9
pandas.core.groupby.DataFrameGroupBy.cumsum
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.cumsum.html
DataFrameGroupBy.cumsum(axis=_NoDefault.no_default, *args, **kwargs)
每个组的累积总和。
返回：
Series 或 DataFrame
另请参见
Series.groupby
将函数应用于 Series 进行分组。
DataFrame.groupby
将函数应用于 DataFrame 的每一行或每一列进行分组。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b']
>>> ser = pd.Series([6, 2, 0], index=lst)
>>> ser
a 6
a 2
b 0
dtype: int64
>>> ser.groupby(level=0).cumsum()
a 6
a 8
b 0
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 2, 5], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["fox", "gorilla", "lion"])
>>> df
a b c
fox 1 8 2
gorilla 1 2 5
lion 2 6 9
>>> df.groupby("a").groups
{1: ['fox', 'gorilla'], 2: ['lion']}
>>> df.groupby("a").cumsum()
b c
fox 8 2
gorilla 10 7
lion 6 9
pandas.core.groupby.DataFrameGroupBy.describe
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.describe.html
DataFrameGroupBy.describe(percentiles=None, include=None, exclude=None)
生成描述性统计。
描述性统计包括总体倾向、分散和数据集分布的形状的总结，不包括NaN值。
分析数字和对象系列以及混合数据类型的DataFrame列集。输出将根据提供的内容而变化。有关更多详细信息，请参阅下面的说明。
参数：
percentiles数字的列表，可选
要包含在输出中的百分位数。所有值应介于 0 和 1 之间。默认值为[.25, .5, .75]，返回第 25、50 和 75 个百分位数。
include‘all’，数据类型的列表或 None（默认），可选
要包含在结果中的数据类型的白名单。对于Series，将被忽略。以下是选项：
-
‘all’：输入的所有列都将包含在输出中。
-
数据类型的列表：将结果限制为提供的数据类型。要将结果限制为数值类型，请提交
numpy.number。要将其限制为对象列，请提交numpy.object数据类型。字符串也可以以select_dtypes的方式使用（例如df.describe(include=['O'])）。要选择 pandas 分类列，请使用'category' -
None（默认）：结果将包括所有数值列。
exclude列表类的数据类型或 None（默认），可选
数据类型的黑名单，从结果中省略。对于Series，将被忽略。以下是选项：
-
数据类型的列表：从结果中排除提供的数据类型。要排除数值类型，请提交
numpy.number。要排除对象列，请提交数据类型numpy.object。字符串也可以以select_dtypes的方式使用（例如df.describe(exclude=['O'])）。要排除 pandas 分类列，请使用'category' -
None（默认）：结果将不排除任何内容。
返回：
Series 或 DataFrame
提供的 Series 或 Dataframe 的摘要统计信息。
另请参阅
DataFrame.count
计算非 NA/null 观测值的数量。
DataFrame.max
对象中的最大值。
DataFrame.min
对象中的最小值。
DataFrame.mean
值的均值。
DataFrame.std
观察值的标准偏差。
DataFrame.select_dtypes
包括/排除基于其 dtype 的列的 DataFrame 的子集。
注意
对于数值数据，结果的索引将包括count、mean、std、min、max以及较低的、50和较高的百分位数。默认情况下，较低的百分位数是25，较高的百分位数是75。50百分位数与中位数相同。
对于对象数据（例如字符串或时间戳），结果的索引将包括count、unique、top和freq。top是最常见的值。freq是最常见值的频率。时间戳还包括first和last项。
如果多个对象值具有最高计数，则count和top结果将从具有最高计数的值中任意选择。
对于通过DataFrame提供的混合数据类型，默认情况下仅返回数值列的分析结果。如果数据框只包含对象和分类数据而没有任何数值列，则默认情况下将返回对对象和分类列的分析结果。如果提供了include='all'作为选项，则结果将包括每种类型的属性的并集。
可以使用include和exclude参数来限制分析输出中分析的DataFrame中的哪些列。分析Series时会忽略这些参数。
例子
描述数值Series。
>>> s = pd.Series([1, 2, 3])
>>> s.describe()
count 3.0
mean 2.0
std 1.0
min 1.0
25% 1.5
50% 2.0
75% 2.5
max 3.0
dtype: float64
描述分类Series。
>>> s = pd.Series(['a', 'a', 'b', 'c'])
>>> s.describe()
count 4
unique 3
top a
freq 2
dtype: object
描述时间戳Series。
>>> s = pd.Series([
... np.datetime64("2000-01-01"),
... np.datetime64("2010-01-01"),
... np.datetime64("2010-01-01")
... ])
>>> s.describe()
count 3
mean 2006-09-01 08:00:00
min 2000-01-01 00:00:00
25% 2004-12-31 12:00:00
50% 2010-01-01 00:00:00
75% 2010-01-01 00:00:00
max 2010-01-01 00:00:00
dtype: object
描述DataFrame。默认情况下，仅返回数值字段。
>>> df = pd.DataFrame({'categorical': pd.Categorical(['d', 'e', 'f']),
... 'numeric': [1, 2, 3],
... 'object': ['a', 'b', 'c']
... })
>>> df.describe()
numeric
count 3.0
mean 2.0
std 1.0
min 1.0
25% 1.5
50% 2.0
75% 2.5
max 3.0
不考虑数据类型，描述DataFrame的所有列。
>>> df.describe(include='all')
categorical numeric object
count 3 3.0 3
unique 3 NaN 3
top f NaN a
freq 1 NaN 1
mean NaN 2.0 NaN
std NaN 1.0 NaN
min NaN 1.0 NaN
25% NaN 1.5 NaN
50% NaN 2.0 NaN
75% NaN 2.5 NaN
max NaN 3.0 NaN
通过将其作为属性访问来描述DataFrame的列。
>>> df.numeric.describe()
count 3.0
mean 2.0
std 1.0
min 1.0
25% 1.5
50% 2.0
75% 2.5
max 3.0
Name: numeric, dtype: float64
仅在DataFrame描述中包含数值列。
>>> df.describe(include=[np.number])
numeric
count 3.0
mean 2.0
std 1.0
min 1.0
25% 1.5
50% 2.0
75% 2.5
max 3.0
仅在DataFrame描述中包含字符串列。
>>> df.describe(include=[object])
object
count 3
unique 3
top a
freq 1
仅从DataFrame描述中包含分类列。
>>> df.describe(include=['category'])
categorical
count 3
unique 3
top d
freq 1
从DataFrame描述中排除数值列。
>>> df.describe(exclude=[np.number])
categorical object
count 3 3
unique 3 3
top f a
freq 1 1
从DataFrame描述中排除对象列。
>>> df.describe(exclude=[object])
categorical numeric
count 3 3.0
unique 3 NaN
top f NaN
freq 1 NaN
mean NaN 2.0
std NaN 1.0
min NaN 1.0
25% NaN 1.5
50% NaN 2.0
75% NaN 2.5
max NaN 3.0
pandas.core.groupby.DataFrameGroupBy.diff
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.diff.html
DataFrameGroupBy.diff(periods=1, axis=_NoDefault.no_default)
元素的第一个离散差异。
计算与组中另一个元素相比的每个元素的差异（默认为前一行中的元素）。
参数：
periodsint，默认为 1
偏移量用于计算差异，接受负值。
axis偏移的轴，默认为 0
对行（0）或列（1）进行差异计算。
从版本 2.1.0 开始不推荐使用：对于 axis=1，应该对基础对象进行操作。否则，axis 关键字是不必要的。
返回：
Series 或 DataFrame
第一次差异。
另请参阅
Series.groupby
将函数应用于 Series 的 groupby。
DataFrame.groupby
将函数应用于 DataFrame 的每一行或列。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
>>> ser
a 7
a 2
a 8
b 4
b 3
b 3
dtype: int64
>>> ser.groupby(level=0).diff()
a NaN
a -5.0
a 6.0
b NaN
b -1.0
b 0.0
dtype: float64
对于 DataFrameGroupBy：
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
... 'mouse', 'mouse', 'mouse', 'mouse'])
>>> df
a b
dog 1 1
dog 3 4
dog 5 8
mouse 7 4
mouse 7 4
mouse 8 2
mouse 3 1
>>> df.groupby(level=0).diff()
a b
dog NaN NaN
dog 2.0 3.0
dog 2.0 4.0
mouse NaN NaN
mouse 0.0 0.0
mouse 1.0 -2.0
mouse -5.0 -1.0
pandas.core.groupby.DataFrameGroupBy.ffill
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.ffill.html
DataFrameGroupBy.ffill(limit=None)
前向填充数值。
参数：
limitint，可选
填充数值的限制。
返回：
Series 或 DataFrame
填充了缺失值的对象。
另请参阅
Series.ffill
返回具有对象中最小字符数的 Series。
DataFrame.ffill
填充了缺失值的对象，如果 inplace=True，则返回 None。
Series.fillna
填充 Series 的 NaN 值。
DataFrame.fillna
填充 DataFrame 的 NaN 值。
示例
对于 SeriesGroupBy：
>>> key = [0, 0, 1, 1]
>>> ser = pd.Series([np.nan, 2, 3, np.nan], index=key)
>>> ser
0 NaN
0 2.0
1 3.0
1 NaN
dtype: float64
>>> ser.groupby(level=0).ffill()
0 NaN
0 2.0
1 3.0
1 3.0
dtype: float64
对于 DataFrameGroupBy：
>>> df = pd.DataFrame(
... {
... "key": [0, 0, 1, 1, 1],
... "A": [np.nan, 2, np.nan, 3, np.nan],
... "B": [2, 3, np.nan, np.nan, np.nan],
... "C": [np.nan, np.nan, 2, np.nan, np.nan],
... }
... )
>>> df
key A B C
0 0 NaN 2.0 NaN
1 0 2.0 3.0 NaN
2 1 NaN NaN 2.0
3 1 3.0 NaN NaN
4 1 NaN NaN NaN
在每个组沿列内向前或向后传播非空值。
>>> df.groupby("key").ffill()
A B C
0 NaN 2.0 NaN
1 2.0 3.0 NaN
2 NaN NaN 2.0
3 3.0 NaN 2.0
4 3.0 NaN 2.0
在每个组沿行内向前或向后传播非空值。
>>> df.T.groupby(np.array([0, 0, 1, 1])).ffill().T
key A B C
0 0.0 0.0 2.0 2.0
1 0.0 2.0 3.0 3.0
2 1.0 1.0 NaN 2.0
3 1.0 3.0 NaN NaN
4 1.0 1.0 NaN NaN
仅替换每组沿行的第一个 NaN 元素。
>>> df.groupby("key").ffill(limit=1)
A B C
0 NaN 2.0 NaN
1 2.0 3.0 NaN
2 NaN NaN 2.0
3 3.0 NaN 2.0
4 3.0 NaN NaN
pandas.core.groupby.DataFrameGroupBy.fillna
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.fillna.html
DataFrameGroupBy.fillna(value=None, method=None, axis=_NoDefault.no_default, inplace=False, limit=None, downcast=_NoDefault.no_default)
使用指定方法在组内填充 NA/NaN 值。
自版本 2.2.0 起弃用：此方法已弃用，并将在将来的版本中删除。请改用DataFrameGroupBy.ffill()或DataFrameGroupBy.bfill()进行向前或向后填充。如果要使用单个值进行填充，请改用DataFrame.fillna()。
参数：
value标量，字典，Series 或 DataFrame
用于填充空缺值的值（例如 0），或者一个指定每个索引（对于 Series）或列（对于 DataFrame）使用哪个值的值的字典/Series/DataFrame。不在字典/Series/DataFrame 中的值将不被填充。此值不能是列表。想要使用value参数而不是method的用户应该优先使用DataFrame.fillna()，因为这将产生相同的结果并且更有效率。
method{{‘bfill’, ‘ffill’, None}}，默认为 None
用于填充空缺值的方法。'ffill'将在一组内向前传播最后一个有效观察值。'bfill'将使用下一个有效观察值来填补间隙。
axis
用于填充缺失值的轴。当DataFrameGroupBy的axis参数为0时，在这里使用axis=1将产生与DataFrame.fillna()相同的结果。当DataFrameGroupBy的axis参数为1时，在这里使用axis=0或axis=1将产生相同的结果。
inplace布尔值，默认为 False
已损坏。不要设置为 True。
limit整数，默认为 None
如果指定了方法，这是在一组内向前/向后填充的最大连续 NaN 值的数量。换句话说，如果有超过这个数量的连续 NaN 值的间隙，它将只被部分填充。如果未指定方法，则这是整个轴上将填充 NaN 的最大条目数。如果不是 None，则必须大于 0。
downcast字典，默认为 None
一个项目->如果可能的话要降级的 dtype 的字典，或者字符串‘infer’，它将尝试降级到适当的相等类型（例如，如果可能的话，从 float64 到 int64）。
返回值：
DataFrame
用缺失值填充的对象。
另请参阅
ffill
在一组内向前填充值。
bfill
在每个组内向后填充数值。
示例
>>> df = pd.DataFrame(
... {
... "key": [0, 0, 1, 1, 1],
... "A": [np.nan, 2, np.nan, 3, np.nan],
... "B": [2, 3, np.nan, np.nan, np.nan],
... "C": [np.nan, np.nan, 2, np.nan, np.nan],
... }
... )
>>> df
key A B C
0 0 NaN 2.0 NaN
1 0 2.0 3.0 NaN
2 1 NaN NaN 2.0
3 1 3.0 NaN NaN
4 1 NaN NaN NaN
在每个组内沿着列向前或向后传播非空值。
>>> df.groupby("key").fillna(method="ffill")
A B C
0 NaN 2.0 NaN
1 2.0 3.0 NaN
2 NaN NaN 2.0
3 3.0 NaN 2.0
4 3.0 NaN 2.0
>>> df.groupby("key").fillna(method="bfill")
A B C
0 2.0 2.0 NaN
1 2.0 3.0 NaN
2 3.0 NaN 2.0
3 3.0 NaN NaN
4 NaN NaN NaN
在每个组内沿着行向前或向后传播非空值。
>>> df.T.groupby(np.array([0, 0, 1, 1])).fillna(method="ffill").T
key A B C
0 0.0 0.0 2.0 2.0
1 0.0 2.0 3.0 3.0
2 1.0 1.0 NaN 2.0
3 1.0 3.0 NaN NaN
4 1.0 1.0 NaN NaN
>>> df.T.groupby(np.array([0, 0, 1, 1])).fillna(method="bfill").T
key A B C
0 0.0 NaN 2.0 NaN
1 0.0 2.0 3.0 NaN
2 1.0 NaN 2.0 2.0
3 1.0 3.0 NaN NaN
4 1.0 NaN NaN NaN
仅在每个组内沿着行替换第一个 NaN 元素。
>>> df.groupby("key").fillna(method="ffill", limit=1)
A B C
0 NaN 2.0 NaN
1 2.0 3.0 NaN
2 NaN NaN 2.0
3 3.0 NaN 2.0
4 3.0 NaN NaN
pandas.core.groupby.DataFrameGroupBy.first
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.first.html
DataFrameGroupBy.first(numeric_only=False, min_count=-1, skipna=True)
计算每个组内每列的第一个条目。
默认跳过 NA 元素。
参数：
numeric_only 布尔值，默认为 False
仅包括浮点数、整数、布尔值列。
min_count 整数，默认为 -1
执行操作所需的有效值数量。如果少于 min_count 个有效值，则结果将为 NA。
skipna 布尔值，默认为 True
排除 NA/null 值。如果整行/列都是 NA，则结果将为 NA。
版本 2.2.1 中的新功能。
返回：
Series 或 DataFrame
每个组内的第一个值。
另请参见
DataFrame.groupby
对 DataFrame 的每一行或列应用 groupby 函数。
pandas.core.groupby.DataFrameGroupBy.last
计算每列的最后一个非空条目。
pandas.core.groupby.DataFrameGroupBy.nth
从每个组中取第 n 行。
示例
>>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[None, 5, 6], C=[1, 2, 3],
... D=['3/11/2000', '3/12/2000', '3/13/2000']))
>>> df['D'] = pd.to_datetime(df['D'])
>>> df.groupby("A").first()
B C D
A
1 5.0 1 2000-03-11
3 6.0 3 2000-03-13
>>> df.groupby("A").first(min_count=2)
B C D
A
1 NaN 1.0 2000-03-11
3 NaN NaN NaT
>>> df.groupby("A").first(numeric_only=True)
B C
A
1 5.0 1
3 6.0 3
pandas.core.groupby.DataFrameGroupBy.head
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.head.html
DataFrameGroupBy.head(n=5)
返回每个组的前 n 行。
类似于.apply(lambda x: x.head(n))，但它返回原始数据框的子集，保留原始索引和顺序（as_index标志被忽略）。
参数：
nint
如果为正：从每个组的开头包括的条目数。如果为负：从每个组的末尾排除的条目数。
返回：
序列或数据框
原始序列或数据框的子集，由 n 确定。
另请参阅
Series.groupby
将函数groupby应用于一个序列。
DataFrame.groupby
将函数groupby应用于数据框的每一行或列。
示例
>>> df = pd.DataFrame([[1, 2], [1, 4], [5, 6]],
... columns=['A', 'B'])
>>> df.groupby('A').head(1)
A B
0 1 2
2 5 6
>>> df.groupby('A').head(-1)
A B
0 1 2
pandas.core.groupby.DataFrameGroupBy.idxmax
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.idxmax.html
DataFrameGroupBy.idxmax(axis=_NoDefault.no_default, skipna=True, numeric_only=False)
返回所请求轴上最大值的第一个出现的索引。
排除 NA/null 值。
参数：
axis{{0 或 ‘index’，1 或 ‘columns’}}，默认为 None
要使用的轴。0 或 ‘index’ 表示逐行，1 或 ‘columns’ 表示逐列。如果未提供轴，则使用 grouper 的轴。
在版本 2.0.0 中更改。
自版本 2.1.0 起弃用：对于 axis=1，请在基础对象上操作。否则，不需要轴关键字。
skipnabool，默认为 True
排除 NA/null 值。如果整行/列都是 NA，则结果为 NA。
numeric_onlybool，默认为 False
仅包括浮点、整数或布尔数据。
新版本 1.5.0 中新增。
返回：
系列
沿指定轴的最大值的索引。
引发：
值错误
- 如果行/列为空
另请参见
Series.idxmax
返回最大元素的索引。
注释
这个方法是 ndarray.argmax 的 DataFrame 版本。
示例
考虑一个包含阿根廷食物消费的数据集。
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
... 'co2_emissions': [37.2, 19.66, 1712]},
... index=['Pork', 'Wheat Products', 'Beef'])
>>> df
consumption co2_emissions
Pork 10.51 37.20
Wheat Products 103.11 19.66
Beef 55.48 1712.00
默认情况下，它返回每列中最大值的索引。
>>> df.idxmax()
consumption Wheat Products
co2_emissions Beef
dtype: object
要返回每行中最大值的索引，请使用 axis="columns"。
>>> df.idxmax(axis="columns")
Pork co2_emissions
Wheat Products consumption
Beef co2_emissions
dtype: object
pandas.core.groupby.DataFrameGroupBy.idxmin
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.idxmin.html
DataFrameGroupBy.idxmin(axis=_NoDefault.no_default, skipna=True, numeric_only=False)
返回请求轴上最小值的第一次出现的索引。
NA/空值被排除。
参数：
轴{{0 或 ‘index’，1 或 ‘columns’}}，默认为 None
要使用的轴。0 或 ‘index’ 代表按行，1 或 ‘columns’ 代表按列。如果未提供轴，则使用分组器的轴。
自版本 2.0.0 更改。
自版本 2.1.0 弃用：对于 axis=1，请在基础对象上进行操作。否则，axis 关键字不是必需的。
skipna布尔值，默认为 True
排除 NA/空值。如果整行/列都是 NA，则结果将为 NA。
numeric_only布尔值，默认为 False
只包括浮点数、整数或布尔值数据。
自版本 1.5.0 新增。
返回：
系列
沿指定轴的最小值的索引。
抛出：
值错误
- 如果行/列为空
另请参见
Series.idxmin
返回最小元素的索引。
注意事项
此方法是 ndarray.argmin 的 DataFrame 版本。
示例
考虑一个包含阿根廷食物消耗的数据集。
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
... 'co2_emissions': [37.2, 19.66, 1712]},
... index=['Pork', 'Wheat Products', 'Beef'])
>>> df
consumption co2_emissions
Pork 10.51 37.20
Wheat Products 103.11 19.66
Beef 55.48 1712.00
默认情况下，返回每列中最小值的索引。
>>> df.idxmin()
consumption Pork
co2_emissions Wheat Products
dtype: object
要返回每行中最小值的索引，请使用 axis="columns"。
>>> df.idxmin(axis="columns")
Pork consumption
Wheat Products co2_emissions
Beef consumption
dtype: object
pandas.core.groupby.DataFrameGroupBy.last
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.last.html
DataFrameGroupBy.last(numeric_only=False, min_count=-1, skipna=True)
计算每个组内每列的最后一个条目。
默认跳过 NA 元素。
参数：
numeric_only布尔值，默认为 False
仅包括浮点数、整数和布尔值列。如果为 None，则尝试使用所有内容，然后仅使用数值数据。
min_count整数，默认值为-1
执行操作所需的有效值的数量。如果存在少于min_count个有效值，则结果将为 NA。
skipna布尔值，默认为 True
排除 NA/null 值。如果整个行/列为 NA，则结果将为 NA。
在版本 2.2.1 中新增。
返回：
Series 或 DataFrame
每个组内的最后数值。
另请参阅
DataFrame.groupby
对 DataFrame 的每行或列应用一个 groupby 函数。
pandas.core.groupby.DataFrameGroupBy.first
计算每列的第一个非空条目。
pandas.core.groupby.DataFrameGroupBy.nth
从每个组中获取第 n 行。
示例
>>> df = pd.DataFrame(dict(A=[1, 1, 3], B=[5, None, 6], C=[1, 2, 3]))
>>> df.groupby("A").last()
B C
A
1 5.0 2
3 6.0 3
pandas.core.groupby.DataFrameGroupBy.max
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.max.html
DataFrameGroupBy.max(numeric_only=False, min_count=-1, engine=None, engine_kwargs=None)
计算组值的最大值。
参数：
numeric_only布尔型，默认为 False。
仅包含浮点、整数、布尔列。
在 2.0.0 版本中更改：numeric_only不再接受None。
min_count整数，默认为-1。
执行操作所需的有效值数量。如果少于min_count个非 NA 值，则结果将为 NA。
engine字符串，默认为 None None。
-
'cython'：通过 C 扩展运行滚动应用。 -
'numba'通过 JIT 编译的代码运行滚动应用。仅在
raw设置为True时可用。 -
None：默认为'cython'或全局设置compute.use_numba。
engine_kwargs字典，默认为 None None。
-
对于
'cython'引擎，不接受engine_kwargs。 -
对于
'numba'引擎，引擎可以接受nopython、nogil。和
parallel字典键。值必须为True或False。'numba'引擎的默认engine_kwargs为{'nopython': True, 'nogil': False, 'parallel': False}，将应用于func和apply分组聚合。
返回：
Series 或 DataFrame
每个组内值的最大值。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
>>> ser
a 1
a 2
b 3
b 4
dtype: int64
>>> ser.groupby(level=0).max()
a 2
b 4
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tiger", "leopard", "cheetah", "lion"])
>>> df
a b c
tiger 1 8 2
leopard 1 2 5
cheetah 2 5 8
lion 2 6 9
>>> df.groupby("a").max()
b c
a
1 8 5
2 6 9
pandas.core.groupby.DataFrameGroupBy.mean
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.mean.html
DataFrameGroupBy.mean(numeric_only=False, engine=None, engine_kwargs=None)
计算组的平均值，不包括缺失值。
参数：
numeric_onlybool，默认为 False
仅包括浮点数、整数、布尔值列。
在版本 2.0.0 中更改：numeric_only 不再接受None，默认为False。
enginestr，默认为 None
-
'cython'：通过 cython 的 C 扩展运行操作。 -
'numba'：通过 numba 的 JIT 编译代码运行操作。 -
None：默认为'cython'或全局设置compute.use_numba
新版本 1.4.0 中新增。
engine_kwargsdict，默认为 None
-
对于
'cython'引擎，没有接受的engine_kwargs。 -
对于
'numba'引擎，引擎可以接受nopython、nogil和parallel字典键。值必须是True或False。'numba'引擎的默认engine_kwargs是{{'nopython': True, 'nogil': False, 'parallel': False}}
新版本 1.4.0 中新增。
返回：
pandas.Series 或 pandas.DataFrame
另请参阅
Series.groupby
对 Series 应用 groupby 函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用 groupby 函数。
示例
>>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
... 'B': [np.nan, 2, 3, 4, 5],
... 'C': [1, 2, 1, 1, 2]}, columns=['A', 'B', 'C'])
按一列分组，并返回每个组中剩余列的平均值。
>>> df.groupby('A').mean()
B C
A
1 3.0 1.333333
2 4.0 1.500000
按两列分组，并返回剩余列的平均值。
>>> df.groupby(['A', 'B']).mean()
C
A B
1 2.0 2.0
4.0 1.0
2 3.0 1.0
5.0 2.0
按一列分组，并返回组中特定列的平均值。
>>> df.groupby('A')['B'].mean()
A
1 3.0
2 4.0
Name: B, dtype: float64
pandas.core.groupby.DataFrameGroupBy.median
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.median.html
DataFrameGroupBy.median(numeric_only=False)
计算组的中位数，排除缺失值。
对于多个分组，结果索引将是一个 MultiIndex
参数：
numeric_onlybool，默认为 False
仅包括浮点数、整数、布尔值列。
在 2.0.0 版本中更改：numeric_only 不再接受None，默认为 False。
返回：
Series 或 DataFrame
每个组内值的中位数。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
>>> ser
a 7
a 2
a 8
b 4
b 3
b 3
dtype: int64
>>> ser.groupby(level=0).median()
a 7.0
b 3.0
dtype: float64
对于 DataFrameGroupBy：
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
... 'mouse', 'mouse', 'mouse', 'mouse'])
>>> df
a b
dog 1 1
dog 3 4
dog 5 8
mouse 7 4
mouse 7 4
mouse 8 2
mouse 3 1
>>> df.groupby(level=0).median()
a b
dog 3.0 4.0
mouse 7.0 3.0
对于 Resampler：
>>> ser = pd.Series([1, 2, 3, 3, 4, 5],
... index=pd.DatetimeIndex(['2023-01-01',
... '2023-01-10',
... '2023-01-15',
... '2023-02-01',
... '2023-02-10',
... '2023-02-15']))
>>> ser.resample('MS').median()
2023-01-01 2.0
2023-02-01 4.0
Freq: MS, dtype: float64
pandas.core.groupby.DataFrameGroupBy.min
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.min.html
DataFrameGroupBy.min(numeric_only=False, min_count=-1, engine=None, engine_kwargs=None)
计算组值的最小值。
参数：
numeric_onlybool，默认为 False
仅包括浮点数、整数、布尔值列。
在 2.0.0 版更改：numeric_only 不再接受 None。
min_countint，默认为 -1
执行操作所需的有效值的最小数量。如果少于 min_count 个非 NA 值存在，则结果将为 NA。
enginestr，默认为 None None
-
'cython'：通过 cython 中的 C 扩展运行滚动应用。 -
'numba'：通过 numba 中的 JIT 编译代码运行滚动应用。仅在
raw设置为True时可用。 -
None：默认为'cython'或全局设置compute.use_numba
engine_kwargsdict，默认为 None None
-
对于
'cython'引擎，不接受engine_kwargs -
对于
'numba'引擎，该引擎可以接受nopython，nogil和
parallel字典键。值必须为True或False。'numba'引擎的默认engine_kwargs为{'nopython': True, 'nogil': False, 'parallel': False}，将应用于func和applygroupby 聚合。
返回：
Series 或 DataFrame
计算每个组内的值的最小值。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
>>> ser
a 1
a 2
b 3
b 4
dtype: int64
>>> ser.groupby(level=0).min()
a 1
b 3
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tiger", "leopard", "cheetah", "lion"])
>>> df
a b c
tiger 1 8 2
leopard 1 2 5
cheetah 2 5 8
lion 2 6 9
>>> df.groupby("a").min()
b c
a
1 2 2
2 5 8
pandas.core.groupby.DataFrameGroupBy.ngroup
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.ngroup.html
DataFrameGroupBy.ngroup(ascending=True)
为每个组编号从 0 到组数 - 1。
这是 cumcount 的枚举补充。请注意，给定给组的数字与在迭代 groupby 对象时将看到组的顺序相匹配，而不是它们首次观察到的顺序。
具有缺失键的组（其中 pd.isna() 为 True）将被标记为 NaN，并且将从计数中跳过。
参数：
ascending 布尔值，默认为 True
如果为 False，则从组数 - 1 到 0 逆向编号。
返回：
Series
每个组的唯一编号。
参见
cumcount
对每个组中的行进行编号。
示例
>>> df = pd.DataFrame({"color": ["red", None, "red", "blue", "blue", "red"]})
>>> df
color
0 red
1 None
2 red
3 blue
4 blue
5 red
>>> df.groupby("color").ngroup()
0 1.0
1 NaN
2 1.0
3 0.0
4 0.0
5 1.0
dtype: float64
>>> df.groupby("color", dropna=False).ngroup()
0 1
1 2
2 1
3 0
4 0
5 1
dtype: int64
>>> df.groupby("color", dropna=False).ngroup(ascending=False)
0 1
1 0
2 1
3 2
4 2
5 1
dtype: int64
pandas.core.groupby.DataFrameGroupBy.nth
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.nth.html
property DataFrameGroupBy.nth
如果 n 是 int，则从每个组中取第 n 行，否则是行的子集。
可以是调用或索引。 dropna 在索引表示法中不可用。 索引表示法接受逗号分隔的整数和切片列表。
如果 dropna，则取第 n 个非空行，dropna 要么是 'all' 要么是 'any'； 这相当于在 groupby 之前调用 dropna(how=dropna)。
参数：
n int、slice 或 int 和 slice 列表
行的单个 nth 值或 nth 值或切片列表。
在 1.4.0 版中更改：添加了切片和包含切片的列表。 添加了索引表示法。
dropna {'any'、'all'、None}，默认为 None
在计算第 n 行是应用指定的 dropna 操作。 仅在 n 是 int 时支持。
返回：
Series 或 DataFrame
每个组中的第 n 个值。
参见
Series.groupby
对 Series 应用 groupby 函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用指定的 groupby 函数。
示例
>>> df = pd.DataFrame({'A': [1, 1, 2, 1, 2],
... 'B': [np.nan, 2, 3, 4, 5]}, columns=['A', 'B'])
>>> g = df.groupby('A')
>>> g.nth(0)
A B
0 1 NaN
2 2 3.0
>>> g.nth(1)
A B
1 1 2.0
4 2 5.0
>>> g.nth(-1)
A B
3 1 4.0
4 2 5.0
>>> g.nth([0, 1])
A B
0 1 NaN
1 1 2.0
2 2 3.0
4 2 5.0
>>> g.nth(slice(None, -1))
A B
0 1 NaN
1 1 2.0
2 2 3.0
也可以使用索引表示法
>>> g.nth[0, 1]
A B
0 1 NaN
1 1 2.0
2 2 3.0
4 2 5.0
>>> g.nth[:-1]
A B
0 1 NaN
1 1 2.0
2 2 3.0
指定 dropna 允许忽略 NaN 值
>>> g.nth(0, dropna='any')
A B
1 1 2.0
2 2 3.0
当指定的 n 大于任何一个组时，返回一个空的 DataFrame
>>> g.nth(3, dropna='any')
Empty DataFrame
Columns: [A, B]
Index: []
pandas.core.groupby.DataFrameGroupBy.nunique
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.nunique.html
DataFrameGroupBy.nunique(dropna=True)
返回一个 DataFrame，其中包含每个位置唯一元素的计数。
参数：
dropna 布尔值，默认为 True
不包括 NaN 在计数中。
返回：
nunique：DataFrame
示例
>>> df = pd.DataFrame({'id': ['spam', 'egg', 'egg', 'spam',
... 'ham', 'ham'],
... 'value1': [1, 5, 5, 2, 5, 5],
... 'value2': list('abbaxy')})
>>> df
id value1 value2
0 spam 1 a
1 egg 5 b
2 egg 5 b
3 spam 2 a
4 ham 5 x
5 ham 5 y
>>> df.groupby('id').nunique()
value1 value2
id
egg 1 1
ham 1 2
spam 2 1
检查具有相同 id 但值冲突的行：
>>> df.groupby('id').filter(lambda g: (g.nunique() > 1).any())
id value1 value2
0 spam 1 a
3 spam 2 a
4 ham 5 x
5 ham 5 y
pandas.core.groupby.DataFrameGroupBy.ohlc
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.ohlc.html
DataFrameGroupBy.ohlc()
计算组的开盘价、最高价、最低价和收盘价值，不包括缺失值。
对于多个分组，结果索引将是一个 MultiIndex
返回：
DataFrame
每个组内的开盘价、最高价、最低价和收盘价值。
示例
对于 SeriesGroupBy：
>>> lst = ['SPX', 'CAC', 'SPX', 'CAC', 'SPX', 'CAC', 'SPX', 'CAC',]
>>> ser = pd.Series([3.4, 9.0, 7.2, 5.2, 8.8, 9.4, 0.1, 0.5], index=lst)
>>> ser
SPX 3.4
CAC 9.0
SPX 7.2
CAC 5.2
SPX 8.8
CAC 9.4
SPX 0.1
CAC 0.5
dtype: float64
>>> ser.groupby(level=0).ohlc()
open high low close
CAC 9.0 9.4 0.5 0.5
SPX 3.4 8.8 0.1 0.1
对于 DataFrameGroupBy：
>>> data = {2022: [1.2, 2.3, 8.9, 4.5, 4.4, 3, 2 , 1],
... 2023: [3.4, 9.0, 7.2, 5.2, 8.8, 9.4, 8.2, 1.0]}
>>> df = pd.DataFrame(data, index=['SPX', 'CAC', 'SPX', 'CAC',
... 'SPX', 'CAC', 'SPX', 'CAC'])
>>> df
2022 2023
SPX 1.2 3.4
CAC 2.3 9.0
SPX 8.9 7.2
CAC 4.5 5.2
SPX 4.4 8.8
CAC 3.0 9.4
SPX 2.0 8.2
CAC 1.0 1.0
>>> df.groupby(level=0).ohlc()
2022 2023
open high low close open high low close
CAC 2.3 4.5 1.0 1.0 9.0 9.4 1.0 1.0
SPX 1.2 8.9 1.2 2.0 3.4 8.8 3.4 8.2
对于 Resampler：
>>> ser = pd.Series([1, 3, 2, 4, 3, 5],
... index=pd.DatetimeIndex(['2023-01-01',
... '2023-01-10',
... '2023-01-15',
... '2023-02-01',
... '2023-02-10',
... '2023-02-15']))
>>> ser.resample('MS').ohlc()
open high low close
2023-01-01 1 3 1 2
2023-02-01 4 5 3 5
pandas.core.groupby.DataFrameGroupBy.pct_change
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.pct_change.html
DataFrameGroupBy.pct_change(periods=1, fill_method=_NoDefault.no_default, limit=_NoDefault.no_default, freq=None, axis=_NoDefault.no_default)
计算每个值相对于组内前一个条目的百分比变化。
返回：
Series 或 DataFrame
每个组内的百分比变化。
另请参见
Series.groupby
对 Series 应用函数 groupby。
DataFrame.groupby
对 DataFrame 的每一行或列应用函数 groupby。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
>>> ser
a 1
a 2
b 3
b 4
dtype: int64
>>> ser.groupby(level=0).pct_change()
a NaN
a 1.000000
b NaN
b 0.333333
dtype: float64
对于 DataFrameGroupBy：
>>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tuna", "salmon", "catfish", "goldfish"])
>>> df
a b c
tuna 1 2 3
salmon 1 5 6
catfish 2 5 8
goldfish 2 6 9
>>> df.groupby("a").pct_change()
b c
tuna NaN NaN
salmon 1.5 1.000
catfish NaN NaN
goldfish 0.2 0.125
pandas.core.groupby.DataFrameGroupBy.prod
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.prod.html
DataFrameGroupBy.prod(numeric_only=False, min_count=0)
计算组值的乘积。
参数：
numeric_onlybool，默认为 False
仅包括浮点数、整数、布尔值列。
从版本 2.0.0 开始更改：numeric_only 不再接受None。
min_countint，默认为 0
执行操作所需的有效值的最小数量。如果少于min_count个非 NA 值存在，则结果将为 NA。
返回：
Series 或 DataFrame
计算每个组内值的乇。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
>>> ser
a 1
a 2
b 3
b 4
dtype: int64
>>> ser.groupby(level=0).prod()
a 2
b 12
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tiger", "leopard", "cheetah", "lion"])
>>> df
a b c
tiger 1 8 2
leopard 1 2 5
cheetah 2 5 8
lion 2 6 9
>>> df.groupby("a").prod()
b c
a
1 16 10
2 30 72
pandas.core.groupby.DataFrameGroupBy.quantile
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.quantile.html
DataFrameGroupBy.quantile(q=0.5, interpolation='linear', numeric_only=False)
在给定分位数处返回组值，类似于 numpy.percentile。
参数：
qfloat 或类数组，默认为 0.5（50%分位数）
在 0 和 1 之间的值，提供要计算的分位数。
interpolation
当所需分位数介于两个点之间时使用的方法。
numeric_onlybool，默认为 False
仅包含浮点数、整数或布尔值数据。
在版本 1.5.0 中新增。
在版本 2.0.0 中更改：numeric_only 现在默认为False。
返回：
Series 或 DataFrame
返回类型由 GroupBy 对象的调用者确定。
请参阅
Series.quantile
类似的方法适用于 Series。
DataFrame.quantile
类似的方法适用于 DataFrame。
计算第 q 个百分位数的 NumPy 方法。
示例
>>> df = pd.DataFrame([
... ['a', 1], ['a', 2], ['a', 3],
... ['b', 1], ['b', 3], ['b', 5]
... ], columns=['key', 'val'])
>>> df.groupby('key').quantile()
val
key
a 2.0
b 3.0
pandas.core.groupby.DataFrameGroupBy.rank
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.rank.html
DataFrameGroupBy.rank(method='average', ascending=True, na_option='keep', pct=False, axis=_NoDefault.no_default)
提供每个组内值的排名。
参数：
method，默认为‘average’
-
average：组的平均等级。
-
min：组中的最低等级。
-
max：组中的最高等级。
-
first：按照它们在数组中出现的顺序分配等级。
-
dense：类似于‘min’，但在组之间等级始终增加 1。
ascendingbool，默认为 True
从高（1）到低（N）的等级为 False。
na_option，默认为‘keep’
-
keep：保留 NA 值在原位。
-
top：如果是升序，则为最小等级。
-
bottom：如果是降序，则为最小等级。
pctbool，默认为 False
计算数据在每个组内的百分比排名。
axisint，默认为 0
计算排名的对象的轴。
自版本 2.1.0 起弃用：对于 axis=1，应在基础对象上操作。否则，axis 关键字不是必需的。
返回：
每个组内值的排名的 DataFrame
另请参阅
Series.groupby
对 Series 应用分组函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用分组函数。
示例
>>> df = pd.DataFrame(
... {
... "group": ["a", "a", "a", "a", "a", "b", "b", "b", "b", "b"],
... "value": [2, 4, 2, 3, 5, 1, 2, 4, 1, 5],
... }
... )
>>> df
group value
0 a 2
1 a 4
2 a 2
3 a 3
4 a 5
5 b 1
6 b 2
7 b 4
8 b 1
9 b 5
>>> for method in ['average', 'min', 'max', 'dense', 'first']:
... df[f'{method}_rank'] = df.groupby('group')['value'].rank(method)
>>> df
group value average_rank min_rank max_rank dense_rank first_rank
0 a 2 1.5 1.0 2.0 1.0 1.0
1 a 4 4.0 4.0 4.0 3.0 4.0
2 a 2 1.5 1.0 2.0 1.0 2.0
3 a 3 3.0 3.0 3.0 2.0 3.0
4 a 5 5.0 5.0 5.0 4.0 5.0
5 b 1 1.5 1.0 2.0 1.0 1.0
6 b 2 3.0 3.0 3.0 2.0 3.0
7 b 4 4.0 4.0 4.0 3.0 4.0
8 b 1 1.5 1.0 2.0 1.0 2.0
9 b 5 5.0 5.0 5.0 4.0 5.0
pandas.core.groupby.DataFrameGroupBy.resample
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.resample.html
DataFrameGroupBy.resample(rule, *args, include_groups=True, **kwargs)
在使用 TimeGrouper 时提供重新采样。
给定一个分组器，该函数根据字符串“string”->“frequency”对其重新采样。
有关更多详情，请参阅 frequency aliases 文档。
参数：
rulestr 或 DateOffset
偏移字符串或表示目标分组器转换的对象。
*args
可能的参数包括 how、fill_method、limit、kind 和 on，以及 TimeGrouper 的其他参数。
include_groupsbool，默认为 True
当为 True 时，将尝试在 DataFrame 的列中包括组，在这种情况下，如果引发 TypeError，则在应用func时将排除组。 当为 False 时，应用 func 时将排除组。
2.2.0 版本中的新功能。
自 2.2.0 版本起已弃用：设置 include_groups 为 True 已弃用。 在未来的版本中将仅允许值 False。
**kwargs
可能的参数包括 how、fill_method、limit、kind 和 on，以及 TimeGrouper 的其他参数。
返回：
pandas.api.typing.DatetimeIndexResamplerGroupby，
pandas.api.typing.PeriodIndexResamplerGroupby，或
pandas.api.typing.TimedeltaIndexResamplerGroupby
返回一个新的 groupby 对象，其类型取决于正在重新采样的数据。
亦可参见
Grouper
指定用于分组的频率进行重新采样。
DatetimeIndex.resample
频率转换和时间序列重新采样。
示例
>>> idx = pd.date_range('1/1/2000', periods=4, freq='min')
>>> df = pd.DataFrame(data=4 * [range(2)],
... index=idx,
... columns=['a', 'b'])
>>> df.iloc[2, 0] = 5
>>> df
a b
2000-01-01 00:00:00 0 1
2000-01-01 00:01:00 0 1
2000-01-01 00:02:00 5 1
2000-01-01 00:03:00 0 1
将 DataFrame 降采样为 3 分钟的区间，并将落入一个区间的时间戳的值求和。
>>> df.groupby('a').resample('3min', include_groups=False).sum()
b
a
0 2000-01-01 00:00:00 2
2000-01-01 00:03:00 1
5 2000-01-01 00:00:00 1
将系列升采样为 30 秒的区间。
>>> df.groupby('a').resample('30s', include_groups=False).sum()
b
a
0 2000-01-01 00:00:00 1
2000-01-01 00:00:30 0
2000-01-01 00:01:00 1
2000-01-01 00:01:30 0
2000-01-01 00:02:00 0
2000-01-01 00:02:30 0
2000-01-01 00:03:00 1
5 2000-01-01 00:02:00 1
按月重新采样。 值分配给周期的月份。
>>> df.groupby('a').resample('ME', include_groups=False).sum()
b
a
0 2000-01-31 3
5 2000-01-31 1
将系列降采样为 3 分钟的区间，方法如上，但关闭区间的右侧。
>>> (
... df.groupby('a')
... .resample('3min', closed='right', include_groups=False)
... .sum()
... )
b
a
0 1999-12-31 23:57:00 1
2000-01-01 00:00:00 2
5 2000-01-01 00:00:00 1
将系列降采样为 3 分钟的区间，并关闭区间的右侧，但使用右侧边缘而不是左侧标记每个区间。
>>> (
... df.groupby('a')
... .resample('3min', closed='right', label='right', include_groups=False)
... .sum()
... )
b
a
0 2000-01-01 00:00:00 1
2000-01-01 00:03:00 2
5 2000-01-01 00:03:00 1
pandas.core.groupby.DataFrameGroupBy.rolling
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.rolling.html
DataFrameGroupBy.rolling(*args, **kwargs)
返回一个滚动分组器，为每个分组提供滚动功能。
参数：
windowint、timedelta、str、offset 或 BaseIndexer 子类
移动窗口的大小。
如果是整数，则为每个窗口使用的固定观察值数量。
如果是 timedelta、str 或者 offset，每个窗口的时间段。每个窗口的大小将根据包含在时间段内的观察值而变化。这仅适用于 datetimelike 索引。要了解更多关于 offsets 和频率字符串的信息，请参见此链接。
如果为 BaseIndexer 子类，则窗口边界基于定义的get_window_bounds方法。额外的滚动关键字参数，即min_periods、center、closed和step，将传递给get_window_bounds。
min_periodsint，默认为 None
窗口中所需的观察值的最小数量，否则结果为np.nan。
对于由偏移量指定的窗口，min_periods将默认为 1。
对于由整数指定的窗口，min_periods将默认为窗口大小。
centerbool，默认为 False
如果为 False，则将窗口标签设置为窗口索引的右边缘。
如果为 True，则将窗口标签设置为窗口索引的中心。
win_typestr，默认为 None
如果为None，则所有点都是均匀加权的。
如果是字符串，则必须是有效的scipy.signal 窗口函数。
特定的 Scipy 窗口类型需要传入聚合函数的额外参数。这些额外参数必须与 Scipy 窗口类型方法签名中指定的关键字匹配。
onstr，可选
对于 DataFrame，计算滚动窗口的列标签或索引级别，而不是 DataFrame 的索引。
由于不使用整数索引来计算滚动窗口，所以忽略并排除了提供的整数列。
axisint 或 str，默认为 0
如果为0或'index'，则在行之间滚动。
如果为1或'columns'，则在列之间滚动。
对于 Series，此参数未使用，默认为 0。
closedstr，默认为 None
如果是'right'，则窗口中的第一个点将被排除在计算之外。
如果为'left'，则在计算中排除窗口中的最后一个点。
如果是'both'，则窗口中的所有点都不会被排除在计算之外。
如果是'neither'，则窗口中的第一个和最后一个点都会被排除在计算之外。
默认为None（'right'）。
methodstr {‘single’, ‘table’}，默认为‘single’
执行单个列或行（'single'）或整个对象（'table'）的滚动操作。
该参数仅在方法调用中指定 engine='numba' 时实现。
返回：
pandas.api.typing.RollingGroupby
返回一个新的 grouper，带有我们的 rolling 附加。
另请参阅
Series.rolling
用 Series 数据调用对象。
DataFrame.rolling
用 DataFrame 调用对象。
Series.groupby
对 Series 应用函数 groupby。
DataFrame.groupby
应用函数 groupby。
示例
>>> df = pd.DataFrame({'A': [1, 1, 2, 2],
... 'B': [1, 2, 3, 4],
... 'C': [0.362, 0.227, 1.267, -0.562]})
>>> df
A B C
0 1 1 0.362
1 1 2 0.227
2 2 3 1.267
3 2 4 -0.562
>>> df.groupby('A').rolling(2).sum()
B C
A
1 0 NaN NaN
1 3.0 0.589
2 2 NaN NaN
3 7.0 0.705
>>> df.groupby('A').rolling(2, min_periods=1).sum()
B C
A
1 0 1.0 0.362
1 3.0 0.589
2 2 3.0 1.267
3 7.0 0.705
>>> df.groupby('A').rolling(2, on='B').sum()
B C
A
1 0 1 NaN
1 2 0.589
2 2 3 NaN
3 4 0.705
pandas.core.groupby.DataFrameGroupBy.sample
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.sample.html
DataFrameGroupBy.sample(n=None, frac=None, replace=False, weights=None, random_state=None)
从每个组中返回一些随机抽样的项目。
您可以使用 random_state 进行可重现性。
参数：
n整数，可选
每个组要返回的项目数。不能与 frac 一起使用，并且必须不大于最小组，除非 replace 为 True。如果 frac 为 None，则默认为一个。
frac浮点数，可选
要返回的项目比例。不能与 n 一起使用。
replace布尔值，默认为 False
是否允许多次对同一行进行抽样。
权重列表形式，可选
默认值 None 表示等概率加权。如果传入一个类似列表的对象，则值必须与底层 DataFrame 或 Series 对象具有相同的长度，并且将在每个组内进行归一化后用作抽样概率。值必须是非负的，并且在每个组内必须至少有一个正元素。
random_state整数、类数组、BitGenerator、np.random.RandomState、np.random.Generator，可选
如果是整数、类数组或 BitGenerator，则是随机数生成器的种子。如果是 np.random.RandomState 或 np.random.Generator，则按照给定值使用。
在 1.4.0 版中更改：现在接受 np.random.Generator 对象
返回：
Series 或 DataFrame
从调用者对象中在每个组内随机抽样的同一类型的新对象。
另请参阅
DataFrame.sample
从 DataFrame 对象中生成随机样本。
从给定的 1-D numpy 数组中生成一个随机样本。
示例
>>> df = pd.DataFrame(
... {"a": ["red"] * 2 + ["blue"] * 2 + ["black"] * 2, "b": range(6)}
... )
>>> df
a b
0 red 0
1 red 1
2 blue 2
3 blue 3
4 black 4
5 black 5
为列 a 中的每个不同值随机选择一行。可以使用 random_state 参数来保证可重现性：
>>> df.groupby("a").sample(n=1, random_state=1)
a b
4 black 4
2 blue 2
1 red 1
将 frac 设置为抽样固定比例而不是计数：
>>> df.groupby("a")["b"].sample(frac=0.5, random_state=2)
5 5
2 2
0 0
Name: b, dtype: int64
通过设置权重来控制组内的样本概率：
>>> df.groupby("a").sample(
... n=1,
... weights=[1, 1, 1, 0, 0, 1],
... random_state=1,
... )
a b
5 black 5
2 blue 2
0 red 0
pandas.core.groupby.DataFrameGroupBy.sem
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.sem.html
DataFrameGroupBy.sem(ddof=1, numeric_only=False)
计算组的均值标准误差，排除缺失值。
对于多重分组，结果索引将是一个 MultiIndex。
参数：
ddofint，默认为 1
自由度。
numeric_onlybool，默认为 False
仅包括浮点数、整数或布尔值数据。
在版本 1.5.0 中新增。
从版本 2.0.0 开始更改：numeric_only 现在默认为 False。
返回：
Series 或 DataFrame
每个组内数值的均值标准误差。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([5, 10, 8, 14], index=lst)
>>> ser
a 5
a 10
b 8
b 14
dtype: int64
>>> ser.groupby(level=0).sem()
a 2.5
b 3.0
dtype: float64
对于 DataFrameGroupBy：
>>> data = [[1, 12, 11], [1, 15, 2], [2, 5, 8], [2, 6, 12]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tuna", "salmon", "catfish", "goldfish"])
>>> df
a b c
tuna 1 12 11
salmon 1 15 2
catfish 2 5 8
goldfish 2 6 12
>>> df.groupby("a").sem()
b c
a
1 1.5 4.5
2 0.5 2.0
对于 Resampler：
>>> ser = pd.Series([1, 3, 2, 4, 3, 8],
... index=pd.DatetimeIndex(['2023-01-01',
... '2023-01-10',
... '2023-01-15',
... '2023-02-01',
... '2023-02-10',
... '2023-02-15']))
>>> ser.resample('MS').sem()
2023-01-01 0.577350
2023-02-01 1.527525
Freq: MS, dtype: float64
pandas.core.groupby.DataFrameGroupBy.shift
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.shift.html
DataFrameGroupBy.shift(periods=1, freq=None, axis=_NoDefault.no_default, fill_value=_NoDefault.no_default, suffix=None)
按 periods 观察值移动每个组。
如果传递了 freq，则索引将使用 periods 和 freq 增加。
参数：
periods int | Sequence[int]，默认为 1
要移动的周期数。如果是值列表，则将每个组按每个周期移动。
freq str，可选
频率字符串。
axis 要移动的轴，默认为 0
移动方向。
自版本 2.1.0 弃用：对于 axis=1，请在底层对象上操作。否则，axis 关键字是不必要的。
fill_value 可选
用于新引入的缺失值的标量值。
版本 2.1.0 中的变更：如果提供了 freq，则会引发 ValueError。
suffix str，可选
如果存在多个周期，则要添加到每个移动列的字符串。否则忽略。
返回：
Series 或 DataFrame
在每个组内移动的对象。
另请参见
Index.shift
移动索引值。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
>>> ser
a 1
a 2
b 3
b 4
dtype: int64
>>> ser.groupby(level=0).shift(1)
a NaN
a 1.0
b NaN
b 3.0
dtype: float64
对于 DataFrameGroupBy：
>>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tuna", "salmon", "catfish", "goldfish"])
>>> df
a b c
tuna 1 2 3
salmon 1 5 6
catfish 2 5 8
goldfish 2 6 9
>>> df.groupby("a").shift(1)
b c
tuna NaN NaN
salmon 2.0 3.0
catfish NaN NaN
goldfish 5.0 8.0
pandas.core.groupby.DataFrameGroupBy.size
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.size.html
DataFrameGroupBy.size()
计算分组大小。
返回：
DataFrame 或 Series
如果 as_index 为 True，则每个组中的行数为 Series，如果 as_index 为 False，则为 DataFrame。
另请参阅
Series.groupby
对一个 Series 应用一个 groupby 函数。
DataFrame.groupby
对 DataFrame 的每一行或列应用一个 groupby 函数。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b']
>>> ser = pd.Series([1, 2, 3], index=lst)
>>> ser
a 1
a 2
b 3
dtype: int64
>>> ser.groupby(level=0).size()
a 2
b 1
dtype: int64
>>> data = [[1, 2, 3], [1, 5, 6], [7, 8, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["owl", "toucan", "eagle"])
>>> df
a b c
owl 1 2 3
toucan 1 5 6
eagle 7 8 9
>>> df.groupby("a").size()
a
1 2
7 1
dtype: int64
对于 Resampler：
>>> ser = pd.Series([1, 2, 3], index=pd.DatetimeIndex(
... ['2023-01-01', '2023-01-15', '2023-02-01']))
>>> ser
2023-01-01 1
2023-01-15 2
2023-02-01 3
dtype: int64
>>> ser.resample('MS').size()
2023-01-01 2
2023-02-01 1
Freq: MS, dtype: int64
pandas.core.groupby.DataFrameGroupBy.skew
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.skew.html
DataFrameGroupBy.skew(axis=_NoDefault.no_default, skipna=True, numeric_only=False, **kwargs)
在组内返回无偏倾斜。
通过 N-1 进行标准化。
参数：
axis {0 或 ‘index’，1 或 ‘columns’，None}，默认为 0
函数要应用的轴。
指定 axis=None 将在两个轴上应用聚合。
新版本中引入：2.0.0。
自版本 2.1.0 弃用：对于 axis=1，操作应在基础对象上进行。否则，axis 关键字是不必要的。
skipna 布尔型，默认为 True。
在计算结果时排除 NA/null 值。
numeric_only 布尔型，默认为 False。
仅包括浮点数、整数和布尔值列。
**kwargs
要传递给函数的其他关键字参数。
返回：
DataFrame
另请参阅
DataFrame.skew
在请求的轴上返回无偏倾斜。
示例
>>> arrays = [['falcon', 'parrot', 'cockatoo', 'kiwi',
... 'lion', 'monkey', 'rabbit'],
... ['bird', 'bird', 'bird', 'bird',
... 'mammal', 'mammal', 'mammal']]
>>> index = pd.MultiIndex.from_arrays(arrays, names=('name', 'class'))
>>> df = pd.DataFrame({'max_speed': [389.0, 24.0, 70.0, np.nan,
... 80.5, 21.5, 15.0]},
... index=index)
>>> df
max_speed
name class
falcon bird 389.0
parrot bird 24.0
cockatoo bird 70.0
kiwi bird NaN
lion mammal 80.5
monkey mammal 21.5
rabbit mammal 15.0
>>> gb = df.groupby(["class"])
>>> gb.skew()
max_speed
class
bird 1.628296
mammal 1.669046
>>> gb.skew(skipna=False)
max_speed
class
bird NaN
mammal 1.669046
pandas.core.groupby.DataFrameGroupBy.std
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.std.html
DataFrameGroupBy.std(ddof=1, engine=None, engine_kwargs=None, numeric_only=False)
计算组的标准差，不包括缺失值。
对于多个分组，结果索引将是 MultiIndex。
参数：
ddofint，默认为 1
自由度。
enginestr，默认为 None
-
'cython'：通过 cython 的 C 扩展来运行操作。 -
'numba'：通过 numba 的 JIT 编译代码来运行操作。 -
None：默认为'cython'或全局设置compute.use_numba
在 1.4.0 版本中新增。
engine_kwargsdict，默认为 None
-
对于
'cython'引擎，没有接受的engine_kwargs -
对于
'numba'引擎，引擎可以接受nopython、nogil和parallel字典键。值必须是True或False。'numba'引擎的默认engine_kwargs为{{'nopython': True, 'nogil': False, 'parallel': False}}
在 1.4.0 版本中新增。
numeric_onlybool，默认为 False
仅包含浮点数、整数或布尔值数据。
在 1.5.0 版本中新增。
从版本 2.0.0 开始更改：numeric_only 现在默认为False。
返回：
Series 或 DataFrame
在每个组内的值的标准差。
另请参阅
Series.groupby
对 Series 应用 groupby 函数。
DataFrame.groupby
对 DataFrame 的每一行或每一列应用 groupby 函数。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
>>> ser
a 7
a 2
a 8
b 4
b 3
b 3
dtype: int64
>>> ser.groupby(level=0).std()
a 3.21455
b 0.57735
dtype: float64
对于 DataFrameGroupBy：
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
... 'mouse', 'mouse', 'mouse', 'mouse'])
>>> df
a b
dog 1 1
dog 3 4
dog 5 8
mouse 7 4
mouse 7 4
mouse 8 2
mouse 3 1
>>> df.groupby(level=0).std()
a b
dog 2.000000 3.511885
mouse 2.217356 1.500000
pandas.core.groupby.DataFrameGroupBy.sum
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.sum.html
DataFrameGroupBy.sum(numeric_only=False, min_count=0, engine=None, engine_kwargs=None)
计算组值的总和。
参数：
numeric_onlybool，默认为 False
仅包括 float、int、boolean 列。
在 2.0.0 版中更改：numeric_only 不再接受 None。
min_countint，默认为 0
执行操作所需的有效值的最小数量。如果非 NA 值少于 min_count 个，则结果将为 NA。
enginestr，默认为 None None
-
'cython'：通过 cython 中的 C 扩展运行滚动应用程序。 -
'numba'：通过 numba 中的 JIT 编译代码运行滚动应用程序。仅在
raw设置为True时可用。 -
None：默认为'cython'或全局设置compute.use_numba
engine_kwargsdict，默认为 None None
-
对于
'cython'引擎，不接受engine_kwargs -
对于
'numba'引擎，该引擎可以接受nopython、nogil和
parallel字典键。值必须为True或False。'numba'引擎的默认engine_kwargs是{'nopython': True, 'nogil': False, 'parallel': False}，将应用于func和applygroupby 聚合。
返回：
Series 或 DataFrame
在每个组内计算值的总和。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 4], index=lst)
>>> ser
a 1
a 2
b 3
b 4
dtype: int64
>>> ser.groupby(level=0).sum()
a 3
b 7
dtype: int64
对于 DataFrameGroupBy：
>>> data = [[1, 8, 2], [1, 2, 5], [2, 5, 8], [2, 6, 9]]
>>> df = pd.DataFrame(data, columns=["a", "b", "c"],
... index=["tiger", "leopard", "cheetah", "lion"])
>>> df
a b c
tiger 1 8 2
leopard 1 2 5
cheetah 2 5 8
lion 2 6 9
>>> df.groupby("a").sum()
b c
a
1 10 7
2 11 17
pandas.core.groupby.DataFrameGroupBy.var
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.var.html
DataFrameGroupBy.var(ddof=1, engine=None, engine_kwargs=None, numeric_only=False)
计算组的方差，不包括缺失值。
对于多重分组，结果索引将是 MultiIndex。
参数：
ddof：整数，默认为 1
自由度。
engine：字符串，默认为 None
-
'cython'：通过 cython 的 C 扩展运行操作。 -
'numba'：通过 JIT 编译自 numba 的代码运行操作。 -
None：默认为'cython'或全局设置compute.use_numba
新版本 1.4.0 中新增。
engine_kwargs：字典，默认为 None
-
对于
'cython'引擎，没有被接受的engine_kwargs -
对于
'numba'引擎，引擎可以接受nopython、nogil和parallel字典键。 值必须为True或False。'numba'引擎的默认engine_kwargs是{{'nopython': True, 'nogil': False, 'parallel': False}}
新版本 1.4.0 中新增。
numeric_only：布尔值，默认为 False
仅包括浮点数、整数或布尔值数据。
新版本 1.5.0 中新增。
在版本 2.0.0 中更改：numeric_only 默认为 False。
返回：
Series 或 DataFrame
每个组内值的方差。
另请参阅
Series.groupby
对 Series 应用函数 groupby。
DataFrame.groupby
对 DataFrame 的每行或每列应用函数 groupby。
示例
对于 SeriesGroupBy：
>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([7, 2, 8, 4, 3, 3], index=lst)
>>> ser
a 7
a 2
a 8
b 4
b 3
b 3
dtype: int64
>>> ser.groupby(level=0).var()
a 10.333333
b 0.333333
dtype: float64
对于 DataFrameGroupBy：
>>> data = {'a': [1, 3, 5, 7, 7, 8, 3], 'b': [1, 4, 8, 4, 4, 2, 1]}
>>> df = pd.DataFrame(data, index=['dog', 'dog', 'dog',
... 'mouse', 'mouse', 'mouse', 'mouse'])
>>> df
a b
dog 1 1
dog 3 4
dog 5 8
mouse 7 4
mouse 7 4
mouse 8 2
mouse 3 1
>>> df.groupby(level=0).var()
a b
dog 4.000000 12.333333
mouse 4.916667 2.250000
pandas.core.groupby.DataFrameGroupBy.tail
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.tail.html
DataFrameGroupBy.tail(n=5)
返回每个组的最后 n 行。
类似于.apply(lambda x: x.tail(n))，但它返回原始 DataFrame 的行子集，并保留原始索引和顺序（as_index标志被忽略）。
参数：
nint
如果为正数：包括每个组末尾的条目数。如果为负数：排除每个组开头的条目数。
返回值：
Series 或 DataFrame
由 n 确定的原始 Series 或 DataFrame 的子集。
另请参阅
Series.groupby
将函数应用于 Series。
DataFrame.groupby
将函数应用于 DataFrame 的每一行或每一列。
示例
>>> df = pd.DataFrame([['a', 1], ['a', 2], ['b', 1], ['b', 2]],
... columns=['A', 'B'])
>>> df.groupby('A').tail(1)
A B
1 a 2
3 b 2
>>> df.groupby('A').tail(-1)
A B
1 a 2
3 b 2
pandas.core.groupby.DataFrameGroupBy.take
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.take.html
DataFrameGroupBy.take(indices, axis=_NoDefault.no_default, **kwargs)
返回每个组中给定位置索引的元素。
这意味着我们不是根据对象的索引属性中的实际值进行索引。我们是根据对象中元素的实际位置进行索引。
如果某个组的索引不存在，则此方法将引发异常。要获得忽略不存在的索引的类似行为，请参见DataFrameGroupBy.nth()。
参数：
indices类数组
一个 int 数组，指示要获取的位置。
轴，默认为 0
要选择元素的轴。0表示我们选择行，1表示我们选择列。
自版本 2.1.0 起弃用：对于轴=1，操作的是底层对象。否则，轴关键字不是必需的。
**kwargs
为了与numpy.take()兼容。对输出没有影响。
返回：
DataFrame
包含从每个组中获取的元素的 DataFrame。
另请参阅
DataFrame.take
沿轴获取 Series 中的元素。
DataFrame.loc
通过标签选择 DataFrame 的子集。
DataFrame.iloc
按位置选择 DataFrame 的子集。
沿轴获取数组中的元素。
示例
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
... ('parrot', 'bird', 24.0),
... ('lion', 'mammal', 80.5),
... ('monkey', 'mammal', np.nan),
... ('rabbit', 'mammal', 15.0)],
... columns=['name', 'class', 'max_speed'],
... index=[4, 3, 2, 1, 0])
>>> df
name class max_speed
4 falcon bird 389.0
3 parrot bird 24.0
2 lion mammal 80.5
1 monkey mammal NaN
0 rabbit mammal 15.0
>>> gb = df.groupby([1, 1, 2, 2, 2])
沿轴 0（默认）获取位置 0 和 1 处的元素。
注意结果中选择的索引与我们的输入索引 0 和 1 不对应。这是因为我们选择的是第 0 和第 1 行，而不是索引等于 0 和 1 的行。
>>> gb.take([0, 1])
name class max_speed
1 4 falcon bird 389.0
3 parrot bird 24.0
2 2 lion mammal 80.5
1 monkey mammal NaN
指定的索引顺序影响结果中的顺序。在这里，顺序与前一个示例中的顺序相反。
>>> gb.take([1, 0])
name class max_speed
1 3 parrot bird 24.0
4 falcon bird 389.0
2 1 monkey mammal NaN
2 lion mammal 80.5
沿轴 1（列选择）获取索引为 1 和 2 的元素。
我们可以使用负整数来获取正整数索引的元素，从对象的末尾开始，就像使用 Python 列表一样。
>>> gb.take([-1, -2])
name class max_speed
1 3 parrot bird 24.0
4 falcon bird 389.0
2 0 rabbit mammal 15.0
1 monkey mammal NaN
pandas.core.groupby.DataFrameGroupBy.value_counts
原文：
pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.value_counts.html
DataFrameGroupBy.value_counts(subset=None, normalize=False, sort=True, ascending=False, dropna=True)
返回一个包含唯一行计数的 Series 或 DataFrame。
版本 1.4.0 中新增。
参数：
subset列表样式，可选
用于计算唯一组合时要使用的列。
normalize布尔值，默认为 False
返回比例而不是频率。
sort布尔值，默认为 True
按频率排序。
ascending布尔值，默认为 False
按升序排序。
dropna布尔值，默认为 True
不包括包含 NA 值的行的计数。
返回：
Series 或 DataFrame
如果 groupby as_index 为 True，则为 Series，否则为 DataFrame。
另请参见
Series.value_counts
Series 上的等效方法。
DataFrame.value_counts
DataFrame 上的等效方法。
SeriesGroupBy 上的等效方法。
注意事项
-
如果 groupby as_index 为 True，则返回的 Series 将具有一个 MultiIndex，每个输入列对应一个级别。
-
如果 groupby as_index 为 False，则返回的 DataFrame 将具有一个额外的列，其中包含 value_counts。该列标记为'count'或'proportion'，取决于
normalize参数。
默认情况下，包含任何 NA 值的行将从结果中省略。
默认情况下，结果将按降序排列，以使每个组的第一个元素是出现频率最高的行。
示例
>>> df = pd.DataFrame({
... 'gender': ['male', 'male', 'female', 'male', 'female', 'male'],
... 'education': ['low', 'medium', 'high', 'low', 'high', 'low'],
... 'country': ['US', 'FR', 'US', 'FR', 'FR', 'FR']
... })
>>> df
gender education country
0 male low US
1 male medium FR
2 female high US
3 male low FR
4 female high FR
5 male low FR
>>> df.groupby('gender').value_counts()
gender education country
female high FR 1
US 1
male low FR 2
US 1
medium FR 1
Name: count, dtype: int64
>>> df.groupby('gender').value_counts(ascending=True)
gender education country
female high FR 1
US 1
male low US 1
medium FR 1
low FR 2
Name: count, dtype: int64
>>> df.groupby('gender').value_counts(normalize=True)
gender education country
female high FR 0.50
US 0.50
male low FR 0.50
US 0.25
medium FR 0.25
Name: proportion, dtype: float64
>>> df.groupby('gender', as_index=False).value_counts()
gender education country count
0 female high FR 1
1 female high US 1
2 male low FR 2
3 male low US 1
4 male medium FR 1
>>> df.groupby('gender', as_index=False).value_counts(normalize=True)
gender education country proportion
0 female high FR 0.50
1 female high US 0.50
2 male low FR 0.50
3 male low US 0.25
4 male medium FR 0.25
浙公网安备 33010602011771号