Pandas-2-2-中文文档-三十五-

Pandas 2.2 中文文档（三十五）

原文：pandas.pydata.org/docs/

`pandas.core.groupby.SeriesGroupBy.all`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.all.html

SeriesGroupBy.all(skipna=True)

如果组中的所有值都为真，则返回 True，否则返回 False。

参数：

skipna 布尔值，默认为 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).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.SeriesGroupBy.any`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.any.html

SeriesGroupBy.any(skipna=True)

如果组中有任何值为真，则返回 True，否则返回 False。

参数：

skipna 布尔值，默认为 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.SeriesGroupBy.bfill`

pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.bfill.html

SeriesGroupBy.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.SeriesGroupBy.corr`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.corr.html

SeriesGroupBy.corr(other, method='pearson', min_periods=None)

计算与其他 Series 的相关性，不包括缺失值。

两个 Series 对象不需要具有相同的长度，并且在应用相关函数之前会在内部进行对齐。

参数：

其他系列

用于计算相关性的 Series。

method {‘pearson’, ‘kendall’, ‘spearman’} 或可调用对象

用于计算相关性的方法：

pearson：标准相关系数
kendall：Kendall Tau 相关系数
spearman：Spearman 等级相关系数
可调用对象：接受两个 1d ndarray 作为输入并返回一个浮点数的可调用对象。

警告

请注意，从 corr 返回的矩阵在对角线上有 1，并且无论可调用对象的行为如何，它都是对称的。

min_periods 整数，可选

需要具有有效结果的最小观测次数。

浮点数

与其他的相关性。

另请参阅

DataFrame.corr

在列之间计算成对的相关性。

DataFrame.corrwith

与另一个 DataFrame 或 Series 计算成对的相关性。

注意事项

目前使用完整成对观测计算 Pearson、Kendall 和 Spearman 相关系数。

自动数据对齐：与所有 pandas 操作一样，此方法会执行自动数据对齐。corr() 自动考虑具有匹配索引的值。

示例

>>> def histogram_intersection(a, b):
...     v = np.minimum(a, b).sum().round(decimals=1)
...     return v
>>> s1 = pd.Series([.2, .0, .6, .2])
>>> s2 = pd.Series([.3, .6, .0, .1])
>>> s1.corr(s2, method=histogram_intersection)
0.3

Pandas 会自动对齐具有匹配索引的值

>>> s1 = pd.Series([1, 2, 3], index=[0, 1, 2])
>>> s2 = pd.Series([1, 2, 3], index=[2, 1, 0])
>>> s1.corr(s2)
-1.0

`pandas.core.groupby.SeriesGroupBy.count`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.count.html

SeriesGroupBy.count()

计算组的计数，不包括缺失值。

Series 或 DataFrame

每个组内的值的计数。

另请参阅

Series.groupby

对 Series 应用 groupby 函数。

DataFrame.groupby

对 DataFrame 的每一行或每一列应用 groupby 函数。

示例

对于 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.SeriesGroupBy.cov`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.cov.html

SeriesGroupBy.cov(other, min_periods=None, ddof=1)

使用 Series 计算协方差，排除缺失值。

两个 Series 对象不需要具有相同的长度，在计算协方差之前将在内部对齐。

参数：

otherSeries

计算协方差的序列。

min_periodsint，可选

需要具有有效结果的最小观察次数。

ddofint，默认为 1

Delta 自由度。计算中使用的除数是 N - ddof，其中 N 表示元素的数量。

浮点数

Series 和其他序列之间的协方差由 N-1（无偏估计器）归一化。

另请参见

DataFrame.cov

计算列的成对协方差。

示例

>>> s1 = pd.Series([0.90010907, 0.13484424, 0.62036035])
>>> s2 = pd.Series([0.12528585, 0.26962463, 0.51111198])
>>> s1.cov(s2)
-0.01685762652715874

`pandas.core.groupby.SeriesGroupBy.cumcount`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.cumcount.html

SeriesGroupBy.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.SeriesGroupBy.cummax`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.cummax.html

SeriesGroupBy.cummax(axis=_NoDefault.no_default, numeric_only=False, **kwargs)

每个组的累积最大值。

系列或数据框

另请参阅

Series.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.SeriesGroupBy.cummin`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.cummin.html

SeriesGroupBy.cummin(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, 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.SeriesGroupBy.cumprod`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.cumprod.html

SeriesGroupBy.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.SeriesGroupBy.cumsum`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.cumsum.html

SeriesGroupBy.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.SeriesGroupBy.describe`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.describe.html

SeriesGroupBy.describe(percentiles=None, include=None, exclude=None)

生成描述性统计。

描述性统计包括总体倾向、分散度和数据集分布的形状的总结，不包括 NaN 值。

分析数值和对象系列，以及混合数据类型的 DataFrame 列集。输出将根据提供的内容而变化。有关更多详细信息，请参阅下面的注释。

参数：

percentiles：数字的类似列表，可选

输出中包含的百分位数。所有百分位数应介于 0 和 1 之间。默认值为 [.25, .5, .75]，返回第 25、50 和 75 百分位数。

include：‘all’、dtype 的类似列表或 None（默认），可选

要在结果中包含的数据类型的白名单。对于 Series 不起作用。以下是选项：

‘all’：输出将包含输入的所有列。
一个 dtype 的类似列表：限制结果为所提供的数据类型。要将结果限制为数值类型，请提交 numpy.number。要限制为对象列，请提交 numpy.object 数据类型。还可以使用字符串以 select_dtypes 的形式（例如 df.describe(include=['O'])）。要选择 pandas 分类列，请使用 'category'。
None（默认）：结果将包括所有数值列。

exclude：dtype 的类似列表或 None（默认），可选，

要从结果中省略的数据类型的黑名单。对于 Series 不起作用。以下是选项：

dtype 的类似列表：从结果中排除所提供的数据类型。要排除数值类型，请提交 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

DataFrame 的子集，根据其 dtype 包括/排除列。

注意事项

对于数值数据，结果的索引将包括 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.SeriesGroupBy.diff`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.diff.html

SeriesGroupBy.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 的每一行或列应用一个 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).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.SeriesGroupBy.ffill`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.ffill.html

SeriesGroupBy.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.SeriesGroupBy.fillna`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.fillna.html

SeriesGroupBy.fillna(value=None, method=None, axis=_NoDefault.no_default, inplace=False, limit=None, downcast=_NoDefault.no_default)

使用指定方法在组内填充 NA/NaN 值。

自版本 2.2.0 弃用：此方法已弃用，将在将来的版本中删除。请改用 SeriesGroupBy.ffill() 或 SeriesGroupBy.bfill() 进行向前或向后填充。如果要使用单个值进行填充，请改用 Series.fillna()。

参数：

value 标量、字典、Series 或 DataFrame

用于填充空洞（例如 0）的值，或者一个指定每个索引（对于 Series）或列（对于 DataFrame）使用哪个值的字典/Series/DataFrame。不在字典/Series/DataFrame 中的值将不被填充。此值不能是列表。想要使用 value 参数而不是 method 的用户应该优先使用Series.fillna()，因为这将产生相同的结果并且更高效。

method{{‘bfill’，‘ffill’，None}}，默认为 None

用于填充空洞的方法。'ffill' 将在组内向前传播最后一个有效观察值。'bfill' 将使用下一个有效观察值来填补间隙。

axis

未使用，仅用于与DataFrameGroupBy.fillna() 兼容。

inplace 布尔值，默认为 False

已损坏。不要设置为 True。

limit 整数，默认为 None

如果指定了 method，则这是在组内向前/向后填充的最大连续 NaN 值的数量。换句话说，如果有一个间隙有超过这个数量的连续 NaN 值，它将只被部分填充。如果未指定 method，则这是整个轴上将填充 NaN 的最大条目数。如果不是 None，则必须大于 0。

downcast 字典，默认为 None

一个项目->dtype 的字典，如果可能的话指定要降级的内容，或者字符串‘infer’，它将尝试降级为适当的相等类型（例如 float64 到 int64 如果可能的话）。

Series

在组内填充缺失值的对象。

另请参见

ffill

在组内向前填充值。

bfill

在组内向后填充值。

示例

对于 SeriesGroupBy：

>>> lst = ['cat', 'cat', 'cat', 'mouse', 'mouse']
>>> ser = pd.Series([1, None, None, 2, None], index=lst)
>>> ser
cat    1.0
cat    NaN
cat    NaN
mouse  2.0
mouse  NaN
dtype: float64
>>> ser.groupby(level=0).fillna(0, limit=1)
cat    1.0
cat    0.0
cat    NaN
mouse  2.0
mouse  0.0
dtype: float64

`pandas.core.groupby.SeriesGroupBy.first`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.first.html

SeriesGroupBy.first(numeric_only=False, min_count=-1, skipna=True)

计算每个组内每列的第一个条目。

默认跳过 NA 元素。

参数：

numeric_onlybool，默认为 False

仅包括浮点数、整数、布尔值列。

min_countint，默认为 -1

执行操作所需的有效值的最小数量。如果存在少于 min_count 个有效值，则结果将为 NA。

skipnabool，默认为 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.SeriesGroupBy.head`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.head.html

SeriesGroupBy.head(n=5)

返回每个组的前 n 行。

类似于 .apply(lambda x: x.head(n))，但它返回原始 DataFrame 的行的子集，并保留原始索引和顺序（as_index 标志被忽略）。

参数：

n 整型

如果为正数：从每个组的开头包括的条目数。如果为负数：从每个组的末尾排除的条目数。

Series 或 DataFrame

根据 n 确定原始 Series 或 DataFrame 的子集。

另请参见

Series.groupby

对 Series 应用 groupby 函数。

DataFrame.groupby

对 DataFrame 的每行或每列应用 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.SeriesGroupBy.last`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.last.html

SeriesGroupBy.last(numeric_only=False, min_count=-1, skipna=True)

计算每个分组内每列的最后一个条目。

默认情况下跳过 NA 元素。

参数：

numeric_onlybool，默认为 False

仅包括浮点数、整数、布尔列。如果为 None，则尝试使用所有内容，然后仅使用数值数据。

min_countint，默认为-1

执行操作所需的有效值的数量。如果有效值少于min_count，则结果将为 NA。

skipnabool，默认为 True

排除 NA/null 值。如果整行/列都是 NA，则结果将为 NA。

版本 2.2.1 中的新功能。

Series 或 DataFrame

每个分组内的值的最后一个。

另请参见

DataFrame.groupby

对 DataFrame 的每一行或列应用分组函数。

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.SeriesGroupBy.idxmax`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.idxmax.html

SeriesGroupBy.idxmax(axis=_NoDefault.no_default, skipna=True)

返回最大值的行标签。

如果多个值等于最大值，则返回具有该值的第一个行标签。

参数：

axis

未使用。与 DataFrame 兼容性所需的参数。

skipnabool，默认为 True

排除 NA/null 值。如果整个 Series 都是 NA，则结果将是 NA。

***args, kwargs

额外的参数和关键字对结果没有影响，但可能会被接受以与 NumPy 兼容。

索引

最大值的标签。

引发：

ValueError

如果 Series 为空。

另请参见

numpy.argmax

返回沿给定轴的最大值的索引。

DataFrame.idxmax

返回所请求轴上最大值的第一次出现的索引。

Series.idxmin

返回第一次出现的最小值的索引标签。

注意

该方法是ndarray.argmax的 Series 版本。该方法返回最大值的标签，而ndarray.argmax返回位置。要获取位置，请使用series.values.argmax()。

示例

>>> s = pd.Series(data=[1, None, 4, 3, 4],
...               index=['A', 'B', 'C', 'D', 'E'])
>>> s
A    1.0
B    NaN
C    4.0
D    3.0
E    4.0
dtype: float64

>>> s.idxmax()
'C'

如果skipna为 False 并且数据中存在 NA 值，则该函数返回nan。

>>> s.idxmax(skipna=False)
nan

`pandas.core.groupby.SeriesGroupBy.idxmin`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.idxmin.html

SeriesGroupBy.idxmin(axis=_NoDefault.no_default, skipna=True)

返回最小值的行标签。

如果多个值等于最小值，则返回具有该值的第一行标签。

参数：

axis

未使用。为了与 DataFrame 兼容性需要的参数。

skipnabool，默认为 True

排除 NA/null 值。如果整个 Series 是 NA，则结果将为 NA。

***args, kwargs

额外的参数和关键字没有效果，但可能会被接受以便与 NumPy 兼容。

索引

最小值的标签。

异常：

ValueError

如果 Series 是空的。

另请参阅

numpy.argmin

返回沿给定轴的最小值的索引。

DataFrame.idxmin

返回请求轴上最小值的第一次出现的索引。

Series.idxmax

返回第一次出现的最大值的索引标签。

注意事项

这个方法是 ndarray.argmin 的 Series 版本。这个方法返回最小值的标签，而 ndarray.argmin 返回位置。要获取位置，请使用 series.values.argmin()。

示例

>>> s = pd.Series(data=[1, None, 4, 1],
...               index=['A', 'B', 'C', 'D'])
>>> s
A    1.0
B    NaN
C    4.0
D    1.0
dtype: float64

>>> s.idxmin()
'A'

如果 skipna 为 False 并且数据中有 NA 值，则该函数返回 nan。

>>> s.idxmin(skipna=False)
nan

`pandas.core.groupby.SeriesGroupBy.is_monotonic_increasing`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.is_monotonic_increasing.html

property SeriesGroupBy.is_monotonic_increasing

返回每个分组的值是否单调递增。

Series

示例

>>> s = pd.Series([2, 1, 3, 4], index=['Falcon', 'Falcon', 'Parrot', 'Parrot'])
>>> s.groupby(level=0).is_monotonic_increasing
Falcon    False
Parrot     True
dtype: bool

`pandas.core.groupby.SeriesGroupBy.is_monotonic_decreasing`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.is_monotonic_decreasing.html

property SeriesGroupBy.is_monotonic_decreasing

返回每个分组的值是否单调递减。

Returns:

Series

示例

>>> s = pd.Series([2, 1, 3, 4], index=['Falcon', 'Falcon', 'Parrot', 'Parrot'])
>>> s.groupby(level=0).is_monotonic_decreasing
Falcon     True
Parrot    False
dtype: bool

`pandas.core.groupby.SeriesGroupBy.max`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.max.html

SeriesGroupBy.max(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

'cython'：通过 cython 的 C 扩展运行滚动应用。
'numba' 运行 JIT 编译的代码通过滚动应用。

仅在 raw 设置为 True 时可用。
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}，并将应用于 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.SeriesGroupBy.mean`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.mean.html

SeriesGroupBy.mean(numeric_only=False, engine=None, engine_kwargs=None)

计算组的均值，排除缺失值。

参数：

numeric_only 布尔值，默认为 False

仅包括浮点数、整数、布尔值列。

在版本 2.0.0 中更改：numeric_only 不再接受 None，默认为 False。

engine 字符串，默认为 None

'cython'：通过 cython 的 C 扩展运行操作。
'numba'：通过 numba 的 JIT 编译代码运行操作。
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 中新增。

pandas.Series 或 pandas.DataFrame

另请参见

Series.groupby

对 Series 应用一个分组函数。

DataFrame.groupby

对 DataFrame 的每行或每列应用一个分组函数。

示例

>>> 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.SeriesGroupBy.median`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.median.html

SeriesGroupBy.median(numeric_only=False)

计算各组的中位数，不包括缺失值。

对于多重分组，结果索引将是一个 MultiIndex

参数：

numeric_only 布尔值，默认为 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.SeriesGroupBy.min`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.min.html

SeriesGroupBy.min(numeric_only=False, min_count=-1, engine=None, engine_kwargs=None)

计算组值的最小值。

参数：

numeric_onlybool，默认值为 False

只包括 float、int、boolean 列。

在版本 2.0.0 中更改：numeric_only 不再接受 None。

min_countint，默认值为 -1

执行操作所需的有效值的最小数量。如果少于 min_count 个非 NA 值，则结果将为 NA。

enginestr，默认值为 None None

'cython' : 通过 cython 的 C-extensions 运行滚动应用。
'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 和 apply groupby 聚合。

返回值：

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.SeriesGroupBy.ngroup`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.ngroup.html

SeriesGroupBy.ngroup(ascending=True)

将每个组从 0 编号到组数 - 1。

这是 cumcount 的枚举补充。请注意，分配给组的编号与在迭代 groupby 对象时看到组的顺序相匹配，而不是它们首次观察到的顺序。

具有缺失键（pd.isna()为 True 的地方）的组将被标记为 NaN，并将从计数中跳过。

参数：

ascendingbool, 默认为 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.SeriesGroupBy.nlargest`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.nlargest.html

SeriesGroupBy.nlargest(n=5, keep='first')

返回前 n 个最大元素。

参数：

nint，默认为 5

返回这么多按降序排序的值。

keep，默认为‘first’

当有无法全部容纳在 n 个元素的 Series 中的重复值时：

first：按出现顺序返回前 n 个元素。
last：按出现的相反顺序返回最后 n 个元素。
all：保留所有出现的元素。这可能导致 Series 的大小大于 n。

Series

Series 中按降序排序的前 n 个最大值。

另请参阅

Series.nsmallest

获取前 n 个最小元素。

Series.sort_values

按值对 Series 进行排序。

Series.head

返回前 n 行。

注意事项

对于相对于Series对象大小而言较小的 n，比.sort_values(ascending=False).head(n)更快。

示例

>>> countries_population = {"Italy": 59000000, "France": 65000000,
...                         "Malta": 434000, "Maldives": 434000,
...                         "Brunei": 434000, "Iceland": 337000,
...                         "Nauru": 11300, "Tuvalu": 11300,
...                         "Anguilla": 11300, "Montserrat": 5200}
>>> s = pd.Series(countries_population)
>>> s
Italy       59000000
France      65000000
Malta         434000
Maldives      434000
Brunei        434000
Iceland       337000
Nauru          11300
Tuvalu         11300
Anguilla       11300
Montserrat      5200
dtype: int64

默认情况下，前 n 个最大元素，其中n=5。

>>> s.nlargest()
France      65000000
Italy       59000000
Malta         434000
Maldives      434000
Brunei        434000
dtype: int64

前 n 个最大元素，其中n=3。默认保留值为‘first’，因此马耳他将被保留。

>>> s.nlargest(3)
France    65000000
Italy     59000000
Malta       434000
dtype: int64

前 n 个最大元素，其中n=3，并保留最后的重复项。根据索引顺序，文莱将被保留，因为它是值为 434000 的最后一个。

>>> s.nlargest(3, keep='last')
France      65000000
Italy       59000000
Brunei        434000
dtype: int64

前 n 个最大元素，其中n=3，并保留所有重复项。请注意，返回的 Series 有五个元素，因为有三个重复项。

>>> s.nlargest(3, keep='all')
France      65000000
Italy       59000000
Malta         434000
Maldives      434000
Brunei        434000
dtype: int64

`pandas.core.groupby.SeriesGroupBy.nsmallest`

pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.nsmallest.html

SeriesGroupBy.nsmallest(n=5, keep='first')

返回最小的 n 个元素。

参数：

nint，默认值为 5

返回这么多按升序排序的值。

keep，默认为 ‘first’

当有无法全部放入 n 个元素的 Series 中的重复值时：

first：按出现顺序返回前 n 个出现次数。
last：按出现顺序的相反顺序返回最后的 n 个出现次数。
all：保留所有出现次数。这可能导致 Series 的大小大于 n。

Series

Series 中按增序排列的前 n 个最小值。

另请参阅

Series.nlargest

获取前 n 个最大的元素。

Series.sort_values

按值对 Series 进行排序。

Series.head

返回前 n 行。

注释

相对于 Series 对象的大小，对于小的 n，比 .sort_values().head(n) 快。

示例

>>> countries_population = {"Italy": 59000000, "France": 65000000,
...                         "Brunei": 434000, "Malta": 434000,
...                         "Maldives": 434000, "Iceland": 337000,
...                         "Nauru": 11300, "Tuvalu": 11300,
...                         "Anguilla": 11300, "Montserrat": 5200}
>>> s = pd.Series(countries_population)
>>> s
Italy       59000000
France      65000000
Brunei        434000
Malta         434000
Maldives      434000
Iceland       337000
Nauru          11300
Tuvalu         11300
Anguilla       11300
Montserrat      5200
dtype: int64

默认情况下，n=5 时的 n 个最小元素。

>>> s.nsmallest()
Montserrat    5200
Nauru        11300
Tuvalu       11300
Anguilla     11300
Iceland     337000
dtype: int64

n 个最小元素，其中 n=3。默认的保留值是 ‘first’，所以瑙鲁和图瓦卢将被保留。

>>> s.nsmallest(3)
Montserrat   5200
Nauru       11300
Tuvalu      11300
dtype: int64

n 个最小元素，其中 n=3，并保留最后的重复项。根据索引顺序，安圭拉和图瓦卢将被保留，因为它们是值为 11300 的最后项。

>>> s.nsmallest(3, keep='last')
Montserrat   5200
Anguilla    11300
Tuvalu      11300
dtype: int64

n 个最小元素，其中 n=3，所有重复项都被保留。请注意，由于三个重复项，返回的 Series 具有四个元素。

>>> s.nsmallest(3, keep='all')
Montserrat   5200
Nauru       11300
Tuvalu      11300
Anguilla    11300
dtype: int64

`pandas.core.groupby.SeriesGroupBy.nth`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.nth.html

property SeriesGroupBy.nth

如果n是一个整数，则从每个组中取第n行，否则取行的一个子集。

可以是调用或索引。索引符号不可用于dropna。索引符号接受逗号分隔的整数和切片列表。

如果dropna，将取第n个非空行，dropna为all或any；这等同于在 groupby 之前调用 dropna(how=dropna)。

参数：

nint，切片或整数和切片的列表

一行的单个n值或n值的列表或切片。

版本 1.4.0 中的更改：添加了切片和包含切片的列表。添加了索引符号。

dropna，默认为 None

在计算第n行是哪一行之前，应用指定的 dropna 操作。仅当n是一个整数时支持。

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.SeriesGroupBy.nunique`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.nunique.html

SeriesGroupBy.nunique(dropna=True)

返回组内唯一元素的数量。

Series

每个组内唯一值的数量。

示例

对于 SeriesGroupby：

>>> lst = ['a', 'a', 'b', 'b']
>>> ser = pd.Series([1, 2, 3, 3], index=lst)
>>> ser
a    1
a    2
b    3
b    3
dtype: int64
>>> ser.groupby(level=0).nunique()
a    2
b    1
dtype: int64

对于 Resampler：

>>> ser = pd.Series([1, 2, 3, 3], 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    3
dtype: int64
>>> ser.resample('MS').nunique()
2023-01-01    2
2023-02-01    1
Freq: MS, dtype: int64

`pandas.core.groupby.SeriesGroupBy.unique`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.unique.html

SeriesGroupBy.unique()

返回每个分组的唯一值。

它返回每个分组的唯一值。按出现顺序返回。基于哈希表的唯一值，因此不会排序。

Series

每个分组的唯一值。

参见

Series.unique

返回 Series 对象的唯一值。

示例

>>> df = pd.DataFrame([('Chihuahua', 'dog', 6.1),
...                    ('Beagle', 'dog', 15.2),
...                    ('Chihuahua', 'dog', 6.9),
...                    ('Persian', 'cat', 9.2),
...                    ('Chihuahua', 'dog', 7),
...                    ('Persian', 'cat', 8.8)],
...                   columns=['breed', 'animal', 'height_in'])
>>> df
 breed     animal   height_in
0  Chihuahua        dog         6.1
1     Beagle        dog        15.2
2  Chihuahua        dog         6.9
3    Persian        cat         9.2
4  Chihuahua        dog         7.0
5    Persian        cat         8.8
>>> ser = df.groupby('animal')['breed'].unique()
>>> ser
animal
cat              [Persian]
dog    [Chihuahua, Beagle]
Name: breed, dtype: object

`pandas.core.groupby.SeriesGroupBy.ohlc`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.ohlc.html

SeriesGroupBy.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.SeriesGroupBy.pct_change`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.pct_change.html

SeriesGroupBy.pct_change(periods=1, fill_method=_NoDefault.no_default, limit=_NoDefault.no_default, freq=None, axis=_NoDefault.no_default)

计算每个值相对于前一个条目在组中的百分比变化。

系列或 DataFrame

每个组内的百分比变化。

另请参见

Series.groupby

将函数应用于系列的分组。

DataFrame.groupby

将函数应用于 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).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.SeriesGroupBy.prod`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.prod.html

SeriesGroupBy.prod(numeric_only=False, min_count=0)

计算组值的乘积。

参数：

numeric_onlybool，默认为 False

仅包括 float、int、boolean 列。

自 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.SeriesGroupBy.quantile`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.quantile.html

SeriesGroupBy.quantile(q=0.5, interpolation='linear', numeric_only=False)

返回给定分位数的组值，类似于 numpy.percentile。

参数：

qfloat 或类数组，默认为 0.5（50%分位数）

介于 0 和 1 之间的值提供要计算的分位数。

interpolation

当期望的分位数落在两个点之间时使用的方法。

numeric_only布尔值，默认为 False

仅包括浮点数、整数或布尔值数据。

新功能在版本 1.5.0 中引入。

在版本 2.0.0 中更改：numeric_only 现在默认为False。

Series 或 DataFrame

返回类型由 GroupBy 对象的调用方确定。

另请参阅

Series.quantile

Series 具有类似的方法。

DataFrame.quantile

DataFrame 具有类似的方法。

numpy.percentile

用于计算第 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.SeriesGroupBy.rank`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.rank.html

SeriesGroupBy.rank(method='average', ascending=True, na_option='keep', pct=False, axis=_NoDefault.no_default)

提供每个组内值的排名。

参数：

method，默认为‘average’

average：组的平均排名。
min：组内的最低排名。
max：组内的最高排名。
first：按数组中出现的顺序分配排名。
dense：类似于‘min’，但是排名在组之间始终增加 1。

ascending布尔值，默认为 True

False 表示按高（1）到低（N）的顺序排名。

na_option，默认为‘keep’

keep：保留 NA 值的位置。
top：如果升序，则是最小的排名。
bottom：如果降序，则是最小的排名。

pct布尔值，默认为 False

计算每个组内数据的百分位排名。

axis整数，默认为 0

计算排名的对象轴。

自版本 2.1.0 起弃用：对于 axis=1，直接在底层对象上操作。否则，axis 关键字是不必要的。

在每个组内值的排名 DataFrame

另请参阅

Series.groupby

对 Series 应用 groupby 函数。

DataFrame.groupby

对 DataFrame 的每一行或列应用 groupby 函数。

示例

>>> 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.SeriesGroupBy.resample`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.resample.html

SeriesGroupBy.resample(rule, *args, include_groups=True, **kwargs)

在使用 TimeGrouper 时提供重新取样。

给定一个 grouper，函数根据字符串“string” -> “frequency”进行重新取样。

有关更多详细信息，请参阅 frequency aliases 文档。

参数：

rulestr 或 DateOffset

目标 grouper 转换的偏移字符串或对象。

*args

可能的参数包括 how、fill_method、limit、kind 和 on，以及 TimeGrouper 的其他参数。

include_groupsbool，默认值为 True

当为 True 时，将尝试包含 DataFrame 中的分组在操作中。如果这引发了 TypeError，则结果将排除分组。当为 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

返回一个新的分组对象，其类型取决于被重新取样的数据。

另请参阅

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.SeriesGroupBy.rolling`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.rolling.html

SeriesGroupBy.rolling(*args, **kwargs)

返回一个滚动分组器，为每个组提供滚动功能。

参数：

windowint、timedelta、str、offset 或 BaseIndexer 子类

移动窗口的大小。

如果是整数，则为每个窗口使用的固定观测次数。

如果为 timedelta、str 或 offset，则每个窗口的时间段。每个窗口将根据包含在时间段中的观测值而变化大小。这仅适用于日期时间索引。要了解有关偏移量和频率字符串的更多信息，请参见此链接。

如果是 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

返回一个新的分组器，带有我们的滚动附加。

另请参见

Series.rolling

调用带有 Series 数据的对象。

DataFrame.rolling

调用带有 DataFrame 的对象。

Series.groupby

对 Series 应用一个分组函数。

DataFrame.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.SeriesGroupBy.sample`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.sample.html

SeriesGroupBy.sample(n=None, frac=None, replace=False, weights=None, random_state=None)

返回每个组的随机样本。

您可以使用 random_state 进行可重复性。

参数：

nint，可选

每个组要返回的项目数。如果 frac 为 None，则不能与 frac 一起使用，并且必须不大于最小的组。如果 replace 为 True，则默认值为一个。

fracfloat，可选

要返回的项目比例。不能与 n 一起使用。

replacebool，默认为 False

允许或禁止多次对同一行进行采样。

weights类似列表，可选

默认值 None 导致等概率加权。如果传入类似列表的对象，则其值必须与底层 DataFrame 或 Series 对象具有相同的长度，并且将在每个组内标准化后用作采样概率。值必须是非负的，并且每个组内必须至少有一个正元素。

random_stateint、类似数组、BitGenerator、np.random.RandomState、np.random.Generator，可选

如果为 int、类似数组或 BitGenerator，则为随机数生成器的种子。如果为 np.random.RandomState 或 np.random.Generator，则使用给定的值。

在版本 1.4.0 中更改：现在接受 np.random.Generator 对象

Series 或 DataFrame

返回一个与调用者相同类型的新对象，其中包含从调用者对象中每个组中随机抽取的项。

另请参阅

DataFrame.sample

从 DataFrame 对象中生成随机样本。

numpy.random.choice

从给定的 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.SeriesGroupBy.sem`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.sem.html

SeriesGroupBy.sem(ddof=1, numeric_only=False)

计算组的均值的标准误差，不包括缺失值。

对于多个分组，结果索引将是一个 MultiIndex。

参数：

ddof整数，默认为 1

自由度。

numeric_only布尔值，默认为 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.SeriesGroupBy.shift`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.shift.html

SeriesGroupBy.shift(periods=1, freq=None, axis=_NoDefault.no_default, fill_value=_NoDefault.no_default, suffix=None)

将每个组的观察值按周期移动。

如果传递了 freq，则将使用 periods 和 freq 增加索引。

参数：

periodsint | Sequence[int], 默认为 1

要移动的周期数。如果是值列表，则按每个周期移动每个组。

freqstr, 可选

频率字符串。

axis要移动的轴，默认为 0

移动方向。

自版本 2.1.0 起已弃用：对于 axis=1，应在底层对象上进行操作。否则，不需要 axis 关键字。

fill_value可选

用于新引入的缺失值的标量值。

自版本 2.1.0 起已更改：如果提供了 freq，将引发 ValueError。

suffixstr, 可选

如果有多个周期，则要添加到每个移动列的字符串。否则忽略。

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.SeriesGroupBy.size`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.size.html

SeriesGroupBy.size()

计算分组大小。

DataFrame 或 Series

如果 as_index 为 True，则每个分组的行数作为一个 Series，如果 as_index 为 False，则作为一个 DataFrame。

另请参阅

Series.groupby

将函数 groupby 应用于一个 Series。

DataFrame.groupby

将函数 groupby 应用于 DataFrame 的每一行或每一列。

示例

对于 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.SeriesGroupBy.skew`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.skew.html

SeriesGroupBy.skew(axis=_NoDefault.no_default, skipna=True, numeric_only=False, **kwargs)

返回组内的无偏倾斜。

通过 N-1 进行归一化。

参数：

axis，默认为 0

函数应用的轴。此参数仅用于与 DataFrame 兼容，并且未使用。

自版本 2.1.0 起弃用：对于 axis=1，操作在基础对象上进行。否则，axis 关键字不是必需的。

skipnabool，默认为 True

在计算结果时排除 NA/null 值。

numeric_onlybool，默认为 False

仅包括浮点数、整数、布尔值列。不适用于 Series。

**kwargs

要传递给函数的其他关键字参数。

Series

另请参阅

Series.skew

返回请求轴上的无偏倾斜度。

示例

>>> ser = pd.Series([390., 350., 357., np.nan, 22., 20., 30.],
...                 index=['Falcon', 'Falcon', 'Falcon', 'Falcon',
...                        'Parrot', 'Parrot', 'Parrot'],
...                 name="Max Speed")
>>> ser
Falcon    390.0
Falcon    350.0
Falcon    357.0
Falcon      NaN
Parrot     22.0
Parrot     20.0
Parrot     30.0
Name: Max Speed, dtype: float64
>>> ser.groupby(level=0).skew()
Falcon    1.525174
Parrot    1.457863
Name: Max Speed, dtype: float64
>>> ser.groupby(level=0).skew(skipna=False)
Falcon         NaN
Parrot    1.457863
Name: Max Speed, dtype: float64

`pandas.core.groupby.SeriesGroupBy.std`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.std.html

SeriesGroupBy.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_kwargs字典，默认值为 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.SeriesGroupBy.sum`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.sum.html

SeriesGroupBy.sum(numeric_only=False, min_count=0, engine=None, engine_kwargs=None)

计算组值的总和。

参数：

numeric_onlybool，默认为 False

仅包括浮点数、整数和布尔值列。

在 2.0.0 版本中更改：numeric_only不再接受None。

min_countint，默认为 0

执行操作所需的有效值的数量。如果少于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和apply groupby 聚合。

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.SeriesGroupBy.var`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.var.html

SeriesGroupBy.var(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 应用一个分组函数。

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).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.SeriesGroupBy.tail`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.tail.html

SeriesGroupBy.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.SeriesGroupBy.take`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.take.html

SeriesGroupBy.take(indices, axis=_NoDefault.no_default, **kwargs)

返回每个组中给定位置索引处的元素。

这意味着我们不是根据对象的索引属性中的实际值进行索引。我们是根据对象中元素的实际位置进行索引。

如果某些组的索引不存在，此方法将引发异常。要获得忽略不存在的索引的类似行为，请参见 SeriesGroupBy.nth().

参数：

indicesarray-like

一个 int 数组，指示在每个组中要获取的位置。

axis，默认 0

选择元素的轴。0 表示选择行，1 表示选择列。对于 SeriesGroupBy，此参数未使用且默认为 0。

从版本 2.1.0 开始弃用：对于 axis=1，请直接操作底层对象。否则，axis 关键字是不必要的。

**kwargs

为了与 numpy.take() 兼容。对输出没有影响。

系列

包含从每个组中取出的元素的系列。

另请参阅

Series.take

沿轴获取系列中的元素。

Series.loc

按标签选择 DataFrame 的子集。

Series.iloc

按位置选择 DataFrame 的子集。

numpy.take

沿轴从数组中获取元素。

SeriesGroupBy.nth

类似于 take，如果索引不存在，则不会引发异常。

示例

>>> 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["name"].groupby([1, 1, 2, 2, 2])

在每个组中沿轴 0 获取位置为 0 和 1 的元素（默认）。

>>> gb.take([0, 1])
1  4    falcon
 3    parrot
2  2      lion
 1    monkey
Name: name, dtype: object

我们可以使用负整数来获取正整数索引，从对象的末尾开始，就像 Python 列表一样。

>>> gb.take([-1, -2])
1  3    parrot
 4    falcon
2  0    rabbit
 1    monkey
Name: name, dtype: object

`pandas.core.groupby.SeriesGroupBy.value_counts`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.value_counts.html

SeriesGroupBy.value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)

`pandas.core.groupby.DataFrameGroupBy.boxplot`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.boxplot.html

DataFrameGroupBy.boxplot(subplots=True, column=None, fontsize=None, rot=0, grid=True, ax=None, figsize=None, layout=None, sharex=False, sharey=True, backend=None, **kwargs)

从 DataFrameGroupBy 数据制作箱线图。

参数：

grouped分组的 DataFrame

subplots布尔值

False - 不使用子图
True - 为每个组创建一个子图。

column列名或列名列表，或向量

可以是任何有效的 groupby 输入。

fontsize浮点数或字符串

rot标签旋转角度

grid将其设置为 True 将显示网格

axMatplotlib 轴对象，默认为 None

figsize以英寸为单位的元组（宽度，高度）

layout元组（可选）

绘图的布局：（行，列）。

sharex布尔值，默认为 False

x 轴是否在子图之间共享。

sharey布尔值，默认为 True

是否在子图之间共享 y 轴。

backend字符串，默认为 None

要使用的后端，而不是在选项plotting.backend中指定的后端。例如，'matplotlib'。或者，要为整个会话指定plotting.backend，请设置pd.options.plotting.backend。

**kwargs

所有其他绘图关键字参数将传递给 matplotlib 的 boxplot 函数。

键/值对的字典=组键/DataFrame.boxplot 返回值

或者在 subplots=figures=False 的情况下返回 DataFrame.boxplot 的返回值

示例

您可以为分组数据创建箱线图，并将它们显示为单独的子图：

>>> import itertools
>>> tuples = [t for t in itertools.product(range(1000), range(4))]
>>> index = pd.MultiIndex.from_tuples(tuples, names=['lvl0', 'lvl1'])
>>> data = np.random.randn(len(index), 4)
>>> df = pd.DataFrame(data, columns=list('ABCD'), index=index)
>>> grouped = df.groupby(level='lvl1')
>>> grouped.boxplot(rot=45, fontsize=12, figsize=(8, 10))

选项subplots=False将在单个图中显示箱线图。

>>> grouped.boxplot(subplots=False, rot=45, fontsize=12)

`pandas.core.groupby.DataFrameGroupBy.hist`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.hist.html

DataFrameGroupBy.hist(column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, backend=None, legend=False, **kwargs)

制作 DataFrame 列的直方图。

直方图是数据分布的表示。此函数在 DataFrame 中的每个系列上调用matplotlib.pyplot.hist()，从而每列产生一个直方图。

参数：

dataDataFrame

包含数据的 pandas 对象。

columnstr 或序列，可选

如果传入，将用于将数据限制为列的子集。

by对象，可选

如果传入，则用于为不同组形成直方图。

gridbool，默认为 True

是否显示轴网格线。

xlabelsizeint，默认为 None

如果指定，更改 x 轴标签大小。

xrotfloat，默认为 None

x 轴标签的旋转。例如，值为 90 会将 x 标签顺时针旋转 90 度。

ylabelsizeint，默认为 None

如果指定，更改 y 轴标签大小。

yrotfloat，默认为 None

y 轴标签的旋转。例如，值为 90 会将 y 标签顺时针旋转 90 度。

axMatplotlib axes object, 默认为 None

要在其上绘制直方图的轴。

sharexbool，默认为 True 如果 ax 为 None，否则为 False

如果 subplots=True，则共享 x 轴并将一些 x 轴标签设置为不可见；如果 ax 为 None，则默认为 True，否则如果传入了 ax，则为 False。请注意，同时传入 ax 和 sharex=True 将改变图中所有子图的所有 x 轴标签。

shareybool，默认为 False

如果 subplots=True，则共享 y 轴并将一些 y 轴标签设置为不可见。

figsize元组，可选

要创建的图的英寸大小。默认情况下使用 matplotlib.rcParams 中的值。

layout元组，可选

用于直方图布局的元组（行，列）。

binsint 或序列，默认为 10

��使用的直方图箱数。如果给定整数，则计算并返回 bins + 1 个箱边。如果 bins 是一个序列，则给出箱边，包括第一个箱的左边缘和最后一个箱的右边缘。在这种情况下，bins 将不经修改地返回。

backendstr，默认为 None

要使用的后端，而不是在选项plotting.backend中指定的后端。例如，'matplotlib'。或者，要为整个会话指定plotting.backend，请设置pd.options.plotting.backend。

legendbool，默认为 False

是否显示图例。

**kwargs

要传递给matplotlib.pyplot.hist()的所有其他绘图关键字参数。

matplotlib.AxesSubplot 或其 numpy.ndarray

参见

matplotlib.pyplot.hist

使用 matplotlib 绘制直方图。

示例

此示例基于一些动物的长度和宽度绘制直方图，显示在三个 bin 中

>>> data = {'length': [1.5, 0.5, 1.2, 0.9, 3],
...         'width': [0.7, 0.2, 0.15, 0.2, 1.1]}
>>> index = ['pig', 'rabbit', 'duck', 'chicken', 'horse']
>>> df = pd.DataFrame(data, index=index)
>>> hist = df.hist(bins=3)

`pandas.core.groupby.SeriesGroupBy.hist`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.hist.html

SeriesGroupBy.hist(by=None, ax=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, figsize=None, bins=10, backend=None, legend=False, **kwargs)

使用 matplotlib 绘制输入系列的直方图。

参数：

by对象，可选

如果传递，则用于为单独的组形成直方图。

axmatplotlib 轴对象

如果未传递，使用 gca()。

gridbool，默认为 True

是否显示坐标轴网格线。

xlabelsizeint，默认为 None

如果指定，更改 x 轴标签大小。

xrotfloat，默认为 None

x 轴标签的旋转。

ylabelsizeint，默认为 None

如果指定，更改 y 轴标签大小。

yrotfloat，默认为 None

y 轴标签的旋转。

figsize元组，默认为 None

默认为英寸的图形大小。

binsint 或序列，默认为 10

要使用的直方图箱数。如果给定整数，则计算并返回 bins + 1 个箱边缘。如果 bins 是一个序列，则给出箱边缘，包括第一个箱的左边缘和最后一个箱的右边缘。在这种情况下，bins 将保持不变。

backendstr，默认为 None

要使用的后端，而不是在选项 plotting.backend 中指定的后端。例如，'matplotlib'。或者，要为整个会话指定 plotting.backend，请设置 pd.options.plotting.backend。

legendbool，默认为 False

是否显示图例。

**kwargs

要传递给实际绘图函数。

matplotlib.AxesSubplot

一个直方图图表。

另请参阅

matplotlib.axes.Axes.hist

使用 matplotlib 绘制直方图。

示例

对于 Series：

>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)
>>> hist = ser.hist()

对于 Groupby：

>>> lst = ['a', 'a', 'a', 'b', 'b', 'b']
>>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)
>>> hist = ser.groupby(level=0).hist()

`pandas.core.groupby.DataFrameGroupBy.plot`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.DataFrameGroupBy.plot.html

property DataFrameGroupBy.plot

绘制 Series 或 DataFrame 的图。

使用由选项plotting.backend指定的后端。默认情况下，使用 matplotlib。

参数：

dataSeries 或 DataFrame

调用该方法的对象。

x标签或位置，默认为 None

仅当数据是 DataFrame 时使用。

y标签、位置或标签列表，默认为 None

允许绘制一列与另一列的图。仅当数据是 DataFrame 时使用。

kind字符串

要生成的图的类型：

‘line’ ：线图（默认）
‘bar’ ：垂直条形图
‘barh’ ：水平条形图
‘hist’ ：直方图
‘box’ ：箱线图
‘kde’ ：核密度估计图
‘density’ ：与‘kde’相同
‘area’ ：面积图
‘pie’ ：饼图
‘scatter’ ：散点图（仅 DataFrame）
‘hexbin’ ：六边形图（仅 DataFrame）

axmatplotlib 轴对象，默认为 None

当前图的轴。

subplots布尔值或迭代序列，默认为 False

是否将列分组为子图：

False ：不使用子图
True ：为每列绘制单独的子图。
列标签的迭代序列：为每组列创建一个子图。例如[(‘a’, ‘c’), (‘b’, ‘d’)]将创建 2 个子图：一个包含列‘a’和‘c’，另一个包含列‘b’和‘d’。未指定的剩余列将在额外的子图中绘制（每列一个）。

新版本 1.5.0 中的新功能。

sharex布尔值，默认为 None（matlab 样式默认值）

如果subplots=True，则共享 x 轴并将一些 x 轴标签设置为不可见；如果没有传递 ax，则默认为 True，否则如果传递了 ax，则为 False；请注意，传递 ax 和sharex=True将改变图中所有轴的所有 x 轴标签。

sharey布尔值，默认为 False

如果subplots=True，则共享 y 轴并设置一些 y 轴标签为不可见。

layout元组，可选

子图布局的（行，列）。

figsize一个元组（宽度，高度），单位为英寸

图对象的大小。

use_index布尔值，默认为 True

将索引用作 x 轴的刻度。

title字符串或列表

绘制图表时使用的标题。如果传递了字符串，则在图的顶部打印字符串。如果传递了列表并且subplots为 True，则在相应的子图上方打印列表中的每个项目。

grid布尔值，默认为 None（matlab 样式默认值）

轴网格线。

legend布尔值或{‘reverse’}

将图例放置在轴子图上。

style列表或字典

每列的 matplotlib 线样式。

logx布尔值或‘sym’，默认为 False

在 x 轴上使用对数比例尺或对数对比例尺。

logy布尔值或‘sym’默认为 False

在 y 轴上使用对数比例尺或对数对比例尺。

loglog布尔值或‘sym’，默认为 False

在 x 和 y 轴上使用对数比例尺或对数对比例尺。

xticks序列

用于 xticks 的值。

yticks序列

用于 yticks 的值。

xlim2-元组/列表

设置当前坐标轴的 x 范围。

ylim 2-元组/列表

设置当前坐标轴的 y 范围。

xlabel 标签，可选

用于 x 轴的 xlabel 的名称。默认使用索引名称作为 xlabel，或者对于平面图，使用 x 列名称。

在 2.0.0 版中更改：现在适用于直方图。

ylabel 标签，可选

用于 y 轴的 ylabel 的名称。默认不显示 ylabel，或者对于平面图，使用 y 列名称。

在 2.0.0 版中更改：现在适用于直方图。

rot 浮点数，默认�� None

刻度的旋转（垂直图的 xticks，水平图的 yticks）。

fontsize 浮点数，默认为 None

xticks 和 yticks 的字体大小。

colormap 字符串或 matplotlib 色图对象，默认为 None

选择颜色的色图。如果是字符串，则从 matplotlib 加载具有该名称的色图。

colorbar 布尔值，可选

如果为 True，则绘制颜色条（仅适用于“scatter”和“hexbin”图）。

position 浮点数

指定条形图布局的相对对齐方式。从 0（左/底部）到 1（右/顶部）。默认为 0.5（中心）。

table 布尔值、Series 或 DataFrame，默认为 False

如果为 True，则使用 DataFrame 中的数据绘制表格，并且数据将被转置以符合 matplotlib 的默认布局。如果传递了 Series 或 DataFrame，则使用传递的数据绘制表格。

yerr DataFrame、Series、类数组、字典和字符串

详细信息请参见带有误差条的绘图。

xerrDataFrame、Series、类数组、字典和字符串

与 yerr 相当。

stacked 布尔值，默认为线图和条形图中的 False，面积图中的 True

如果为 True，则创建堆叠图。

secondary_y 布尔值或序列，默认为 False

如果是列表/元组，则是否在次要 y 轴上绘图，以及要在次要 y 轴上绘制哪些列。

mark_right 布尔值，默认为 True

在使用 secondary_y 轴时，在图例中自动标记列标签为“(right)”。

include_bool 布尔值，默认为 False

如果为 True，则可以绘制布尔值。

backend 字符串，默认为 None

要使用的后端，而不是在选项 plotting.backend 中指定的后端。例如，“matplotlib”。或者，要为整个会话指定 plotting.backend，请设置 pd.options.plotting.backend。

**kwargs

传递给 matplotlib 绘图方法的选项。

matplotlib.axes.Axes 或其 numpy.ndarray

如果后端不是默认的 matplotlib，则返回值将是后端返回的对象。

注意

有关此主题的更多信息，请在线查看 matplotlib 文档。
如果 kind = 'bar' 或 'barh'，则可以通过 position 关键字指定条形图布局的相对对齐方式。从 0（左/底部）到 1（右/顶部）。默认为 0.5（中心）。

示例

对于 Series：

>>> ser = pd.Series([1, 2, 3, 3])
>>> plot = ser.plot(kind='hist', title="My plot")

对于 DataFrame：

>>> df = pd.DataFrame({'length': [1.5, 0.5, 1.2, 0.9, 3],
...                   'width': [0.7, 0.2, 0.15, 0.2, 1.1]},
...                   index=['pig', 'rabbit', 'duck', 'chicken', 'horse'])
>>> plot = df.plot(title="DataFrame Plot")

对于 SeriesGroupBy：

>>> lst = [-1, -2, -3, 1, 2, 3]
>>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)
>>> plot = ser.groupby(lambda x: x > 0).plot(title="SeriesGroupBy Plot")

对于 DataFrameGroupBy：

>>> df = pd.DataFrame({"col1" : [1, 2, 3, 4],
...                   "col2" : ["A", "B", "A", "B"]})
>>> plot = df.groupby("col2").plot(kind="bar", title="DataFrameGroupBy Plot")

`pandas.core.groupby.SeriesGroupBy.plot`

原文：pandas.pydata.org/docs/reference/api/pandas.core.groupby.SeriesGroupBy.plot.html

property SeriesGroupBy.plot

绘制 Series 或 DataFrame 的图。

使用选项plotting.backend指定的后端。默认情况下，使用 matplotlib。

参数：

dataSeries 或 DataFrame

调用方法的对象。

x标签或位置，默认为 None

仅当数据为 DataFrame 时使用。

y标签、位置或标签列表、位置，默认为 None

允许绘制一列与另一列。仅当数据为 DataFrame 时使用。

kind字符串

要生成的图的类型：

‘line’：线图（默认）
‘bar’：垂直条形图
‘barh’：水平条形图
‘hist’：直方图
‘box’：箱线图
‘kde’：核密度估计图
‘density’：与‘kde’相同
‘area’：面积图
‘pie’：饼图
‘scatter’：散点图（仅限 DataFrame）
‘hexbin’：六边形图（仅限 DataFrame）

axmatplotlib 轴对象，默认为 None

当前图形的轴。

subplots布尔值或迭代序列，默认为 False

是否将列分组到子图中：

False：不使用子图
True：为每列创建单独的子图。
列标签的迭代序列的序列：为每组列创建一个子图。例如[(‘a’, ‘c’)，（‘b’，‘d’）]将创建 2 个子图：一个具有列‘a’和‘c’，一个具有列‘b’和‘d’。未指定的剩余列将在附加子图中绘制（每列一个）。

版本 1.5.0 中的新功能。

sharex布尔值，默认为 True（如果 ax 为 None）否则为 False。

如果subplots=True，则共享 x 轴并将一些 x 轴标签设置为不可见；如果 ax 为 None，则默认为 True，否则为 False；请注意，同时传入 ax 和sharex=True将更改图形中所有轴的所有 x 轴标签。

sharey布尔值，默认为 False

如果subplots=True，则共享 y 轴并将一些 y 轴标签设置为不可见。

layout元组，可选

（行，列）用于子图的布局。

figsize元组（宽度，高度），单位为英寸

图形对象的大小。

use_index布尔值，默认为 True

在 x 轴上使用索引作为刻度。

title字符串或列表

用于绘图的标题。如果传递了字符串，则在图的顶部打印字符串。如果传递了列表且 subplots 为 True，则在对应的子图上方打印列表中的每个项目。

grid布尔值，默认为 None（matlab 样式默认）

轴网格线。

legend布尔值或{‘reverse’}

在轴子图上放置图例。

style列表或字典

每列的 matplotlib 线样式。

logx布尔值或‘sym’，默认为 False

在 x 轴上使用对数比例或对数对数比例。

logy布尔值或‘sym’，默认为 False

在 x 轴上使用对数比例或对数对数比例。

loglog布尔值或‘sym’，默认为 False

在 x 轴上使用对数比例或对数对数比例。

xticks序列

用于 xticks 的值。

yticks序列

用于 yticks 的值。

xlim2 元组/列表

设置当前轴的 x 限制。

ylim2 元组/列表

设置当前轴的 y 限制。

xlabel标签，可选

用于 x 轴的 xlabel 的名称。默认情况下，使用索引名称作为 xlabel，或者对于平面图，使用 x 列名。

版本 2.0.0 中的更改：现在适用于直方图。

ylabel标签，可选

用于 y 轴的 ylabel 的名称。默认情况下不显示 ylabel，或者对于平面图，显示 y 列名。

版本 2.0.0 中的更改：现在适用于直方图。

rot浮点数，默认为 None

刻度线的旋转角度（垂直方向的 xticks，水平方向的 yticks）。

fontsize浮点数，默认为 None

xticks 和 yticks 的字体大小。

colormap字符串或 matplotlib 色图对象，默认为 None

从中选择颜色的色图。如果是字符串，则从 matplotlib 加载该名称的色图。

colorbar布尔值，可选

如果为 True，则绘制颜色条（仅对‘scatter’和‘hexbin’绘图有效）。

position浮点数

指定条形图布局的相对对齐方式。从 0（左/底部）到 1（右/顶部）。默认值为 0.5（中心）。

table布尔值、Series 或 DataFrame，默认为 False

如果为 True，则使用 DataFrame 中的数据绘制表，并且数据将被转置以满足 matplotlib 的默认布局。如果传递了 Series 或 DataFrame，则使用传递的数据绘制表。

yerrDataFrame、Series、类数组、字典和字符串

详情请参阅带误差条的绘图。

xerrDataFrame、Series、类数组、字典和字符串

等同于 yerr。

stacked布尔值，默认为线图和柱状图中的 False，区域图中为 True

如果为 True，则创建堆叠图。

secondary_y布尔值或序列，默认为 False

如果是列表/元组，则是否在辅助 y 轴上绘制图表，以及在辅助 y 轴上绘制哪些列。

mark_right布尔值，默认为 True

使用 secondary_y 轴时，在图例中自动标记列标签为“(right)”。

include_bool布尔值，默认为 False

如果为 True，则可以绘制布尔值。

backend字符串，默认为 None

要使用的后端，而不是在选项plotting.backend中指定的后端。例如，“matplotlib”。或者，要为整个会话指定plotting.backend，请设置pd.options.plotting.backend。

**kwargs

传递给 matplotlib 绘图方法的选项。

matplotlib.axes.Axes 或其 numpy.ndarray

如果后端不是默认的 matplotlib，则返回值将是后端返回的对象。

注释

在网上查看 matplotlib 文档以了解更多信息
如果 kind=‘bar’或‘barh’，则可以通过 position 关键字指定条形图布局的相对对齐方式。从 0（左/底部）到 1（右/顶部）。默认值为 0.5（中心）。

示例

对于 Series：

>>> ser = pd.Series([1, 2, 3, 3])
>>> plot = ser.plot(kind='hist', title="My plot")

对于 DataFrame：

>>> df = pd.DataFrame({'length': [1.5, 0.5, 1.2, 0.9, 3],
...                   'width': [0.7, 0.2, 0.15, 0.2, 1.1]},
...                   index=['pig', 'rabbit', 'duck', 'chicken', 'horse'])
>>> plot = df.plot(title="DataFrame Plot")

对于 SeriesGroupBy：

>>> lst = [-1, -2, -3, 1, 2, 3]
>>> ser = pd.Series([1, 2, 2, 4, 6, 6], index=lst)
>>> plot = ser.groupby(lambda x: x > 0).plot(title="SeriesGroupBy Plot")

对于 DataFrameGroupBy：

>>> df = pd.DataFrame({"col1" : [1, 2, 3, 4],
...                   "col2" : ["A", "B", "A", "B"]})
>>> plot = df.groupby("col2").plot(kind="bar", title="DataFrameGroupBy Plot")

重新采样

原文：pandas.pydata.org/docs/reference/resampling.html

pandas.api.typing.Resampler 实例由重新采样调用返回：pandas.DataFrame.resample(), pandas.Series.resample().

索引、迭代

`Resampler.__iter__`()	分组迭代器。
`Resampler.groups`	字典 {组名 -> 组标签}。
`Resampler.indices`	字典 {组名 -> 组索引}。
`Resampler.get_group`(name[, obj])	使用提供的名称构造组的 DataFrame。

函数应用

`Resampler.apply`([func])	使用一个或多个操作在指定轴上聚合。
`Resampler.aggregate`([func])	使用一个或多个操作在指定轴上聚合。
`Resampler.transform`(arg, args, *kwargs)	在每个分组上调用生成类似索引 Series 的函数。
`Resampler.pipe`(func, args, *kwargs)	将 `func` 与参数应用于此 Resampler 对象并返回其结果。

上采样

`Resampler.ffill`([limit])	向前填充值。
`Resampler.bfill`([limit])	在重新采样数据中向后填充新的缺失值。
`Resampler.nearest`([limit])	使用最近的值重新采样。
`Resampler.fillna`(method[, limit])	填充由上采样引入的缺失值。
`Resampler.asfreq`([fill_value])	返回新频率的值，实质上是重新索引。
`Resampler.interpolate`([method, axis, limit, ...])	根据不同的方法在目标时间戳之间插值。

计算 / 描述性统计

`Resampler.count`()	计算组的计数，不包括缺失值。
`Resampler.nunique`(args, *kwargs)	返回组中唯一元素的数量。
`Resampler.first`([numeric_only, min_count, ...])	计算每个组内每列的第一个条目。
`Resampler.last`([numeric_only, min_count, skipna])	计算每个组内每列的最后一个条目。
`Resampler.max`([numeric_only, min_count])	计算组的最大值。
`Resampler.mean`([numeric_only])	计算组的平均值，不包括缺失值。
`Resampler.median`([numeric_only])	计算组的中位数，不包括缺失值。
`Resampler.min`([numeric_only, min_count])	计算组的最小值。
`Resampler.ohlc`(args, *kwargs)	计算组的开盘价、最高价、最低价和收盘价，不包括缺失值。
`Resampler.prod`([numeric_only, min_count])	计算组值的乘积。
`Resampler.size`()	计算组大小。
`Resampler.sem`([ddof, numeric_only])	计算组均值的标准误差，排除缺失值。
`Resampler.std`([ddof, numeric_only])	计算组的标准差，排除缺失值。
`Resampler.sum`([numeric_only, min_count])	计算组值的总和。
`Resampler.var`([ddof, numeric_only])	计算组的方差，排除缺失值。
`Resampler.quantile`([q])	返回给定分位数处的值。

索引、迭代

`Resampler.__iter__`()	分组迭代器。
`Resampler.groups`	字典 {组名称 -> 组标签}。
`Resampler.indices`	字典 {组名称 -> 组索引}。
`Resampler.get_group`(name[, obj])	使用提供的名称构造组 DataFrame。

函数应用

`Resampler.apply`([func])	使用一个或多个操作在指定轴上聚合。
`Resampler.aggregate`([func])	使用一个或多个操作在指定轴上聚合。
`Resampler.transform`(arg, args, *kwargs)	调用函数，在每个分组上生成类似索引的 Series。
`Resampler.pipe`(func, args, *kwargs)	对此 Resampler 对象应用带参数的 `func` 并返回其结果。

上采样

`Resampler.ffill`([limit])	前向填充值。
`Resampler.bfill`([limit])	向后填充重新采样数据中的新缺失值。
`Resampler.nearest`([limit])	使用最近的值重新采样。
`Resampler.fillna`(method[, limit])	填充由上采样引入的缺失值。
`Resampler.asfreq`([fill_value])	返回新频率的值，本质上是重新索引。
`Resampler.interpolate`([method, axis, limit, ...])	根据不同的方法在目标时间戳之间插值。

计算 / 描述性统计

`Resampler.count`()	计算组的计数，不包括缺失值。
`Resampler.nunique`(args, *kwargs)	返回组中唯一元素的数量。
`Resampler.first`([numeric_only, min_count, ...])	计算每个组中每列的第一个条目。
`Resampler.last`([numeric_only, min_count, skipna])	计算每个组中每列的最后一个条目。
`Resampler.max`([numeric_only, min_count])	计算组的最大值。
`Resampler.mean`([numeric_only])	计算组的均值，不包括缺失值。
`Resampler.median`([numeric_only])	计算组的中位数，不包括缺失值。
`Resampler.min`([numeric_only, min_count])	计算组的最小值。
`Resampler.ohlc`(args, *kwargs)	计算组的开盘价、最高价、最低价和收盘价，不包括缺失值。
`Resampler.prod`([numeric_only, min_count])	计算组值的乘积。
`Resampler.size`()	计算组的大小。
`Resampler.sem`([ddof, numeric_only])	计算组的均值标准误差，不包括缺失值。
`Resampler.std`([ddof, numeric_only])	计算组的标准差，不包括缺失值。
`Resampler.sum`([numeric_only, min_count])	计算组值的总和。
`Resampler.var`([ddof, numeric_only])	计算组的方差，不包括缺失值。
`Resampler.quantile`([q])	返回给定分位数的值。

posted @ 2024-06-26 10:31 绝不原创的飞龙阅读(43) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Pandas-2-2-中文文档-三十五-

Pandas 2.2 中文文档（三十五）

pandas.core.groupby.SeriesGroupBy.all

pandas.core.groupby.SeriesGroupBy.any

pandas.core.groupby.SeriesGroupBy.bfill

pandas.core.groupby.SeriesGroupBy.corr

pandas.core.groupby.SeriesGroupBy.count

pandas.core.groupby.SeriesGroupBy.cov

pandas.core.groupby.SeriesGroupBy.cumcount

pandas.core.groupby.SeriesGroupBy.cummax

pandas.core.groupby.SeriesGroupBy.cummin

pandas.core.groupby.SeriesGroupBy.cumprod

pandas.core.groupby.SeriesGroupBy.cumsum

pandas.core.groupby.SeriesGroupBy.describe

pandas.core.groupby.SeriesGroupBy.diff

pandas.core.groupby.SeriesGroupBy.ffill

pandas.core.groupby.SeriesGroupBy.fillna

pandas.core.groupby.SeriesGroupBy.first

pandas.core.groupby.SeriesGroupBy.head

pandas.core.groupby.SeriesGroupBy.last

pandas.core.groupby.SeriesGroupBy.idxmax

pandas.core.groupby.SeriesGroupBy.idxmin

pandas.core.groupby.SeriesGroupBy.is_monotonic_increasing

pandas.core.groupby.SeriesGroupBy.is_monotonic_decreasing

pandas.core.groupby.SeriesGroupBy.max

pandas.core.groupby.SeriesGroupBy.mean

pandas.core.groupby.SeriesGroupBy.median

pandas.core.groupby.SeriesGroupBy.min

pandas.core.groupby.SeriesGroupBy.ngroup

pandas.core.groupby.SeriesGroupBy.nlargest

pandas.core.groupby.SeriesGroupBy.nsmallest

pandas.core.groupby.SeriesGroupBy.nth

pandas.core.groupby.SeriesGroupBy.nunique

pandas.core.groupby.SeriesGroupBy.unique

pandas.core.groupby.SeriesGroupBy.ohlc

pandas.core.groupby.SeriesGroupBy.pct_change

pandas.core.groupby.SeriesGroupBy.prod

pandas.core.groupby.SeriesGroupBy.quantile

pandas.core.groupby.SeriesGroupBy.rank

pandas.core.groupby.SeriesGroupBy.resample

pandas.core.groupby.SeriesGroupBy.rolling

pandas.core.groupby.SeriesGroupBy.sample

pandas.core.groupby.SeriesGroupBy.sem

pandas.core.groupby.SeriesGroupBy.shift

pandas.core.groupby.SeriesGroupBy.size

pandas.core.groupby.SeriesGroupBy.skew

pandas.core.groupby.SeriesGroupBy.std

pandas.core.groupby.SeriesGroupBy.sum

pandas.core.groupby.SeriesGroupBy.var

pandas.core.groupby.SeriesGroupBy.tail

pandas.core.groupby.SeriesGroupBy.take

pandas.core.groupby.SeriesGroupBy.value_counts

pandas.core.groupby.DataFrameGroupBy.boxplot

pandas.core.groupby.DataFrameGroupBy.hist

pandas.core.groupby.SeriesGroupBy.hist

pandas.core.groupby.DataFrameGroupBy.plot

pandas.core.groupby.SeriesGroupBy.plot

重新采样

索引、迭代

函数应用

上采样

计算 / 描述性统计

索引、迭代

函数应用

上采样

计算 / 描述性统计

公告

`pandas.core.groupby.SeriesGroupBy.all`

`pandas.core.groupby.SeriesGroupBy.any`

`pandas.core.groupby.SeriesGroupBy.bfill`

`pandas.core.groupby.SeriesGroupBy.corr`

`pandas.core.groupby.SeriesGroupBy.count`

`pandas.core.groupby.SeriesGroupBy.cov`

`pandas.core.groupby.SeriesGroupBy.cumcount`

`pandas.core.groupby.SeriesGroupBy.cummax`

`pandas.core.groupby.SeriesGroupBy.cummin`

`pandas.core.groupby.SeriesGroupBy.cumprod`

`pandas.core.groupby.SeriesGroupBy.cumsum`

`pandas.core.groupby.SeriesGroupBy.describe`

`pandas.core.groupby.SeriesGroupBy.diff`

`pandas.core.groupby.SeriesGroupBy.ffill`

`pandas.core.groupby.SeriesGroupBy.fillna`

`pandas.core.groupby.SeriesGroupBy.first`

`pandas.core.groupby.SeriesGroupBy.head`

`pandas.core.groupby.SeriesGroupBy.last`

`pandas.core.groupby.SeriesGroupBy.idxmax`

`pandas.core.groupby.SeriesGroupBy.idxmin`

`pandas.core.groupby.SeriesGroupBy.is_monotonic_increasing`

`pandas.core.groupby.SeriesGroupBy.is_monotonic_decreasing`

`pandas.core.groupby.SeriesGroupBy.max`

`pandas.core.groupby.SeriesGroupBy.mean`

`pandas.core.groupby.SeriesGroupBy.median`

`pandas.core.groupby.SeriesGroupBy.min`

`pandas.core.groupby.SeriesGroupBy.ngroup`

`pandas.core.groupby.SeriesGroupBy.nlargest`

`pandas.core.groupby.SeriesGroupBy.nsmallest`

`pandas.core.groupby.SeriesGroupBy.nth`

`pandas.core.groupby.SeriesGroupBy.nunique`

`pandas.core.groupby.SeriesGroupBy.unique`

`pandas.core.groupby.SeriesGroupBy.ohlc`

`pandas.core.groupby.SeriesGroupBy.pct_change`

`pandas.core.groupby.SeriesGroupBy.prod`

`pandas.core.groupby.SeriesGroupBy.quantile`

`pandas.core.groupby.SeriesGroupBy.rank`

`pandas.core.groupby.SeriesGroupBy.resample`

`pandas.core.groupby.SeriesGroupBy.rolling`

`pandas.core.groupby.SeriesGroupBy.sample`

`pandas.core.groupby.SeriesGroupBy.sem`

`pandas.core.groupby.SeriesGroupBy.shift`

`pandas.core.groupby.SeriesGroupBy.size`

`pandas.core.groupby.SeriesGroupBy.skew`

`pandas.core.groupby.SeriesGroupBy.std`

`pandas.core.groupby.SeriesGroupBy.sum`

`pandas.core.groupby.SeriesGroupBy.var`

`pandas.core.groupby.SeriesGroupBy.tail`

`pandas.core.groupby.SeriesGroupBy.take`

`pandas.core.groupby.SeriesGroupBy.value_counts`

`pandas.core.groupby.DataFrameGroupBy.boxplot`

`pandas.core.groupby.DataFrameGroupBy.hist`

`pandas.core.groupby.SeriesGroupBy.hist`

`pandas.core.groupby.DataFrameGroupBy.plot`

`pandas.core.groupby.SeriesGroupBy.plot`