Pandas-2-2-中文文档-二十一-

Pandas 2.2 中文文档（二十一）

原文：pandas.pydata.org/docs/

`pandas.DataFrame.gt`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.gt.html

DataFrame.gt(other, axis='columns', level=None)

获取 DataFrame 和其他元素的大于关系，逐元素进行（二进制运算符 gt）。

在灵活的包装器（eq、ne、le、lt、ge、gt）中，用于比较运算符。

等同于==、!=、<=、<、>=、>，支持选择轴（行或列）和级别进行比较。

参数：

其他标量、序列、Series 或 DataFrame

任何单个或多个元素数据结构，或类似列表的对象。

轴，默认为'columns'

是否通过索引（0 或'index'）或列（1 或'columns'）进行比较。

级别整数或标签

在一个级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。

布尔值的 DataFrame

比较的结果。

参见

DataFrame.eq

逐元素比较 DataFrame 是否相等。

DataFrame.ne

逐元素比较 DataFrame 是否不等。

DataFrame.le

逐元素比较 DataFrame 是否小于或等于。

DataFrame.lt

逐元素比较 DataFrame 是否严格小于。

DataFrame.ge

逐元素比较 DataFrame 是否大于或等于。

DataFrame.gt

逐元素比较 DataFrame 是否严格大于。

注意

不匹配的索引将被合并在一起。NaN 值被视为不同（即 NaN != NaN）。

示例

>>> df = pd.DataFrame({'cost': [250, 150, 100],
...                    'revenue': [100, 250, 300]},
...                   index=['A', 'B', 'C'])
>>> df
 cost  revenue
A   250      100
B   150      250
C   100      300

与标量进行比较，可以使用运算符或方法：

>>> df == 100
 cost  revenue
A  False     True
B  False    False
C   True    False

>>> df.eq(100)
 cost  revenue
A  False     True
B  False    False
C   True    False

当其他是Series时，DataFrame 的列与其他的索引对齐并进行广播：

>>> df != pd.Series([100, 250], index=["cost", "revenue"])
 cost  revenue
A   True     True
B   True    False
C  False     True

使用该方法来控制广播轴：

>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
 cost  revenue
A  True    False
B  True     True
C  True     True
D  True     True

当与任意序列进行比较时，列数必须与其他元素的数量相匹配：

>>> df == [250, 100]
 cost  revenue
A   True     True
B  False    False
C  False    False

使用该方法来控制轴：

>>> df.eq([250, 250, 100], axis='index')
 cost  revenue
A   True    False
B  False     True
C   True    False

与形状不同的 DataFrame 进行比较。

>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]},
...                      index=['A', 'B', 'C', 'D'])
>>> other
 revenue
A      300
B      250
C      100
D      150

>>> df.gt(other)
 cost  revenue
A  False    False
B  False    False
C  False     True
D  False    False

通过级别比较 MultiIndex。

>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220],
...                              'revenue': [100, 250, 300, 200, 175, 225]},
...                             index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
...                                    ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
 cost  revenue
Q1 A   250      100
 B   150      250
 C   100      300
Q2 A   150      200
 B   300      175
 C   220      225

>>> df.le(df_multindex, level=1)
 cost  revenue
Q1 A   True     True
 B   True     True
 C   True     True
Q2 A  False     True
 B   True    False
 C   True    False

`pandas.DataFrame.le`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.le.html

DataFrame.le(other, axis='columns', level=None)

获取数据帧和其他的小于或等于，逐元素（二进制运算符 le）。

在灵活的包装器（eq，ne，le，lt，ge，gt）中使用比较运算符。

等同于==，！=，<=，<，>=，>，支持选择轴（行或列）和级别进行比较。

参数：

other标量，序列，Series 或 DataFrame

任何单个或多个元素数据结构，或类似列表的对象。

轴，默认为'列'

是否按索引（0 或'索引'）或列（1 或'列'）进行比较。

level整数或标签

在一个级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。

布尔值的数据帧

比较的结果。

另请参阅

DataFrame.eq

逐元素比较数据帧是否相等。

DataFrame.ne

逐元素比较数据帧是否不等。

DataFrame.le

逐元素比较数据帧是否小于不等式或相等。

DataFrame.lt

逐元素严格比较数据帧。

DataFrame.ge

逐元素比较数据帧是否大于不等或相等。

DataFrame.gt

逐元素严格比较数据帧是否大于不等式。

注意事项

不匹配的索引将被合并在一起。 NaN 值被视为不同（即 NaN！= NaN）。

示例

>>> df = pd.DataFrame({'cost': [250, 150, 100],
...                    'revenue': [100, 250, 300]},
...                   index=['A', 'B', 'C'])
>>> df
 cost  revenue
A   250      100
B   150      250
C   100      300

使用标量进行比较，可以使用运算符或方法：

>>> df == 100
 cost  revenue
A  False     True
B  False    False
C   True    False

>>> df.eq(100)
 cost  revenue
A  False     True
B  False    False
C   True    False

当 other 是一个Series时，数据帧的列与 other 的索引对齐并进行广播：

>>> df != pd.Series([100, 250], index=["cost", "revenue"])
 cost  revenue
A   True     True
B   True    False
C  False     True

使用该方法来控制广播轴：

>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
 cost  revenue
A  True    False
B  True     True
C  True     True
D  True     True

当与任意序列进行比较时，列的数量必须与 other 中的元素数量相匹配：

>>> df == [250, 100]
 cost  revenue
A   True     True
B  False    False
C  False    False

使用该方法来控制轴：

>>> df.eq([250, 250, 100], axis='index')
 cost  revenue
A   True    False
B  False     True
C   True    False

与不同形状的数据帧进行比较。

>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]},
...                      index=['A', 'B', 'C', 'D'])
>>> other
 revenue
A      300
B      250
C      100
D      150

>>> df.gt(other)
 cost  revenue
A  False    False
B  False    False
C  False     True
D  False    False

与级别的 MultiIndex 进行比较。

>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220],
...                              'revenue': [100, 250, 300, 200, 175, 225]},
...                             index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
...                                    ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
 cost  revenue
Q1 A   250      100
 B   150      250
 C   100      300
Q2 A   150      200
 B   300      175
 C   220      225

>>> df.le(df_multindex, level=1)
 cost  revenue
Q1 A   True     True
 B   True     True
 C   True     True
Q2 A  False     True
 B   True    False
 C   True    False

`pandas.DataFrame.ge`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.ge.html

DataFrame.ge(other, axis='columns', level=None)

获取 DataFrame 和其他元素的大于或等于，逐元素进行（二进制运算符 ge）。

在比较运算符的灵活包装器（eq，ne，le，lt，ge，gt）之间。

等同于==，!=，<=，<，>=，>，支持选择轴（行或列）和比较级别。

参数：

other标量，序列，Series 或 DataFrame

任何单个或多个元素数据结构，或类似列表的对象。

axis，默认为‘columns’

是否按索引（0 或‘index’）或列（1 或‘columns’）进行比较。

level整数或标签

在级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。

布尔值的 DataFrame

比较的结果。

另请参阅

DataFrame.eq

逐元素比较 DataFrame 的相等。

DataFrame.ne

逐元素比较 DataFrame 的不等式。

DataFrame.le

逐元素比较 DataFrame 的小于不等式或相等。

DataFrame.lt

逐元素比较 DataFrame 的严格小于不等式。

DataFrame.ge

逐元素比较 DataFrame 的大于不等式或相等。

DataFrame.gt

逐元素比较 DataFrame 的严格大于不等式。

注意

不匹配的索引将被合并在一起。NaN 值被视为不同（即 NaN != NaN）。

示例

>>> df = pd.DataFrame({'cost': [250, 150, 100],
...                    'revenue': [100, 250, 300]},
...                   index=['A', 'B', 'C'])
>>> df
 cost  revenue
A   250      100
B   150      250
C   100      300

与标量进行比较，使用运算符或方法：

>>> df == 100
 cost  revenue
A  False     True
B  False    False
C   True    False

>>> df.eq(100)
 cost  revenue
A  False     True
B  False    False
C   True    False

当other是Series时，DataFrame 的列与other的索引对齐并进行广播：

>>> df != pd.Series([100, 250], index=["cost", "revenue"])
 cost  revenue
A   True     True
B   True    False
C  False     True

使用方法来控制广播轴：

>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
 cost  revenue
A  True    False
B  True     True
C  True     True
D  True     True

当与任意序列进行比较时，列数必须与other中的元素数量匹配：

>>> df == [250, 100]
 cost  revenue
A   True     True
B  False    False
C  False    False

使用方法来控制轴：

>>> df.eq([250, 250, 100], axis='index')
 cost  revenue
A   True    False
B  False     True
C   True    False

与形状不同的 DataFrame 进行比较。

>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]},
...                      index=['A', 'B', 'C', 'D'])
>>> other
 revenue
A      300
B      250
C      100
D      150

>>> df.gt(other)
 cost  revenue
A  False    False
B  False    False
C  False     True
D  False    False

按级别比较 MultiIndex。

>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220],
...                              'revenue': [100, 250, 300, 200, 175, 225]},
...                             index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
...                                    ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
 cost  revenue
Q1 A   250      100
 B   150      250
 C   100      300
Q2 A   150      200
 B   300      175
 C   220      225

>>> df.le(df_multindex, level=1)
 cost  revenue
Q1 A   True     True
 B   True     True
 C   True     True
Q2 A  False     True
 B   True    False
 C   True    False

`pandas.DataFrame.ne`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.ne.html

DataFrame.ne(other, axis='columns', level=None)

获取数据框架和其他元素逐个不相等的结果（二进制运算符 ne）。

在比较运算符中的灵活包装器（eq、ne、le、lt、ge、gt）之间。

等同于==、!=、<=、<、>=、>，支持选择轴（行或列）和级别进行比较。

参数：

other标量、序列、Series 或 DataFrame

任何单个或多个元素数据结构，或类似列表的对象。

axis，默认为'columns'

是否按索引（0 或'index'）或列（1 或'columns'）进行比较。

level整数或标签

在一个级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。

布尔值的 DataFrame

比较的结果。

参见

DataFrame.eq

按元素逐个比较数据框架的相等性。

DataFrame.ne

按元素逐个比较数据框架的不等性。

DataFrame.le

按元素逐个比较数据框架的小于不等性或相等性。

DataFrame.lt

按元素逐个比较数据框架的严格小于不等性。

DataFrame.ge

按元素逐个比较数据框架的大于不等性或相等性。

DataFrame.gt

按元素逐个比较数据框架的严格大于不等性。

注意

不匹配的索引将被合并在一起。NaN 值被视为不同（即 NaN != NaN）。

示例

>>> df = pd.DataFrame({'cost': [250, 150, 100],
...                    'revenue': [100, 250, 300]},
...                   index=['A', 'B', 'C'])
>>> df
 cost  revenue
A   250      100
B   150      250
C   100      300

使用运算符或方法与标量进行比较：

>>> df == 100
 cost  revenue
A  False     True
B  False    False
C   True    False

>>> df.eq(100)
 cost  revenue
A  False     True
B  False    False
C   True    False

当 other 是一个Series时，DataFrame 的列与 other 的索引对齐并进行广播：

>>> df != pd.Series([100, 250], index=["cost", "revenue"])
 cost  revenue
A   True     True
B   True    False
C  False     True

使用该方法来控制广播轴：

>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
 cost  revenue
A  True    False
B  True     True
C  True     True
D  True     True

当与任意序列进行比较时，列数必须与 other 中的元素数相匹配：

>>> df == [250, 100]
 cost  revenue
A   True     True
B  False    False
C  False    False

使用该方法来控制轴：

>>> df.eq([250, 250, 100], axis='index')
 cost  revenue
A   True    False
B  False     True
C   True    False

与不同形状的数据框架进行比较。

>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]},
...                      index=['A', 'B', 'C', 'D'])
>>> other
 revenue
A      300
B      250
C      100
D      150

>>> df.gt(other)
 cost  revenue
A  False    False
B  False    False
C  False     True
D  False    False

与 MultiIndex 按级别进行比较。

>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220],
...                              'revenue': [100, 250, 300, 200, 175, 225]},
...                             index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
...                                    ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
 cost  revenue
Q1 A   250      100
 B   150      250
 C   100      300
Q2 A   150      200
 B   300      175
 C   220      225

>>> df.le(df_multindex, level=1)
 cost  revenue
Q1 A   True     True
 B   True     True
 C   True     True
Q2 A  False     True
 B   True    False
 C   True    False

`pandas.DataFrame.eq`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.eq.html

DataFrame.eq(other, axis='columns', level=None)

获取 DataFrame 和其他对象的相等元素，逐元素进行（二进制运算符 eq）。

在灵活的包装器（eq、ne、le、lt、ge、gt）中进行比较操作符。

等同于==、!=、<=、<、>=、>，支持选择轴（行或列）和级别进行比较。

参数：

其他标量、序列、Series 或 DataFrame

任何单个或多个元素数据结构，或类似列表的对象。

轴，默认为'columns'

是否按索引（0 或'index'）或列（1 或'columns'）进行比较。

级别整数或标签

在一个级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。

布尔值的 DataFrame

比较的结果。

另请参见

DataFrame.eq

逐元素比较 DataFrame 是否相等。

DataFrame.ne

逐元素比较 DataFrame 是否不等。

DataFrame.le

逐元素比较 DataFrame 是否小于不等式或相等。

DataFrame.lt

逐元素比较 DataFrame 是否严格小于不等式。

DataFrame.ge

逐元素比较 DataFrame 是否大于不等式或相等。

DataFrame.gt

逐元素比较 DataFrame 是否严格大于不等式。

注意

不匹配的索引将被合并在一起。NaN 值被视为不同（即 NaN != NaN）。

示例

>>> df = pd.DataFrame({'cost': [250, 150, 100],
...                    'revenue': [100, 250, 300]},
...                   index=['A', 'B', 'C'])
>>> df
 cost  revenue
A   250      100
B   150      250
C   100      300

使用运算符或方法对标量进行比较：

>>> df == 100
 cost  revenue
A  False     True
B  False    False
C   True    False

>>> df.eq(100)
 cost  revenue
A  False     True
B  False    False
C   True    False

当other是一个Series时，DataFrame 的列与other的索引对齐并进行广播：

>>> df != pd.Series([100, 250], index=["cost", "revenue"])
 cost  revenue
A   True     True
B   True    False
C  False     True

使用方法控制广播轴：

>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
 cost  revenue
A  True    False
B  True     True
C  True     True
D  True     True

当与任意序列进行比较时，列的数量必须与other中的元素数量匹配：

>>> df == [250, 100]
 cost  revenue
A   True     True
B  False    False
C  False    False

使用方法控制轴：

>>> df.eq([250, 250, 100], axis='index')
 cost  revenue
A   True    False
B  False     True
C   True    False

与不同形状的 DataFrame 进行比较。

>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]},
...                      index=['A', 'B', 'C', 'D'])
>>> other
 revenue
A      300
B      250
C      100
D      150

>>> df.gt(other)
 cost  revenue
A  False    False
B  False    False
C  False     True
D  False    False

与 MultiIndex 按级别进行比较。

>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220],
...                              'revenue': [100, 250, 300, 200, 175, 225]},
...                             index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
...                                    ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
 cost  revenue
Q1 A   250      100
 B   150      250
 C   100      300
Q2 A   150      200
 B   300      175
 C   220      225

>>> df.le(df_multindex, level=1)
 cost  revenue
Q1 A   True     True
 B   True     True
 C   True     True
Q2 A  False     True
 B   True    False
 C   True    False

`pandas.DataFrame.combine`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.combine.html

DataFrame.combine(other, func, fill_value=None, overwrite=True)

与另一个数据框进行按列合并。

使用func将数据框与另一个数据框按元素合并。结果数据框的行和列索引将是两者的并集。

参数：

other数据框

要按列合并的数据框。

func函数

接受两个序列作为输入并返回一个序列或标量的函数。用于按列合并两个数据框。

fill_value标量值，默认为 None

在将任何列传递给合并函数之前用于填充 NaN 的值。

overwrite布尔值，默认为 True

如果为 True，则self中不存在于other中的列将被用 NaN 覆盖。

数据框

提供的数据框的组合。

另请参阅

DataFrame.combine_first

将两个数据框对象合并，并默认使用调用该方法的数据框中的非空值。

示例

使用简单函数进行合并，选择较小的列。

>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [4, 4]})
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
>>> take_smaller = lambda s1, s2: s1 if s1.sum() < s2.sum() else s2
>>> df1.combine(df2, take_smaller)
 A  B
0  0  3
1  0  3

使用真实的元素级合并函数的示例。

>>> df1 = pd.DataFrame({'A': [5, 0], 'B': [2, 4]})
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
>>> df1.combine(df2, np.minimum)
 A  B
0  1  2
1  0  3

使用fill_value在将列传递给合并函数之前填充None。

>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]})
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
>>> df1.combine(df2, take_smaller, fill_value=-5)
 A    B
0  0 -5.0
1  0  4.0

然而，如果两个数据框中相同元素都是None，那么None将被保留。

>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]})
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [None, 3]})
>>> df1.combine(df2, take_smaller, fill_value=-5)
 A    B
0  0 -5.0
1  0  3.0

演示了在数据框之间的轴不同时使用overwrite时的行为的示例。

>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [4, 4]})
>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [-10, 1], }, index=[1, 2])
>>> df1.combine(df2, take_smaller)
 A    B     C
0  NaN  NaN   NaN
1  NaN  3.0 -10.0
2  NaN  3.0   1.0

>>> df1.combine(df2, take_smaller, overwrite=False)
 A    B     C
0  0.0  NaN   NaN
1  0.0  3.0 -10.0
2  NaN  3.0   1.0

演示传入数据框的优先级。

>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1], }, index=[1, 2])
>>> df2.combine(df1, take_smaller)
 A    B   C
0  0.0  NaN NaN
1  0.0  3.0 NaN
2  NaN  3.0 NaN

>>> df2.combine(df1, take_smaller, overwrite=False)
 A    B   C
0  0.0  NaN NaN
1  0.0  3.0 1.0
2  NaN  3.0 1.0

`pandas.DataFrame.combine_first`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.combine_first.html

DataFrame.combine_first(other)

使用其他位置的值更新相同位置的空元素。

通过使用另一个 DataFrame 中的非空值填充一个 DataFrame 中的空值来合并两个 DataFrame 对象。结果 DataFrame 的行和列索引将是两者的并集。结果 DataFrame 包含‘第一个’DataFrame 的值，并在调用 first.combine_first(second)时覆盖第二个 DataFrame 的值，其中 first.loc[index, col]和 second.loc[index, col]都不是缺失值。

参数：

otherDataFrame

提供的 DataFrame 用于填充空值。

DataFrame

将提供的 DataFrame 与其他对象组合的结果。

另请参阅

DataFrame.combine

使用给定函数在两个 DataFrame 上执行系列操作。

示例

>>> df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
>>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
>>> df1.combine_first(df2)
 A    B
0  1.0  3.0
1  0.0  4.0

如果空值的位置在其他位置不存在，则空值仍然存在

>>> df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]})
>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
>>> df1.combine_first(df2)
 A    B    C
0  NaN  4.0  NaN
1  0.0  3.0  1.0
2  NaN  3.0  1.0

`pandas.DataFrame.apply`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.apply.html

DataFrame.apply(func, axis=0, raw=False, result_type=None, args=(), by_row='compat', engine='python', engine_kwargs=None, **kwargs)

沿 DataFrame 的轴应用函数。

传递给函数的对象是 Series 对象，其索引要么是 DataFrame 的索引（axis=0），要么是 DataFrame 的列（axis=1）。默认情况下（result_type=None），最终返回类型是从应用函数的返回类型推断出来的。否则，它取决于 result_type 参数。

参数：

func函数

应用于每列或行的函数。

axis，默认为 0

应用函数的轴：

0 或‘index’：将函数应用于每列。
1 或‘columns’：将函数应用于每行。

rawbool，默认为 False

确定行或列是作为 Series 还是 ndarray 对象传递的：

False：将每行或列作为 Series 传递给函数。
True：传递的函数将接收 ndarray 对象。如果只是应用 NumPy 缩减函数，这将实现更好的性能。

result_type，默认为 None

仅在axis=1（列）时起作用：

‘expand’：类似列表的结果将转换为列。
‘reduce’：如果可能，返回 Series 而不是扩展类似列表的结果。这与‘expand’相反。
‘broadcast’：结果将广播到 DataFrame 的原始形状，原始索引和列将被保留。

默认行为（None）取决于应用函数的返回值：类似列表的结果将作为这些的 Series 返回。但是，如果应用函数返回 Series，则这些将扩展为列。

args元组

传递给 func 的位置参数，除了数组/系列。

by_rowFalse 或“compat”，默认为“compat”

仅当func是函数列表或字典并且 func 不是字符串时才有效。如果“compat”可能首先将 func 翻译为 pandas 方法（例如Series().apply(np.sum)将被翻译为Series().sum()）。如果这不起作用，将尝试再次调用 apply，并使用by_row=True，如果失败，将再次调用 apply 并使用by_row=False（向后兼容）。如果为 False，则整个 Series 将一次传递给 funcs。

版本 2.1.0 中的新功能。

engine，默认为‘python’

在 apply 中选择 python（默认）引擎或 numba 引擎。

numba 引擎将尝试对传递的函数进行 JIT 编译，这可能会加快大型 DataFrame 的速度。它还支持以下 engine_kwargs：

nopython（在 nopython 模式下编译函数）
nogil（在 JIT 编译函数内释放 GIL）
并行（尝试在 DataFrame 上并行应用函数）

注意：由于 numba 内部限制/pandas 如何与 numba 接口，只有在 raw=True 时才应使用此功能

注意：numba 编译器仅支持 Python/numpy 操作的子集。

请阅读有关numba 中支持的 python 特性和numba 中支持的 numpy 特性以了解您可以使用或不可以使用的内容。

2.2.0 版本中的新功能。

engine_kwargsdict

将关键字参数传递给引擎。目前仅由 numba 引擎使用，请参阅引擎参数的文档以了解更多信息。

**kwargs

传递给 func 的额外关键字参数作为关键字参数。

Series 或 DataFrame

在 DataFrame 的给定轴上应用func的结果。

请参见

DataFrame.map

适用于逐元素操作。

DataFrame.aggregate

仅执行聚合类型操作。

DataFrame.transform

仅执行变换类型操作。

注释

对传递的对象进行变异的函数可能会产生意外行为或错误，并且不受支持。有关更多详细信息，请参阅使用用户定义的函数 (UDF) 方法进行变异。

示例

>>> df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
>>> df
 A  B
0  4  9
1  4  9
2  4  9

使用 numpy 通用函数（在这种情况下与 np.sqrt(df) 相同）：

>>> df.apply(np.sqrt)
 A    B
0  2.0  3.0
1  2.0  3.0
2  2.0  3.0

在任一轴上使用减少函数

>>> df.apply(np.sum, axis=0)
A    12
B    27
dtype: int64

>>> df.apply(np.sum, axis=1)
0    13
1    13
2    13
dtype: int64

返回类似列表将导致 Series

>>> df.apply(lambda x: [1, 2], axis=1)
0    [1, 2]
1    [1, 2]
2    [1, 2]
dtype: object

传递result_type='expand'将会将类似列表的结果扩展到 DataFrame 的列中。

>>> df.apply(lambda x: [1, 2], axis=1, result_type='expand')
 0  1
0  1  2
1  1  2
2  1  2

在函数内返回 Series 类似于传递result_type='expand'。结果列名将是 Series 的索引。

>>> df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1)
 foo  bar
0    1    2
1    1    2
2    1    2

传递result_type='broadcast'将确保相同的形状结果，无论函数返回的是类似列表还是标量，并在轴上进行广播。结果列名将是原始的。

>>> df.apply(lambda x: [1, 2], axis=1, result_type='broadcast')
 A  B
0  1  2
1  1  2
2  1  2

`pandas.DataFrame.map`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.map.html

DataFrame.map(func, na_action=None, **kwargs)

对 DataFrame 逐元素应用函数。

新版本 2.1.0 中：DataFrame.applymap 被弃用并重命名为 DataFrame.map。

此方法将接受并返回标量的函数应用于 DataFrame 的每个元素。

参数：

funccallable

Python 函数，从单个值返回单个值。

na_action，默认为 None

如果为 'ignore'，传播 NaN 值，而不将它们传递给 func。

**kwargs

传递给 func 的额外关键字参数。

DataFrame

转换后的 DataFrame。

另请参阅

DataFrame.apply

在 DataFrame 的输入轴上应用函数。

DataFrame.replace

用 value 替换 to_replace 中给定的值。

Series.map

在 Series 上逐元素应用函数。

示例

>>> df = pd.DataFrame([[1, 2.12], [3.356, 4.567]])
>>> df
 0      1
0  1.000  2.120
1  3.356  4.567

>>> df.map(lambda x: len(str(x)))
 0  1
0  3  4
1  5  5

类似于 Series.map，可以忽略 NA 值：

>>> df_copy = df.copy()
>>> df_copy.iloc[0, 0] = pd.NA
>>> df_copy.map(lambda x: len(str(x)), na_action='ignore')
 0  1
0  NaN  4
1  5.0  5

也可以使用非 lambda 函数的 map：

>>> df.map(round, ndigits=1)
 0    1
0  1.0  2.1
1  3.4  4.6

请注意，通常存在 func 的矢量化版本，速度会快得多。您可以逐元素平方每个数字。

>>> df.map(lambda x: x**2)
 0          1
0   1.000000   4.494400
1  11.262736  20.857489

但最好在这种情况下避免使用 map。

>>> df ** 2
 0          1
0   1.000000   4.494400
1  11.262736  20.857489

`pandas.DataFrame.applymap`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.applymap.html

DataFrame.applymap(func, na_action=None, **kwargs)

对 DataFrame 逐元素应用函数。

自版本 2.1.0 起已弃用：DataFrame.applymap 已被弃用。请使用 DataFrame.map 代替。

此方法将接受并返回标量的函数应用于 DataFrame 的每个元素。

参数：

func可调用

Python 函数，从单个值返回单个值。

na_action，默认为 None

如果为'ignore'，则传播 NaN 值，而不将其传递给 func。

**kwargs

传递给 func 的其他关键字参数作为关键字参数。

DataFrame

转换后的 DataFrame。

另请参阅

DataFrame.apply

沿着 DataFrame 的输入轴应用函数。

DataFrame.map

沿着 DataFrame 的输入轴应用函数。

DataFrame.replace

用 value 替换 to_replace 中给定的值。

示例

>>> df = pd.DataFrame([[1, 2.12], [3.356, 4.567]])
>>> df
 0      1
0  1.000  2.120
1  3.356  4.567

>>> df.map(lambda x: len(str(x)))
 0  1
0  3  4
1  5  5

`pandas.DataFrame.pipe`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.pipe.html

DataFrame.pipe(func, *args, **kwargs)

应用期望 Series 或 DataFrames 的可链接函数。

参数：

funcfunction

要应用于 Series/DataFrame 的函数。args和kwargs被传递到func中。或者一个(callable, data_keyword)元组，其中data_keyword是一个字符串，指示期望 Series/DataFrame 的callable的关键字。

*argsiterable，可选

传递给func的位置参数。

****kwargs**mapping，可选

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

func的返回类型。

另请参阅

DataFrame.apply

沿 DataFrame 的输入轴应用函数。

DataFrame.map

在整个 DataFrame 上逐元素应用函数。

Series.map

在Series上应用映射对应关系。

注意

在链接在一起的函数中使用.pipe，这些函数期望 Series、DataFrames 或 GroupBy 对象。

示例

从字典构造收入 DataFrame。

>>> data = [[8000, 1000], [9500, np.nan], [5000, 2000]]
>>> df = pd.DataFrame(data, columns=['Salary', 'Others'])
>>> df
 Salary  Others
0    8000  1000.0
1    9500     NaN
2    5000  2000.0

在收入 DataFrame 上执行减税的函数。

>>> def subtract_federal_tax(df):
...     return df * 0.9
>>> def subtract_state_tax(df, rate):
...     return df * (1 - rate)
>>> def subtract_national_insurance(df, rate, rate_increase):
...     new_rate = rate + rate_increase
...     return df * (1 - new_rate)

而不是写

>>> subtract_national_insurance(
...     subtract_state_tax(subtract_federal_tax(df), rate=0.12),
...     rate=0.05,
...     rate_increase=0.02)

您可以写

>>> (
...     df.pipe(subtract_federal_tax)
...     .pipe(subtract_state_tax, rate=0.12)
...     .pipe(subtract_national_insurance, rate=0.05, rate_increase=0.02)
... )
 Salary   Others
0  5892.48   736.56
1  6997.32      NaN
2  3682.80  1473.12

如果您有一个函数，它将数据作为（比如）第二个参数，传递一个元组指示哪个关键字期望数据。例如，假设national_insurance将其数据作为第二个参数中的df：

>>> def subtract_national_insurance(rate, df, rate_increase):
...     new_rate = rate + rate_increase
...     return df * (1 - new_rate)
>>> (
...     df.pipe(subtract_federal_tax)
...     .pipe(subtract_state_tax, rate=0.12)
...     .pipe(
...         (subtract_national_insurance, 'df'),
...         rate=0.05,
...         rate_increase=0.02
...     )
... )
 Salary   Others
0  5892.48   736.56
1  6997.32      NaN
2  3682.80  1473.12

`pandas.DataFrame.agg`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.agg.html

DataFrame.agg(func=None, axis=0, *args, **kwargs)

对指定轴上的一个或多个操作进行聚合。

参数：

func函数，str，list 或 dict

用于聚合数据的函数。如果是函数，则必须在传递 DataFrame 或传递给 DataFrame.apply 时起作用。

接受的组合为：

函数
字符串函数名称
函数列表和/或函数名称，例如 [np.sum, 'mean']
轴标签 -> 函数，函数名称或此类列表的字典。

axis，默认为 0

如果为 0 或 ‘index’：对每列应用函数。如果为 1 或 ‘columns’：对每行应用函数。

*args

传递给 func 的位置参数。

**kwargs

传递给 func 的关键字参数。

返回值：

标量、Series 或 DataFrame

返回值可以是：

标量：当 Series.agg 与单个函数一起调用时
Series：当 DataFrame.agg 与单个函数一起调用时
DataFrame：当 DataFrame.agg 与多个函数一起调用时

另请参阅

DataFrame.apply

执行任何类型的操作。

DataFrame.transform

执行转换类型的操作。

pandas.DataFrame.groupby

在组上执行操作。

pandas.DataFrame.resample

在重采样的 bin 上执行操作。

pandas.DataFrame.rolling

在滚动窗口上执行操作。

pandas.DataFrame.expanding

在扩展窗口上执行操作。

pandas.core.window.ewm.ExponentialMovingWindow

在指数加权窗口上执行操作。

注释

聚合操作始终在轴上执行，即索引（默认）或列轴。这种行为与 numpy 聚合函数（mean、median、prod、sum、std、var）不同，numpy 的默认行为是计算扁平化数组的聚合，例如，numpy.mean(arr_2d) 而不是 numpy.mean(arr_2d, axis=0)。

agg 是 aggregate 的别名。使用别名。

会更改传递对象的函数可能会产生意外行为或错误，并且不受支持。有关更多详细信息，请参阅使用用户定义函数（UDF）方法进行更改。

传递的用户定义函数将被传递一个 Series 进行评估。

示例

>>> df = pd.DataFrame([[1, 2, 3],
...                    [4, 5, 6],
...                    [7, 8, 9],
...                    [np.nan, np.nan, np.nan]],
...                   columns=['A', 'B', 'C'])

在行上对这些函数进行聚合。

>>> df.agg(['sum', 'min'])
 A     B     C
sum  12.0  15.0  18.0
min   1.0   2.0   3.0

每列的不同聚合。

>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
 A    B
sum  12.0  NaN
min   1.0  2.0
max   NaN  8.0

在列上聚合不同的函数并重命名结果 DataFrame 的索引。

>>> df.agg(x=('A', 'max'), y=('B', 'min'), z=('C', 'mean'))
 A    B    C
x  7.0  NaN  NaN
y  NaN  2.0  NaN
z  NaN  NaN  6.0

在列上聚合。

>>> df.agg("mean", axis="columns")
0    2.0
1    5.0
2    8.0
3    NaN
dtype: float64

`pandas.DataFrame.aggregate`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.aggregate.html

DataFrame.aggregate(func=None, axis=0, *args, **kwargs)

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

参数：

func函数、str、list 或 dict

用于聚合数据的函数。如果是函数，则必须在传递给 DataFrame 或传递给 DataFrame.apply 时起作用。

接受的组合有：

函数
字符串函数名称
函数列表和/或函数名称，例如[np.sum, 'mean']
轴标签的字典->函数、函数名称或此类列表。

axis，默认为 0

如果为 0 或'index'：对每列应用函数。如果为 1 或'columns'：对每行应用函数。

*args

传递给 func 的位置参数。

**kwargs

传递给 func 的关键字参数。

scalar、Series 或 DataFrame

返回可以是：

scalar：当使用单个函数调用 Series.agg 时
Series：当使用单个函数调用 DataFrame.agg 时
DataFrame：当使用多个函数调用 DataFrame.agg 时

另请参见

DataFrame.apply

执行任何类型的操作。

DataFrame.transform

执行转换类型操作。

pandas.DataFrame.groupby

在组上执行操作。

pandas.DataFrame.resample

在重新取样的箱子上执行操作。

pandas.DataFrame.rolling

在滚动窗口上执行操作。

pandas.DataFrame.expanding

在不断扩展的窗口上执行操作。

pandas.core.window.ewm.ExponentialMovingWindow

在指数加权窗口上执行操作。

注意

聚合操作始终在一个轴上执行，即索引（默认）或列轴。这种行为与 numpy 聚合函数（mean、median、prod、sum、std、var）不同，numpy 聚合函数的默认行为是计算平坦数组的聚合，例如，numpy.mean(arr_2d)与numpy.mean(arr_2d, axis=0)不同。

agg 是 aggregate 的别名。使用别名。

可能会产生意外行为或错误的会改变传递对象的函数不受支持。有关更多详细信息，请参见使用用户定义函数（UDF）方法进行变异。

传递的用户定义函数将传递一个 Series 进行评估。

示例

>>> df = pd.DataFrame([[1, 2, 3],
...                    [4, 5, 6],
...                    [7, 8, 9],
...                    [np.nan, np.nan, np.nan]],
...                   columns=['A', 'B', 'C'])

在行上聚合这些函数。

>>> df.agg(['sum', 'min'])
 A     B     C
sum  12.0  15.0  18.0
min   1.0   2.0   3.0

每列的不同聚合。

>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
 A    B
sum  12.0  NaN
min   1.0  2.0
max   NaN  8.0

在列上聚合不同的函数，并重命名生成的 DataFrame 的索引。

>>> df.agg(x=('A', 'max'), y=('B', 'min'), z=('C', 'mean'))
 A    B    C
x  7.0  NaN  NaN
y  NaN  2.0  NaN
z  NaN  NaN  6.0

汇总列数据。

>>> df.agg("mean", axis="columns")
0    2.0
1    5.0
2    8.0
3    NaN
dtype: float64

`pandas.DataFrame.transform`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.transform.html

DataFrame.transform(func, axis=0, *args, **kwargs)

在 self 上调用 func，产生一个与 self 轴形状相同的 DataFrame。

参数：

func 函数、字符串、类似列表或类似字典

用于转换数据的函数。如果是函数，则必须能够在传递 DataFrame 时正常工作，或者能够传递给 DataFrame.apply。如果 func 既类似列表又类似字典，则以字典行为为准。

接受的组合方式有：

函数
字符串函数名称
函数列表和/或函数名称的类似列表，例如 [np.exp, 'sqrt']
类似字典的轴标签 -> 函数、函数名称或类似这样的列表。

axis，默认 0

如果为 0 或 ‘index’：将函数应用于每一列。如果为 1 或 ‘columns’：将函数应用于每一行。

*args

传递给 func 的位置参数。

**kwargs

传递给 func 的关键字参数。

DataFrame

必须与自身长度相同的 DataFrame。

异常：

ValueError 如果返回的 DataFrame 与自身长度不同。

另请参阅

DataFrame.agg

仅执行聚合类型操作。

DataFrame.apply

在 DataFrame 上调用函数。

注意事项

会更改传递对象的函数可能会产生意外行为或错误，并且不受支持。有关更多详细信息，请参阅使用用户定义函数 (UDF) 方法进行更改。

示例

>>> df = pd.DataFrame({'A': range(3), 'B': range(1, 4)})
>>> df
 A  B
0  0  1
1  1  2
2  2  3
>>> df.transform(lambda x: x + 1)
 A  B
0  1  2
1  2  3
2  3  4

即使生成的 DataFrame 必须与输入 DataFrame 长度相同，也可以提供多个输入函数：

>>> s = pd.Series(range(3))
>>> s
0    0
1    1
2    2
dtype: int64
>>> s.transform([np.sqrt, np.exp])
 sqrt        exp
0  0.000000   1.000000
1  1.000000   2.718282
2  1.414214   7.389056

您可以在 GroupBy 对象上调用 transform：

>>> df = pd.DataFrame({
...     "Date": [
...         "2015-05-08", "2015-05-07", "2015-05-06", "2015-05-05",
...         "2015-05-08", "2015-05-07", "2015-05-06", "2015-05-05"],
...     "Data": [5, 8, 6, 1, 50, 100, 60, 120],
... })
>>> df
 Date  Data
0  2015-05-08     5
1  2015-05-07     8
2  2015-05-06     6
3  2015-05-05     1
4  2015-05-08    50
5  2015-05-07   100
6  2015-05-06    60
7  2015-05-05   120
>>> df.groupby('Date')['Data'].transform('sum')
0     55
1    108
2     66
3    121
4     55
5    108
6     66
7    121
Name: Data, dtype: int64

>>> df = pd.DataFrame({
...     "c": [1, 1, 1, 2, 2, 2, 2],
...     "type": ["m", "n", "o", "m", "m", "n", "n"]
... })
>>> df
 c type
0  1    m
1  1    n
2  1    o
3  2    m
4  2    m
5  2    n
6  2    n
>>> df['size'] = df.groupby('c')['type'].transform(len)
>>> df
 c type size
0  1    m    3
1  1    n    3
2  1    o    3
3  2    m    4
4  2    m    4
5  2    n    4
6  2    n    4

`pandas.DataFrame.groupby`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.groupby.html

DataFrame.groupby(by=None, axis=_NoDefault.no_default, level=None, as_index=True, sort=True, group_keys=True, observed=_NoDefault.no_default, dropna=True)

使用映射器或列系列对 DataFrame 进行分组。

Groupby 操作涉及将对象拆分、应用函数和组合结果的某种组合。这可用于对大量数据进行分组并在这些组上执行操作。

参数：

by映射、函数、标签、pd.Grouper 或此类列表

用于确定 groupby 的组。如果 by 是一个函数，则会对对象的索引值调用它。如果传递了字典或 Series，则将使用 Series 或字典的值来确定组（首先对齐 Series 的值；请参阅 .align() 方法）。如果传递了与所选轴长度相等的列表或 ndarray（请参见分组用户指南），则值将按原样用于确定组。可以传递标签或标签列表以按 self 中的列��行分组。请注意，元组被解释为（单个）键。

axis，默认为 0

沿行（0）或列（1）拆分。对于 Series，此参数未使用，默认为 0。

自 2.1.0 版起已弃用：将在将来的版本中删除并像 axis=0 一样运行。对于 axis=1，请改用 frame.T.groupby(...)。

levelint、级别名称或此类序列，默认为 None

如果轴是多重索引（分层），则按特定级别或级别进行分组。不要同时指定 by 和 level。

as_indexbool，默认为 True

返回带有组标签作为索引的对象。仅适用于 DataFrame 输入。as_index=False 实际上是“SQL 风格”分组输出。此参数对筛选（参见用户指南中的筛选），如 head()、tail()、nth() 和转换（参见用户指南中的转换）没有影响。

sortbool，默认为 True

对组键进行排序。关闭此选项可获得更好的性能。请注意，这不会影响每个组内观察的顺序。Groupby 会保留每个组内行的顺序。如果为 False，则组将按照原始 DataFrame 中的顺序出现。此参数对筛选（参见用户指南中的筛选），如 head()、tail()、nth() 和转换（参见用户指南中的转换）没有影响。

在 2.0.0 版中更改：使用有序分类分组器指定 sort=False 将不再对值进行排序。

group_keysbool，默认为 True

在调用 apply 并且by参数产生类似索引（即 a transform）结果时，将组键添加到索引中以标识片段。默认情况下，当结果的索引（和列）标签与输入匹配时，不包括组键，否则包括。

自版本 1.5.0 起更改：警告group_keys将不再在apply的结果是类似索引的 Series 或 DataFrame 时被忽略。明确指定group_keys以包含或排除组键。

自版本 2.0.0 起更改：group_keys现在默认为True。

observedbool，默认为 False

只有在任何一个分组器是分类变量时才适用。如果为 True：仅显示分类分组器的观察值。如果为 False：显示分类分组器的所有值。

自版本 2.1.0 起弃用：默认值将在未来的 pandas 版本中更改为 True。

dropnabool，默认为 True

如果为 True，并且组键包含 NA 值，则 NA 值将与行/列一起被删除。如果为 False，则 NA 值也将被视为组键。

pandas.api.typing.DataFrameGroupBy

返回一个包含有关组的信息的 groupby 对象。

另请参见

resample

用于频率转换和时间序列重采样的便捷方法。

注意

请查看用户指南以获取更详细的用法和示例，包括将对象拆分为组，遍历组，选择组，聚合等。

示例

>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
...                               'Parrot', 'Parrot'],
...                    'Max Speed': [380., 370., 24., 26.]})
>>> df
 Animal  Max Speed
0  Falcon      380.0
1  Falcon      370.0
2  Parrot       24.0
3  Parrot       26.0
>>> df.groupby(['Animal']).mean()
 Max Speed
Animal
Falcon      375.0
Parrot       25.0

层次索引

我们可以使用 level 参数按层次索引的不同级别进行分组：

>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
...           ['Captive', 'Wild', 'Captive', 'Wild']]
>>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type'))
>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},
...                   index=index)
>>> df
 Max Speed
Animal Type
Falcon Captive      390.0
 Wild         350.0
Parrot Captive       30.0
 Wild          20.0
>>> df.groupby(level=0).mean()
 Max Speed
Animal
Falcon      370.0
Parrot       25.0
>>> df.groupby(level="Type").mean()
 Max Speed
Type
Captive      210.0
Wild         185.0

我们还可以通过设置 dropna 参数选择是否在组键中包含 NA 值，默认设置为 True。

>>> l = [[1, 2, 3], [1, None, 4], [2, 1, 3], [1, 2, 2]]
>>> df = pd.DataFrame(l, columns=["a", "b", "c"])

>>> df.groupby(by=["b"]).sum()
 a   c
b
1.0 2   3
2.0 2   5

>>> df.groupby(by=["b"], dropna=False).sum()
 a   c
b
1.0 2   3
2.0 2   5
NaN 1   4

>>> l = [["a", 12, 12], [None, 12.3, 33.], ["b", 12.3, 123], ["a", 1, 1]]
>>> df = pd.DataFrame(l, columns=["a", "b", "c"])

>>> df.groupby(by="a").sum()
 b     c
a
a   13.0   13.0
b   12.3  123.0

>>> df.groupby(by="a", dropna=False).sum()
 b     c
a
a   13.0   13.0
b   12.3  123.0
NaN 12.3   33.0

在使用.apply()时，使用group_keys来包含或排除组键。group_keys参数默认为True（包含）。

>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon',
...                               'Parrot', 'Parrot'],
...                    'Max Speed': [380., 370., 24., 26.]})
>>> df.groupby("Animal", group_keys=True)[['Max Speed']].apply(lambda x: x)
 Max Speed
Animal
Falcon 0      380.0
 1      370.0
Parrot 2       24.0
 3       26.0

>>> df.groupby("Animal", group_keys=False)[['Max Speed']].apply(lambda x: x)
 Max Speed
0      380.0
1      370.0
2       24.0
3       26.0

`pandas.DataFrame.rolling`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.rolling.html

DataFrame.rolling(window, min_periods=None, center=False, win_type=None, on=None, axis=_NoDefault.no_default, closed=None, step=None, method='single')

提供滚动窗口计算。

参数：

windowint、时间间隔、字符串、偏移量或 BaseIndexer 子类

移动窗口的大小。

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

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

如果为 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。

自版本 2.1.0 起弃用：已弃用 axis 关键字。对于axis=1，请先转置 DataFrame。

closedstr，默认为 None

如果为'right'，则窗口中的第一个点不参与计算。

如果是'left'，则窗口中的最后一个点不参与计算。

如果为'both'，则窗口中的所有点都不参与计算。

如果为'neither'，则窗口中的第一个和最后一个点都不参与计算。

默认为None（'right'）。

stepint，默认为 None

自版本 1.5.0 起新增。

在每个step结果处评估窗口，相当于切片为[::step]。window必须是一个整数。使用除 None 或 1 之外的步长参数将产生一个形状与输入不同的结果。

方法str {‘single’, ‘table’}，默认为‘single’

版本 1.3.0 中的新功能。

按单列或行（'single'）或整个对象（'table'）执行滚动操作。

仅在方法调用中指定engine='numba'时实现此参数。

pandas.api.typing.Window 或 pandas.api.typing.Rolling

如果传递了win_type，则返回 Window 的实例。否则，返回 Rolling 的实例。

另请参阅

expanding

提供扩展转换。

ewm

提供指数加权函数。

注意

查看窗口操作以获取更多用法细节和示例。

示例

>>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})
>>> df
 B
0  0.0
1  1.0
2  2.0
3  NaN
4  4.0

窗口

两个观测值的滚动求和。

>>> df.rolling(2).sum()
 B
0  NaN
1  1.0
2  3.0
3  NaN
4  NaN

两秒的滚动求和窗口跨度。

>>> df_time = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]},
...                        index=[pd.Timestamp('20130101 09:00:00'),
...                               pd.Timestamp('20130101 09:00:02'),
...                               pd.Timestamp('20130101 09:00:03'),
...                               pd.Timestamp('20130101 09:00:05'),
...                               pd.Timestamp('20130101 09:00:06')])

>>> df_time
 B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  2.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  4.0

>>> df_time.rolling('2s').sum()
 B
2013-01-01 09:00:00  0.0
2013-01-01 09:00:02  1.0
2013-01-01 09:00:03  3.0
2013-01-01 09:00:05  NaN
2013-01-01 09:00:06  4.0

具有两个观测值的前瞻窗口的滚动求和。

>>> indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=2)
>>> df.rolling(window=indexer, min_periods=1).sum()
 B
0  1.0
1  3.0
2  2.0
3  4.0
4  4.0

最小周期

两个观测值的滚动求和，但只需要一个观测值来计算数值。

>>> df.rolling(2, min_periods=1).sum()
 B
0  0.0
1  1.0
2  3.0
3  2.0
4  4.0

中心

将结果分配给窗口索引的中心的滚动求和。

>>> df.rolling(3, min_periods=1, center=True).sum()
 B
0  1.0
1  3.0
2  3.0
3  6.0
4  4.0

>>> df.rolling(3, min_periods=1, center=False).sum()
 B
0  0.0
1  1.0
2  3.0
3  3.0
4  6.0

步长

两个观测值的滚动求和，至少需要一个观测值来计算数值，并且步长为 2。

>>> df.rolling(2, min_periods=1, step=2).sum()
 B
0  0.0
2  3.0
4  4.0

窗口类型

长度为 2 的滚动求和，使用 Scipy 'gaussian'窗口类型。聚合函数中需要std。

>>> df.rolling(2, win_type='gaussian').sum(std=3)
 B
0       NaN
1  0.986207
2  2.958621
3       NaN
4       NaN

开启

两天的滚动求和。

>>> df = pd.DataFrame({
...     'A': [pd.to_datetime('2020-01-01'),
...           pd.to_datetime('2020-01-01'),
...           pd.to_datetime('2020-01-02'),],
...     'B': [1, 2, 3], },
...     index=pd.date_range('2020', periods=3))

>>> df
 A  B
2020-01-01 2020-01-01  1
2020-01-02 2020-01-01  2
2020-01-03 2020-01-02  3

>>> df.rolling('2D', on='A').sum()
 A    B
2020-01-01 2020-01-01  1.0
2020-01-02 2020-01-01  3.0
2020-01-03 2020-01-02  6.0

`pandas.DataFrame.expanding`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.expanding.html

DataFrame.expanding(min_periods=1, axis=_NoDefault.no_default, method='single')

提供了扩展窗口计算。

参数：

min_periodsint，默认 1

窗口中所需的最小观察次数才能有值；否则结果是 np.nan。

axisint 或 str，默认 0

如果是 0 或 'index'，则跨行滚动。

如果是 1 或 'columns'，则跨列滚动。

对于 Series，此参数未使用，默认为 0。

methodstr {'single', 'table'}，默认 'single'

执行单个列或行（'single'）或整个对象（'table'）的滚动操作。

该参数仅在方法调用中指定 engine='numba' 时实现。

1.3.0 版新增。

pandas.api.typing.Expanding

另见

rolling

提供了滚动窗口计算。

ewm

提供了指数加权函数。

注意

有关更多使用详细信息和示例，请参阅窗口操作。

示例

>>> df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]})
>>> df
 B
0  0.0
1  1.0
2  2.0
3  NaN
4  4.0

min_periods

用于计算一个值所需的 1 对比 3 个观察结果的扩展总和。

>>> df.expanding(1).sum()
 B
0  0.0
1  1.0
2  3.0
3  3.0
4  7.0
>>> df.expanding(3).sum()
 B
0  NaN
1  NaN
2  3.0
3  3.0
4  7.0

`pandas.DataFrame.ewm`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.ewm.html

DataFrame.ewm(com=None, span=None, halflife=None, alpha=None, min_periods=0, adjust=True, ignore_na=False, axis=_NoDefault.no_default, times=None, method='single')

提供指数加权（EW）计算。

如果未提供times，则必须提供com、span、halflife或alpha中的一个。如果提供了times，则可以提供halflife和com、span或alpha中的一个。

参数：

comfloat，可选

以质心形式指定衰减

(\alpha = 1 / (1 + com))，对于(com \geq 0)。

spanfloat，可选

以跨度形式指定衰减

(\alpha = 2 / (span + 1))，对于(span \geq 1)。

halflifefloat，str，timedelta，可选

以半衰期形式指定衰减

(\alpha = 1 - \exp\left(-\ln(2) / halflife\right))，对于(halflife > 0)。

如果指定了times，则观察值衰减到其一半值所需的时间间隔。仅适用于mean()，并且半衰期值不适用于其他函数。

alphafloat，可选

直接指定平滑因子(\alpha)

(0 < \alpha \leq 1)

min_periodsint，默认为 0

窗口中所需的最小观察数，否则结果为np.nan。

adjustbool，默认为 True

在开始时期通过衰减调整因子除以以解决相对权重不平衡的问题（将 EWMA 视为移动平均）。

当adjust=True（默认）时，使用权重(w_i = (1 - \alpha)^i)计算 EW 函数。例如，系列[ (x_0, x_1, ..., x_t) ]的 EW 移动平均值将是：

[y_t = \frac{x_t + (1 - \alpha)x_{t-1} + (1 - \alpha)² x_{t-2} + ... + (1 - \alpha)^t x_0}{1 + (1 - \alpha) + (1 - \alpha)² + ... + (1 - \alpha)^t}]

当adjust=False时，指数加权函数是递归计算的：

[ $\begin{split}\begin{split} y_0 &= x_0\ y_t &= (1 - \alpha) y_{t-1} + \alpha x_t, \end{split}$ \end{split}]

ignore_nabool，默认为 False

计算权重时忽略缺失值。

当ignore_na=False（默认）时，权重基于绝对位置。例如，在计算[ (x_0)，None，(x_2)]的最终加权平均值时，如果adjust=True，则(x_0)和(x_2)的权重分别为((1-\alpha)²)和(1)，如果adjust=False，则分别为((1-\alpha)²)和(\alpha)。
当ignore_na=True时，权重基于相对位置。例如，在计算[ (x_0)，None，(x_2)]的最终加权平均值时，如果adjust=True，则(x_0)和(x_2)的权重分别为(1-\alpha)和(1)，如果adjust=False，则分别为(1-\alpha)和(\alpha)。

axis，默认为 0

如果为0或'index'，则跨行计算。

如果为1或'columns'，则跨列计算。

对于 Series，此参数未使用且默认为 0。

timesnp.ndarray，Series，默认为 None

仅适用于mean()。

与观察值对应的时间。必须是单调递增且datetime64[ns]类型。

如果为类似于 1-D 数组的形式，具有与观察值相同形状的序列。

方法str {‘single’, ‘table’}，默认为 ‘single’

版本 1.4.0 中的新功能。

对单个列或行（'single'）执行滚动操作，或对整个对象（'table'）执行。

仅在方法调用中指定 engine='numba' 时实现此参数。

仅适用于 mean()

pandas.api.typing.ExponentialMovingWindow

另请参阅

rolling

提供滚动窗口计算。

expanding

提供扩展转换。

笔记

有关更多使用细节和示例，请参阅窗口操作。

示例

>>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})
>>> df
 B
0  0.0
1  1.0
2  2.0
3  NaN
4  4.0

>>> df.ewm(com=0.5).mean()
 B
0  0.000000
1  0.750000
2  1.615385
3  1.615385
4  3.670213
>>> df.ewm(alpha=2 / 3).mean()
 B
0  0.000000
1  0.750000
2  1.615385
3  1.615385
4  3.670213

adjust

>>> df.ewm(com=0.5, adjust=True).mean()
 B
0  0.000000
1  0.750000
2  1.615385
3  1.615385
4  3.670213
>>> df.ewm(com=0.5, adjust=False).mean()
 B
0  0.000000
1  0.666667
2  1.555556
3  1.555556
4  3.650794

ignore_na

>>> df.ewm(com=0.5, ignore_na=True).mean()
 B
0  0.000000
1  0.750000
2  1.615385
3  1.615385
4  3.225000
>>> df.ewm(com=0.5, ignore_na=False).mean()
 B
0  0.000000
1  0.750000
2  1.615385
3  1.615385
4  3.670213

times

使用与 times 相对于时间间隔 halflife 计算的权重的指数加权平均值。

>>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17']
>>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean()
 B
0  0.000000
1  0.585786
2  1.523889
3  1.523889
4  3.233686

`pandas.DataFrame.abs`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.abs.html

DataFrame.abs()

返回一个每个元素绝对数值的 Series/DataFrame。

此函数仅适用于全部为数值的元素。

abs

包含每个元素绝对值的 Series/DataFrame。

另请参阅

numpy.absolute

逐个元素计算绝对值。

注意事项

对于complex输入，1.2 + 1j，绝对值为 (\sqrt{ a² + b² })。

示例

Series 中的绝对数值。

>>> s = pd.Series([-1.10, 2, -3.33, 4])
>>> s.abs()
0    1.10
1    2.00
2    3.33
3    4.00
dtype: float64

Series 中带有复数的绝对数值。

>>> s = pd.Series([1.2 + 1j])
>>> s.abs()
0    1.56205
dtype: float64

Series 中带有 Timedelta 元素的绝对数值。

>>> s = pd.Series([pd.Timedelta('1 days')])
>>> s.abs()
0   1 days
dtype: timedelta64[ns]

使用 argsort 选择最接近某个值的数据行（来自 StackOverflow）。

>>> df = pd.DataFrame({
...     'a': [4, 5, 6, 7],
...     'b': [10, 20, 30, 40],
...     'c': [100, 50, -30, -50]
... })
>>> df
 a    b    c
0    4   10  100
1    5   20   50
2    6   30  -30
3    7   40  -50
>>> df.loc[(df.c - 43).abs().argsort()]
 a    b    c
1    5   20   50
0    4   10  100
2    6   30  -30
3    7   40  -50

`pandas.DataFrame.all`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.all.html

DataFrame.all(axis=0, bool_only=False, skipna=True, **kwargs)

返回所有元素是否为 True，可能沿着一个轴。

返回 True，除非系列中或沿着 DataFrame 轴存在至少一个为 False 或等效值（例如零或空）的元素。

参数：

axis，默认为 0

指示应减少哪个轴或轴。对于 Series，此参数未使用且默认为 0。

0 / ‘index’：减少索引，返回一个其索引为原始列标签的 Series。
1 / ‘columns’：减少列，返回一个其索引为原始索引的 Series。
None：减少所有轴，返回一个标量。

bool_onlybool，默认为 False

仅包括布尔列。对于 Series，未实现。

skipnabool，默认为 True

排除 NA/空值。如果整行/列都是 NA 并且 skipna 为 True，则结果将为 True，就像空行/列一样。如果 skipna 为 False，则 NA 被视为 True，因为它们不等于零。

****kwargs**any，默认为 None

其他关键字参数没有效果，但可能会被接受以与 NumPy 兼容。

Series 或 DataFrame

如果指定了 level，则返回 DataFrame；否则返回 Series。

另请参见

Series.all

如果所有元素都为 True，则返回 True。

DataFrame.any

如果有一个（或多个）元素为 True，则返回 True。

示例

Series

>>> pd.Series([True, True]).all()
True
>>> pd.Series([True, False]).all()
False
>>> pd.Series([], dtype="float64").all()
True
>>> pd.Series([np.nan]).all()
True
>>> pd.Series([np.nan]).all(skipna=False)
True

DataFrames

从字典创建一个 DataFrame。

>>> df = pd.DataFrame({'col1': [True, True], 'col2': [True, False]})
>>> df
 col1   col2
0  True   True
1  True  False

默认行为检查每列中的值是否都返回 True。

>>> df.all()
col1     True
col2    False
dtype: bool

指定 axis='columns' 以检查每行中的值是否都返回 True。

>>> df.all(axis='columns')
0     True
1    False
dtype: bool

或 axis=None 以检查每个值是否为 True。

>>> df.all(axis=None)
False

`pandas.DataFrame.any`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.any.html

DataFrame.any(*, axis=0, bool_only=False, skipna=True, **kwargs)

返回是否有任何元素为 True，可能在一个轴上。

除非系列或 DataFrame 轴中至少有一个元素为 True 或等效（例如非零或非空），否则返回 False。

参数：

axis，默认为 0

指示应减少哪个轴或哪些轴。对于 Series，此参数未使用且默认为 0。

0 / ‘index’：减少索引，返回一个其索引为原始列标签的 Series。
1 / ‘columns’：减少列，返回一个其索引为原始索引的 Series。
None：减少所有轴，返回一个标量。

bool_onlybool，默认为 False

仅包括布尔列。对于 Series 未实现。

skipnabool，默认为 True

排除 NA/null 值。如果整行/列都是 NA 且 skipna 为 True，则结果为 False，因为空行/列。如果 skipna 为 False，则 NA 被视为 True，因为它们不等于零。

****kwargs**any，默认为 None

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

Series 或 DataFrame

如果指定了 level，则返回 DataFrame；否则返回 Series。

另请参见

numpy.any

此方法的 Numpy 版本。

Series.any

返回是否有任何元素为 True。

Series.all

返回所有元素是否都为 True。

DataFrame.any

返回请求轴上是否有任何元素为 True。

DataFrame.all

返回请求轴上所有元素是否都为 True。

示例

Series

对于 Series 输入，输出是一个标量，指示是否有任何元素为 True。

>>> pd.Series([False, False]).any()
False
>>> pd.Series([True, False]).any()
True
>>> pd.Series([], dtype="float64").any()
False
>>> pd.Series([np.nan]).any()
False
>>> pd.Series([np.nan]).any(skipna=False)
True

DataFrame

每列是否至少包含一个 True 元素（默认）。

>>> df = pd.DataFrame({"A": [1, 2], "B": [0, 2], "C": [0, 0]})
>>> df
 A  B  C
0  1  0  0
1  2  2  0

>>> df.any()
A     True
B     True
C    False
dtype: bool

对列进行聚合。

>>> df = pd.DataFrame({"A": [True, False], "B": [1, 2]})
>>> df
 A  B
0   True  1
1  False  2

>>> df.any(axis='columns')
0    True
1    True
dtype: bool

>>> df = pd.DataFrame({"A": [True, False], "B": [1, 0]})
>>> df
 A  B
0   True  1
1  False  0

>>> df.any(axis='columns')
0    True
1    False
dtype: bool

通过axis=None对整个 DataFrame 进行聚合。

>>> df.any(axis=None)
True

空 DataFrame 的 any 是一个空 Series。

>>> pd.DataFrame([]).any()
Series([], dtype: bool)

`pandas.DataFrame.clip`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.clip.html

DataFrame.clip(lower=None, upper=None, *, axis=None, inplace=False, **kwargs)

在输入阈值处修剪值。

将超出边界的值赋为边界值。阈值可以是单个值或类似数组，对于后者，剪裁是在指定的轴上逐元素执行的。

参数：

lowerfloat 或类似数组，默认为 None

最小阈值值。所有低于此阈值的值将被设置为它。缺失的阈值（例如 NA）不会剪裁该值。

upperfloat 或类似数组，默认为 None

最大阈值值。所有高于此阈值的值将被设置为它。缺失的阈值（例如 NA）不会剪裁该值。

axis{{0 或 ‘index’，1 或 ‘columns’，None}}，默认为 None

沿给定轴与下限和上限对齐对象。对于 Series，此参数未使用并默认为 None。

inplacebool，默认为 False

是否在数据上原地执行操作。

***args, kwargs

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

返回值：

Series 或 DataFrame 或 None

与调用对象相同类型，超出剪裁边界的值被替换，如果 inplace=True 则为 None。

另请参阅

Series.clip

在系列中按输入阈值修剪值。

DataFrame.clip

在数据框中按输入阈值修剪值。

numpy.clip

在数组中剪裁（限制）值。

示例

>>> data = {'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]}
>>> df = pd.DataFrame(data)
>>> df
 col_0  col_1
0      9     -2
1     -3     -7
2      0      6
3     -1      8
4      5     -5

每列使用下限和上限进行剪裁：

>>> df.clip(-4, 6)
 col_0  col_1
0      6     -2
1     -3     -4
2      0      6
3     -1      6
4      5     -4

每列使用特定的下限和上限进行剪裁：

>>> df.clip([-2, -1], [4, 5])
 col_0  col_1
0      4     -1
1     -2     -1
2      0      5
3     -1      5
4      4     -1

每列元素使用特定的下限和上限进行剪裁：

>>> t = pd.Series([2, -4, -1, 6, 3])
>>> t
0    2
1   -4
2   -1
3    6
4    3
dtype: int64

>>> df.clip(t, t + 4, axis=0)
 col_0  col_1
0      6      2
1     -3     -4
2      0      3
3      6      8
4      5      3

每列元素使用特定的下限进行剪裁，带有缺失值：

>>> t = pd.Series([2, -4, np.nan, 6, 3])
>>> t
0    2.0
1   -4.0
2    NaN
3    6.0
4    3.0
dtype: float64

>>> df.clip(t, axis=0)
col_0  col_1
0      9      2
1     -3     -4
2      0      6
3      6      8
4      5      3

`pandas.DataFrame.corr`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.corr.html

DataFrame.corr(method='pearson', min_periods=1, numeric_only=False)

计算列之间的成对相关性，排除 NA/null 值。

参数：

method 或可调用

`pandas.DataFrame.corrwith`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.corrwith.html

DataFrame.corrwith(other, axis=0, drop=False, method='pearson', numeric_only=False)

计算成对相关性。

在计算 DataFrame 的行或列与 Series 或 DataFrame 的行或列之间的成对相关性之前，首先沿着两个轴对齐 DataFrame。

参数：

otherDataFrame，Series

用于计算相关性的对象。

axis，默认为 0

要使用的轴。0 或‘index’表示按行计算，1 或‘columns’表示按列计算。

dropbool，默认为 False

从结果中删除缺失的索引。

method或可调用函数

`pandas.DataFrame.count`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.count.html

DataFrame.count(axis=0, numeric_only=False)

对于每列或行，计算非 NA 单元格的数量。

值为 None、NaN、NaT、pandas.NA都被视为 NA。

参数：

axis，默认为 0

如果为 0 或‘index’，则对每列生成计数。如果为 1 或‘columns’，则对每行生成计数。

numeric_only布尔值，默认为 False

只包括 float、int 或 boolean 数据。

Series

对于每列/行，非 NA/null 条目的数量。

另请参阅

Series.count

Series 中非 NA 元素的数量。

DataFrame.value_counts

计数列的唯一组合。

DataFrame.shape

DataFrame 行数和列数（包括 NA 元素）。

DataFrame.isna

显示 NA 元素位置的布尔值相同大小的 DataFrame。

示例

从字典构造 DataFrame：

>>> df = pd.DataFrame({"Person":
...                    ["John", "Myla", "Lewis", "John", "Myla"],
...                    "Age": [24., np.nan, 21., 33, 26],
...                    "Single": [False, True, True, True, False]})
>>> df
 Person   Age  Single
0    John  24.0   False
1    Myla   NaN    True
2   Lewis  21.0    True
3    John  33.0    True
4    Myla  26.0   False

注意未计入的 NA 值：

>>> df.count()
Person    5
Age       4
Single    5
dtype: int64

每个行的计数：

>>> df.count(axis='columns')
0    3
1    2
2    3
3    3
4    3
dtype: int64

`pandas.DataFrame.cov`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.cov.html

DataFrame.cov(min_periods=None, ddof=1, numeric_only=False)

计算列之间的成对协方差，排除 NA/null 值。

计算 DataFrame 系列之间的成对协方差。返回的数据框是 DataFrame 列的协方差矩阵。

计算时会自动排除 NA 和 null 值（请参阅下面关于缺失值偏差的注释）。可以设置一个阈值，用于每个值创建的最小观测数。对于低于此阈值的观测，将返回NaN。

该方法通常用于分析时间序列数据，以了解不同测量值之间随时间的关系。

参数：

min_periods整数，可选

每对列所需的最小观测数以获得有效结果。

ddof整数，默认为 1

自由度差值。计算中使用的除数为N - ddof，其中N表示元素数量。此参数仅在数据框中没有nan时适用。

numeric_only布尔值，默认为 False

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

1.5.0 版本中的新功能。

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

数据框

DataFrame 系列的协方差矩阵。

另请参阅

Series.cov

与另一个 Series 计算协方差。

core.window.ewm.ExponentialMovingWindow.cov

指数加权样本协方差。

core.window.expanding.Expanding.cov

扩展样本协方差。

core.window.rolling.Rolling.cov

滚动样本协方差。

注释

返回 DataFrame 时间序列的协方差矩阵。协方差通过 N-ddof 进行归一化。

对于具有缺失数据的 Series 的 DataFrame（假设数据是随机缺失的），返回的协方差矩阵将是成员 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.DataFrame.cummax`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.cummax.html

DataFrame.cummax(axis=None, skipna=True, *args, **kwargs)

返回 DataFrame 或 Series 轴上的累积最大值。

返回一个大小相同的 DataFrame 或 Series，其中包含累积最大值。

参数：

axis，默认为 0

轴的索引或名称。0 等同于 None 或‘index’。对于 Series，此参数未使用且默认为 0。

skipnabool，默认为 True

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

***args, kwargs

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

Series 或 DataFrame

返回 Series 或 DataFrame 的累积最大值。

另请参阅

core.window.expanding.Expanding.max

类似功能，但忽略NaN值。

DataFrame.max

返回 DataFrame 轴上的最大值。

DataFrame.cummax

返回 DataFrame 轴上的累积最大值。

DataFrame.cummin

返回 DataFrame 轴上的累积最小值。

DataFrame.cumsum

返回 DataFrame 轴上的累积和。

DataFrame.cumprod

返回 DataFrame 轴上的累积乘积。

示例

Series

>>> s = pd.Series([2, np.nan, 5, -1, 0])
>>> s
0    2.0
1    NaN
2    5.0
3   -1.0
4    0.0
dtype: float64

默认情况下，忽略 NA 值。

>>> s.cummax()
0    2.0
1    NaN
2    5.0
3    5.0
4    5.0
dtype: float64

要在操作中包含 NA 值，请使用skipna=False

>>> s.cummax(skipna=False)
0    2.0
1    NaN
2    NaN
3    NaN
4    NaN
dtype: float64

DataFrame

>>> df = pd.DataFrame([[2.0, 1.0],
...                    [3.0, np.nan],
...                    [1.0, 0.0]],
...                   columns=list('AB'))
>>> df
 A    B
0  2.0  1.0
1  3.0  NaN
2  1.0  0.0

默认情况下，遍历行并找到每列中的最大值。这等同于axis=None或axis='index'。

>>> df.cummax()
 A    B
0  2.0  1.0
1  3.0  NaN
2  3.0  1.0

要遍历列并找到每行中的最大值，请使用axis=1

>>> df.cummax(axis=1)
 A    B
0  2.0  2.0
1  3.0  NaN
2  1.0  1.0

`pandas.DataFrame.cummin`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.cummin.html

DataFrame.cummin(axis=None, skipna=True, *args, **kwargs)

返回 DataFrame 或 Series 轴上的累积最小值。

返回一个大小相同的 DataFrame 或 Series，其中包含累积最小值。

参数：

axis，默认为 0

索引或轴的名称。0 等同于 None 或'index'。对于 Series，此参数未使用且默认为 0。

skipna布尔值，默认为 True

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

***args, kwargs

附加关键字对结果没有影响，但可能会被接受以与 NumPy 兼容。

Series 或 DataFrame

返回 Series 或 DataFrame 的累积最小值。

另请参见

core.window.expanding.Expanding.min

类似功能，但忽略NaN值。

DataFrame.min

返回 DataFrame 轴上的最小值。

DataFrame.cummax

返回 DataFrame 轴上的累积最大值。

DataFrame.cummin

返回 DataFrame 轴上的累积最小值。

DataFrame.cumsum

返回沿着 DataFrame 轴的累积和。

DataFrame.cumprod

返回沿着 DataFrame 轴的累积乘积。

示例

Series

>>> s = pd.Series([2, np.nan, 5, -1, 0])
>>> s
0    2.0
1    NaN
2    5.0
3   -1.0
4    0.0
dtype: float64

默认情况下，忽略 NA 值。

>>> s.cummin()
0    2.0
1    NaN
2    2.0
3   -1.0
4   -1.0
dtype: float64

要在操作中包含 NA 值，请使用skipna=False

>>> s.cummin(skipna=False)
0    2.0
1    NaN
2    NaN
3    NaN
4    NaN
dtype: float64

DataFrame

>>> df = pd.DataFrame([[2.0, 1.0],
...                    [3.0, np.nan],
...                    [1.0, 0.0]],
...                   columns=list('AB'))
>>> df
 A    B
0  2.0  1.0
1  3.0  NaN
2  1.0  0.0

默认情况下，遍历行并找到每列中的最小值。这等同于axis=None或axis='index'。

>>> df.cummin()
 A    B
0  2.0  1.0
1  2.0  NaN
2  1.0  0.0

要遍历列并找到每行中的最小值，请使用axis=1

>>> df.cummin(axis=1)
 A    B
0  2.0  1.0
1  3.0  NaN
2  1.0  0.0

`pandas.DataFrame.cumprod`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.cumprod.html

DataFrame.cumprod(axis=None, skipna=True, *args, **kwargs)

返回 DataFrame 或 Series 轴上的累积乘积。

返回一个包含累积乘积的相同大小的 DataFrame 或 Series。

参数：

axis，默认为 0

索引或轴的名称。0 等同于 None 或 ‘index’。对于 Series，此参数未使用，默认为 0。

skipnabool，默认为 True

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

***args, kwargs

附加关键字参数没有效果，但可能会被接受以与 NumPy 兼容。

Series 或 DataFrame

返回 Series 或 DataFrame 的累积乘积。

另请参见

core.window.expanding.Expanding.prod

类似功能，但忽略 NaN 值。

DataFrame.prod

返回 DataFrame 轴上的乘积。

DataFrame.cummax

返回 DataFrame 轴上的累积最小值。

DataFrame.cummin

返回 DataFrame 轴上的累积最小值。

DataFrame.cumsum

返回 DataFrame 轴上的累积和。

DataFrame.cumprod

返回 DataFrame 轴上的累积乘积。

示例

Series

>>> s = pd.Series([2, np.nan, 5, -1, 0])
>>> s
0    2.0
1    NaN
2    5.0
3   -1.0
4    0.0
dtype: float64

默认情况下，忽略 NA 值。

>>> s.cumprod()
0     2.0
1     NaN
2    10.0
3   -10.0
4    -0.0
dtype: float64

要在操作中包含 NA 值，请使用 skipna=False

>>> s.cumprod(skipna=False)
0    2.0
1    NaN
2    NaN
3    NaN
4    NaN
dtype: float64

DataFrame

>>> df = pd.DataFrame([[2.0, 1.0],
...                    [3.0, np.nan],
...                    [1.0, 0.0]],
...                   columns=list('AB'))
>>> df
 A    B
0  2.0  1.0
1  3.0  NaN
2  1.0  0.0

默认情况下，迭代行并在每列中找到乘积。这等同于 axis=None 或 axis='index'。

>>> df.cumprod()
 A    B
0  2.0  1.0
1  6.0  NaN
2  6.0  0.0

要迭代列并在每行中找到乘积，请使用 axis=1

>>> df.cumprod(axis=1)
 A    B
0  2.0  2.0
1  3.0  NaN
2  1.0  0.0

`pandas.DataFrame.cumsum`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.cumsum.html

DataFrame.cumsum(axis=None, skipna=True, *args, **kwargs)

返回 DataFrame 或 Series 轴上的累积和。

返回一个包含累积和的相同大小的 DataFrame 或 Series。

参数：

axis，默认为 0

轴的索引或名称。0 等同于 None 或‘index’。对于 Series，此参数未使用并默认为 0。

skipnabool，默认为 True

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

***args, kwargs

附加关键字没有效果，但可能会被接受以与 NumPy 兼容。

Series 或 DataFrame

返回 Series 或 DataFrame 的累积和。

另请参见

core.window.expanding.Expanding.sum

类似的功能，但忽略NaN值。

DataFrame.sum

返回 DataFrame 轴上的总和。

DataFrame.cummax

返回沿着 DataFrame 轴的累积最大值。

DataFrame.cummin

返回 DataFrame 轴上的累积最小值。

DataFrame.cumsum

返回 DataFrame 轴上的累积和。

DataFrame.cumprod

返回沿着 DataFrame 轴的累积乘积。

示例

Series

>>> s = pd.Series([2, np.nan, 5, -1, 0])
>>> s
0    2.0
1    NaN
2    5.0
3   -1.0
4    0.0
dtype: float64

默认情况下，NA 值会被忽略。

>>> s.cumsum()
0    2.0
1    NaN
2    7.0
3    6.0
4    6.0
dtype: float64

要在操作中包含 NA 值，请使用skipna=False

>>> s.cumsum(skipna=False)
0    2.0
1    NaN
2    NaN
3    NaN
4    NaN
dtype: float64

DataFrame

>>> df = pd.DataFrame([[2.0, 1.0],
...                    [3.0, np.nan],
...                    [1.0, 0.0]],
...                   columns=list('AB'))
>>> df
 A    B
0  2.0  1.0
1  3.0  NaN
2  1.0  0.0

默认情况下，迭代行并找到每列的总和。这相当于axis=None或axis='index'。

>>> df.cumsum()
 A    B
0  2.0  1.0
1  5.0  NaN
2  6.0  1.0

要迭代列并找到每行的总和，请使用axis=1

>>> df.cumsum(axis=1)
 A    B
0  2.0  3.0
1  3.0  NaN
2  1.0  1.0

`pandas.DataFrame.describe`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html

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

生成描述性统计。

描述性统计包括总体趋势、离散度和数据集分布形状的摘要，不包括NaN值。

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

参数：

percentiles数字的列表或 None（默认），可选

要包含在输出中的百分位数。所有值应介于 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 (default)：结果将包括所有数值列。

exclude数据类型的列表或 None（默认），可选，

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

数据类型的列表：排除结果中提供的数据类型。要排除数值类型，请提交numpy.number。要排除对象列，请提交数据类型numpy.object。也可以使用select_dtypes的风格（例如df.describe(exclude=['O'])）。要排除 pandas 分类列，请使用'category'
None (default)：结果将不排除任何内容。

Series 或 DataFrame

提供的 Series 或 Dataframe 的摘要统计信息。

另请参阅

DataFrame.count

计算非 NA/null 观测值的数量。

DataFrame.max

对象中的最大值。

DataFrame.min

对象中的最小值。

DataFrame.mean

值的平均值。

DataFrame.std

观察的标准差。

DataFrame.select_dtypes

基于其数据类型包含/排除列的 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.DataFrame.diff`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.diff.html

DataFrame.diff(periods=1, axis=0)

元素的第一个离散差分。

计算 DataFrame 元素与 DataFrame 中另一个元素的差异（默认为前一行的元素）。

参数：

periodsint，默认为 1

用于计算差异的周期数，接受负值。

axis，默认为 0

对行（0）或列（1）进行差分。

DataFrame

Series 的第一个差分。

另请参阅

DataFrame.pct_change

在给定周期数内的百分比变化。

DataFrame.shift

将索引按所需周期数移位，并可选择时间频率。

Series.diff

对对象进行第一个离散差分。

注意事项

对于布尔数据类型，这使用operator.xor()而不是operator.sub()。结果根据 DataFrame 中的当前数据类型计算，但结果的数据类型始终为 float64。

示例

与前一行的差异

>>> df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6],
...                    'b': [1, 1, 2, 3, 5, 8],
...                    'c': [1, 4, 9, 16, 25, 36]})
>>> df
 a  b   c
0  1  1   1
1  2  1   4
2  3  2   9
3  4  3  16
4  5  5  25
5  6  8  36

>>> df.diff()
 a    b     c
0  NaN  NaN   NaN
1  1.0  0.0   3.0
2  1.0  1.0   5.0
3  1.0  1.0   7.0
4  1.0  2.0   9.0
5  1.0  3.0  11.0

与前一列的差异

>>> df.diff(axis=1)
 a  b   c
0 NaN  0   0
1 NaN -1   3
2 NaN -1   7
3 NaN -1  13
4 NaN  0  20
5 NaN  2  28

与第三个前一行的差异

>>> df.diff(periods=3)
 a    b     c
0  NaN  NaN   NaN
1  NaN  NaN   NaN
2  NaN  NaN   NaN
3  3.0  2.0  15.0
4  3.0  4.0  21.0
5  3.0  6.0  27.0

与后一行的差异

>>> df.diff(periods=-1)
 a    b     c
0 -1.0  0.0  -3.0
1 -1.0 -1.0  -5.0
2 -1.0 -1.0  -7.0
3 -1.0 -2.0  -9.0
4 -1.0 -3.0 -11.0
5  NaN  NaN   NaN

输入数据类型溢出

>>> df = pd.DataFrame({'a': [1, 0]}, dtype=np.uint8)
>>> df.diff()
 a
0    NaN
1  255.0

`pandas.DataFrame.eval`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.eval.html

DataFrame.eval(expr, *, inplace=False, **kwargs)

评估描述 DataFrame 列操作的字符串。

仅对列进行操作，而不是特定的行或元素。这允许 eval 运行任意代码，如果将用户输入传递给此函数，则可能会使您容易受到代码注入的攻击。

参数：

exprstr

要评估的表达式字符串。

inplacebool，默认为 False

如果表达式包含赋值，则是否执行就地操作并改变现有 DataFrame。否则，将返回一个新的 DataFrame。

**kwargs

有关 query() 接受的关键字参数的完整详细信息，请参阅 eval() 的文档。

ndarray、标量、pandas 对象或 None

评估的结果或如果 inplace=True 则为 None。

另请参见

DataFrame.query

评估布尔表达式以查询帧的列。

DataFrame.assign

可以评估表达式或函数以为列创建新值。

eval

将 Python 表达式作为字符串使用不同的后端进行评估。

注意事项

有关 eval() 的 API 文档的更多详细信息，请参阅使用 eval 提高性能的详细示例。

示例

>>> df = pd.DataFrame({'A': range(1, 6), 'B': range(10, 0, -2)})
>>> df
 A   B
0  1  10
1  2   8
2  3   6
3  4   4
4  5   2
>>> df.eval('A + B')
0    11
1    10
2     9
3     8
4     7
dtype: int64

默认情况下允许赋值，但不会修改原始 DataFrame。

>>> df.eval('C = A + B')
 A   B   C
0  1  10  11
1  2   8  10
2  3   6   9
3  4   4   8
4  5   2   7
>>> df
 A   B
0  1  10
1  2   8
2  3   6
3  4   4
4  5   2

可以使用多行表达式为多列赋值：

>>> df.eval(
...  '''
... C = A + B
... D = A - B
... '''
... )
 A   B   C  D
0  1  10  11 -9
1  2   8  10 -6
2  3   6   9 -3
3  4   4   8  0
4  5   2   7  3

`pandas.DataFrame.kurt`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.kurt.html

DataFrame.kurt(axis=0, skipna=True, numeric_only=False, **kwargs)

返回请求轴上的无偏峰度。

使用费舍尔定义的峰度（正态峰度为 0.0）获得的峰度。通过 N-1 进行标准化。

参数：

axis {索引（0），列（1）}

函数应用的轴。对于 Series，此参数未使用且默认为 0。

对于 DataFrames，指定 axis=None 将在两个轴上应用聚合。

版本 2.0.0 中的新功能。

skipna 布尔值，默认为 True

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

numeric_only 布尔值，默认为 False

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

**kwargs

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

Series 或标量

示例

>>> s = pd.Series([1, 2, 2, 3], index=['cat', 'dog', 'dog', 'mouse'])
>>> s
cat    1
dog    2
dog    2
mouse  3
dtype: int64
>>> s.kurt()
1.5

使用 DataFrame

>>> df = pd.DataFrame({'a': [1, 2, 2, 3], 'b': [3, 4, 4, 4]},
...                   index=['cat', 'dog', 'dog', 'mouse'])
>>> df
 a   b
 cat  1   3
 dog  2   4
 dog  2   4
mouse  3   4
>>> df.kurt()
a   1.5
b   4.0
dtype: float64

使用 axis=None

>>> df.kurt(axis=None).round(6)
-0.988693

使用 axis=1

>>> df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [3, 4], 'd': [1, 2]},
...                   index=['cat', 'dog'])
>>> df.kurt(axis=1)
cat   -6.0
dog   -6.0
dtype: float64

`pandas.DataFrame.kurtosis`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.kurtosis.html

DataFrame.kurtosis(axis=0, skipna=True, numeric_only=False, **kwargs)

返回请求轴上的无偏峰度。

使用 Fisher 的峰度定义获得的峰度（正态分布的峰度 == 0.0）。通过 N-1 进行归一化。

参数：

axis

函数应用的轴。对于 Series，此参数未使用，默认为 0。

对于 DataFrames，指定 axis=None 将在两个轴上应用聚合。

版本 2.0.0 中新增。

skipna 布尔值，默认为 True

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

numeric_only 布尔值，默认为 False

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

**kwargs

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

Series 或标量

示例

>>> s = pd.Series([1, 2, 2, 3], index=['cat', 'dog', 'dog', 'mouse'])
>>> s
cat    1
dog    2
dog    2
mouse  3
dtype: int64
>>> s.kurt()
1.5

使用 DataFrame

>>> df = pd.DataFrame({'a': [1, 2, 2, 3], 'b': [3, 4, 4, 4]},
...                   index=['cat', 'dog', 'dog', 'mouse'])
>>> df
 a   b
 cat  1   3
 dog  2   4
 dog  2   4
mouse  3   4
>>> df.kurt()
a   1.5
b   4.0
dtype: float64

使用 axis=None

>>> df.kurt(axis=None).round(6)
-0.988693

使用 axis=1

>>> df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [3, 4], 'd': [1, 2]},
...                   index=['cat', 'dog'])
>>> df.kurt(axis=1)
cat   -6.0
dog   -6.0
dtype: float64

`pandas.DataFrame.max`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.max.html

DataFrame.max(axis=0, skipna=True, numeric_only=False, **kwargs)

返回请求轴上的值的最大值。

如果您想要最大值的索引，请使用idxmax。这相当于numpy.ndarray方法argmax。

参数：

axis

函数应用的轴。对于系列，此参数未使用，默认为 0。

对于数据框，指定axis=None将在两个轴上应用聚合。

版本 2.0.0 中的新功能。

skipnabool，默认为 True

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

numeric_onlybool，默认为 False

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

**kwargs

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

系列或标量

另请参阅

Series.sum

返回总和。

Series.min

返回最小值。

Series.max

返回最大。

Series.idxmin

返回最小值的索引。

Series.idxmax

返回最大值的索引。

DataFrame.sum

返回请求轴上的总和。

DataFrame.min

返回请求轴上的最小值。

DataFrame.max

返回请求轴上的最大值。

DataFrame.idxmin

返回请求轴上的最小值的索引。

DataFrame.idxmax

返回请求轴上的最大值的索引。

示例

>>> idx = pd.MultiIndex.from_arrays([
...     ['warm', 'warm', 'cold', 'cold'],
...     ['dog', 'falcon', 'fish', 'spider']],
...     names=['blooded', 'animal'])
>>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx)
>>> s
blooded  animal
warm     dog       4
 falcon    2
cold     fish      0
 spider    8
Name: legs, dtype: int64

>>> s.max()
8

`pandas.DataFrame.mean`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.mean.html

DataFrame.mean(axis=0, skipna=True, numeric_only=False, **kwargs)

返回请求轴上的值的平均值。

参数：

轴

函数应用的轴。对于 Series，此参数未使用，默认为 0。

对于 DataFrames，指定axis=None将在两个轴上应用聚合。

版本 2.0.0 中的新功能。

skipnabool，默认为 True

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

numeric_onlybool，默认为 False

仅包括浮点数、整数、布尔列。对于 Series 未实现。

**kwargs

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

Series 或标量

示例

>>> s = pd.Series([1, 2, 3])
>>> s.mean()
2.0

对于 DataFrame

>>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])
>>> df
 a   b
tiger  1   2
zebra  2   3
>>> df.mean()
a   1.5
b   2.5
dtype: float64

使用 axis=1

>>> df.mean(axis=1)
tiger   1.5
zebra   2.5
dtype: float64

在这种情况下，应将 numeric_only 设置为 True 以避免出错。

>>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},
...                   index=['tiger', 'zebra'])
>>> df.mean(numeric_only=True)
a   1.5
dtype: float64

`pandas.DataFrame.median`

原文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.median.html

DataFrame.median(axis=0, skipna=True, numeric_only=False, **kwargs)

返回请求轴上值的中位数。

参数：

轴

要应用函数的轴。对于 Series，此参数未使用且默认为 0。

对于 DataFrames，指定 axis=None 将在两个轴上应用聚合。

版本 2.0.0 中的新功能。

skipna 布尔值，默认为 True

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

numeric_only 布尔值，默认为 False

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

**kwargs

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

Series 或标量

示例

>>> s = pd.Series([1, 2, 3])
>>> s.median()
2.0

使用 DataFrame

>>> df = pd.DataFrame({'a': [1, 2], 'b': [2, 3]}, index=['tiger', 'zebra'])
>>> df
 a   b
tiger  1   2
zebra  2   3
>>> df.median()
a   1.5
b   2.5
dtype: float64

使用 axis=1

>>> df.median(axis=1)
tiger   1.5
zebra   2.5
dtype: float64

在这种情况下，应将 numeric_only 设置为 True 以避免出错。

>>> df = pd.DataFrame({'a': [1, 2], 'b': ['T', 'Z']},
...                   index=['tiger', 'zebra'])
>>> df.median(numeric_only=True)
a   1.5
dtype: float64

posted @ 2024-06-24 16:21 绝不原创的飞龙阅读(13) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Pandas-2-2-中文文档-三十四-

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

· c、Pandas

· Pandas备忘录（持续更新）

· 数据分析 - pandas-note

历史上的今天：
2021-06-24 如何评价「施一公请辞清华大学副校长，全职执掌西湖大学」？你如何看待西湖大学的发展前景？

公告

Github：@wizardforcel

简书：@布客飞龙

微博：@布客飞龙

赞助我：

昵称：绝不原创的飞龙
园龄： 5年2个月
粉丝： 67
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

掠夺·扩张·投机·博弈

Pandas 2.2 中文文档（二十一）

pandas.DataFrame.gt

pandas.DataFrame.le

pandas.DataFrame.ge

pandas.DataFrame.ne

pandas.DataFrame.eq

pandas.DataFrame.combine

pandas.DataFrame.combine_first

pandas.DataFrame.apply

pandas.DataFrame.map

pandas.DataFrame.applymap

pandas.DataFrame.pipe

pandas.DataFrame.agg

pandas.DataFrame.aggregate

pandas.DataFrame.transform

pandas.DataFrame.groupby

pandas.DataFrame.rolling

pandas.DataFrame.expanding

pandas.DataFrame.ewm

pandas.DataFrame.abs

pandas.DataFrame.all

pandas.DataFrame.any

pandas.DataFrame.clip

pandas.DataFrame.corr

pandas.DataFrame.corrwith

pandas.DataFrame.count

pandas.DataFrame.cov

pandas.DataFrame.cummax

pandas.DataFrame.cummin

pandas.DataFrame.cumprod

pandas.DataFrame.cumsum

pandas.DataFrame.describe

pandas.DataFrame.diff

pandas.DataFrame.eval

pandas.DataFrame.kurt

pandas.DataFrame.kurtosis

pandas.DataFrame.max

pandas.DataFrame.mean

pandas.DataFrame.median

公告

搜索

常用链接

随笔档案

`pandas.DataFrame.gt`

`pandas.DataFrame.le`

`pandas.DataFrame.ge`

`pandas.DataFrame.ne`

`pandas.DataFrame.eq`

`pandas.DataFrame.combine`

`pandas.DataFrame.combine_first`

`pandas.DataFrame.apply`

`pandas.DataFrame.map`

`pandas.DataFrame.applymap`

`pandas.DataFrame.pipe`

`pandas.DataFrame.agg`

`pandas.DataFrame.aggregate`

`pandas.DataFrame.transform`

`pandas.DataFrame.groupby`

`pandas.DataFrame.rolling`

`pandas.DataFrame.expanding`

`pandas.DataFrame.ewm`

`pandas.DataFrame.abs`

`pandas.DataFrame.all`

`pandas.DataFrame.any`

`pandas.DataFrame.clip`

`pandas.DataFrame.corr`

`pandas.DataFrame.corrwith`

`pandas.DataFrame.count`

`pandas.DataFrame.cov`

`pandas.DataFrame.cummax`

`pandas.DataFrame.cummin`

`pandas.DataFrame.cumprod`

`pandas.DataFrame.cumsum`

`pandas.DataFrame.describe`

`pandas.DataFrame.diff`

`pandas.DataFrame.eval`

`pandas.DataFrame.kurt`

`pandas.DataFrame.kurtosis`

`pandas.DataFrame.max`

`pandas.DataFrame.mean`

`pandas.DataFrame.median`