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

Pandas 2.2 中文文档（二十二）

原文：pandas.pydata.org/docs/

`pandas.DataFrame.min`

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

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

返回所请求轴的最小值。

如果要获取最小值的索引，请使用 idxmin。这相当于 numpy.ndarray 方法 argmin。

参数：

axis

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

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

新版本 2.0.0 中新增。

skipnabool，默认为 True

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

numeric_onlybool，默认为 False

仅包含 float、int、boolean 列。对于 Series，未实现。

kwargs

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

Series 或标量

另请参阅

返回总和。

返回最小值。

返回最大值。

返回最小值的索引。

返回最大值的索引。

返回所请求轴的总和。

返回所请求轴的最小值。

返回所请求轴的最大值。

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

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

示例

>>> 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.min()
0

`pandas.DataFrame.mode`

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

DataFrame.mode(axis=0, numeric_only=False, dropna=True)

获取沿选定轴的每个元素的众数。

一组值的众数是出现频率最高的值。它可以是多个值。

参数：

axis {0 或 'index'，1 或 'columns'}，默认为 0

在搜索众数时要迭代的轴：

0 或 'index'：获取每列的众数
1 或 'columns'：获取每行的众数。

numeric_only 布尔值，默认为 False

如果为 True，则仅应用于数值列。

dropna 布尔值，默认为 True

不考虑 NaN/NaT 的计数。

DataFrame

每列或每行的众数。

另请参阅

Series.mode

返回 Series 中出现频率最高的值。

Series.value_counts

返回 Series 中值的计数。

示例

>>> df = pd.DataFrame([('bird', 2, 2),
...                    ('mammal', 4, np.nan),
...                    ('arthropod', 8, 0),
...                    ('bird', 2, np.nan)],
...                   index=('falcon', 'horse', 'spider', 'ostrich'),
...                   columns=('species', 'legs', 'wings'))
>>> df
 species  legs  wings
falcon        bird     2    2.0
horse       mammal     4    NaN
spider   arthropod     8    0.0
ostrich       bird     2    NaN

默认情况下，不考虑缺失值，翅膀的众数为 0 和 2。由于生成的 DataFrame 有两行，因此species和legs的第二行包含NaN。

>>> df.mode()
 species  legs  wings
0    bird   2.0    0.0
1     NaN   NaN    2.0

设置 dropna=False，将考虑NaN值，它们可以是众数（比如翅膀）。

>>> df.mode(dropna=False)
 species  legs  wings
0    bird     2    NaN

设置 numeric_only=True，仅计算数值列的众数，忽略其他类型的列。

>>> df.mode(numeric_only=True)
 legs  wings
0   2.0    0.0
1   NaN    2.0

要在列而不是行上计算众数，请使用 axis 参数：

>>> df.mode(axis='columns', numeric_only=True)
 0    1
falcon   2.0  NaN
horse    4.0  NaN
spider   0.0  8.0
ostrich  2.0  NaN

`pandas.DataFrame.pct_change`

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

DataFrame.pct_change(periods=1, fill_method=_NoDefault.no_default, limit=_NoDefault.no_default, freq=None, **kwargs)

当前元素与先前元素之间的分数变化。

默认情况下，计算与上一行的分数变化。这在比较时间序列元素的变化分数时很有用。

注意

尽管这个方法的名称是这样的，但它计算的是分数变化（也称为单位变化或相对变化），而不是百分比变化。如果你需要百分比变化，请将这些值乘以 100。

参数：

periodsint，默认为 1

形成百分比变化所需的周期数。

fill_method，默认为‘pad’

在计算百分比变化之前如何处理缺失值。

自版本 2.1 起已弃用：除 fill_method=None 之外，所有 fill_method 选项均已弃用。

limitint，默认为 None

在停止之前填充的连续 NA 的数量。

自版本 2.1 起已弃用。

freqDateOffset、timedelta 或 str，可选

从时间序列 API 中使用的增量（例如‘ME’或 BDay()）。

**kwargs

额外的关键字参数传递到 DataFrame.shift 或 Series.shift 中。

Series 或 DataFrame

与调用对象相同的类型。

另请参阅

Series.diff

计算 Series 中两个元素的差异。

DataFrame.diff

计算 DataFrame 中两个元素的差异。

Series.shift

将索引向前或向后移动若干周期。

DataFrame.shift

将索引向前或向后移动若干周期。

示例

Series

>>> s = pd.Series([90, 91, 85])
>>> s
0    90
1    91
2    85
dtype: int64

>>> s.pct_change()
0         NaN
1    0.011111
2   -0.065934
dtype: float64

>>> s.pct_change(periods=2)
0         NaN
1         NaN
2   -0.055556
dtype: float64

查看在 Series 中的百分比变化，其中将 NA 填充为最后一个有效观察值向前到下一个有效观察值。

>>> s = pd.Series([90, 91, None, 85])
>>> s
0    90.0
1    91.0
2     NaN
3    85.0
dtype: float64

>>> s.ffill().pct_change()
0         NaN
1    0.011111
2    0.000000
3   -0.065934
dtype: float64

DataFrame

法国法郎、德国马克和意大利里拉在 1980-01-01 至 1980-03-01 之间的百分比变化。

>>> df = pd.DataFrame({
...     'FR': [4.0405, 4.0963, 4.3149],
...     'GR': [1.7246, 1.7482, 1.8519],
...     'IT': [804.74, 810.01, 860.13]},
...     index=['1980-01-01', '1980-02-01', '1980-03-01'])
>>> df
 FR      GR      IT
1980-01-01  4.0405  1.7246  804.74
1980-02-01  4.0963  1.7482  810.01
1980-03-01  4.3149  1.8519  860.13

>>> df.pct_change()
 FR        GR        IT
1980-01-01       NaN       NaN       NaN
1980-02-01  0.013810  0.013684  0.006549
1980-03-01  0.053365  0.059318  0.061876

GOOG 和 APPL 股票交易量的变化百分比。展示了在列之间计算百分比变化。

>>> df = pd.DataFrame({
...     '2016': [1769950, 30586265],
...     '2015': [1500923, 40912316],
...     '2014': [1371819, 41403351]},
...     index=['GOOG', 'APPL'])
>>> df
 2016      2015      2014
GOOG   1769950   1500923   1371819
APPL  30586265  40912316  41403351

>>> df.pct_change(axis='columns', periods=-1)
 2016      2015  2014
GOOG  0.179241  0.094112   NaN
APPL -0.252395 -0.011860   NaN

`pandas.DataFrame.prod`

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

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

返回请求轴上的值的乘积。

参数：

axis

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

警告

DataFrame.prod 在axis=None的行为已被弃用，在将来的版本中，这将在两个轴上减少并返回一个标量。要保留旧行为，请传递 axis=0（或不传递 axis）。

版本 2.0.0 中的新功能。

skipnabool，默认为 True

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

numeric_onlybool，默认为 False

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

min_countint，默认为 0

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

**kwargs

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

Series 或标量

另请参阅

返回总和。

返回最小值。

返回最大值。

返回最小值的索引。

返回最大值的索引。

返回请求轴上的总和。

返回请求轴上的最小值。

返回请求轴上的最大值。

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

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

示例

默认情况下，空或全 NA Series 的乘积为1

>>> pd.Series([], dtype="float64").prod()
1.0

可以通过min_count参数进行控制

>>> pd.Series([], dtype="float64").prod(min_count=1)
nan

由于skipna参数，min_count处理所有 NA 和空系列的方式相同。

>>> pd.Series([np.nan]).prod()
1.0

>>> pd.Series([np.nan]).prod(min_count=1)
nan

`pandas.DataFrame.product`

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

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

返回请求轴上的值的乘积。

参数：

axis

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

警告

使用axis=None调用 DataFrame.prod 的行为已被弃用，在将来的版本中，这将在两个轴上进行缩减并返回一个标量。要保留旧的行为，请传递 axis=0（或不传递 axis）。

版本 2.0.0 中的新功能。

skipnabool，默认为 True

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

numeric_onlybool，默认为 False

仅包括 float、int、boolean 列。不适用于 Series。

min_countint，默认为 0

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

**kwargs

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

Series 或标量

另请参阅

Series.sum

返回总和。

Series.min

返回最小值。

Series.max

返回最大值。

Series.idxmin

返回最小值的索引。

Series.idxmax

返回最大值的索引。

DataFrame.sum

返回请求轴上的总和。

DataFrame.min

返回请求轴上的最小值。

DataFrame.max

返回请求轴上的最大值。

DataFrame.idxmin

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

DataFrame.idxmax

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

示例

默认情况下，空或全 NA Series 的乘积为1

>>> pd.Series([], dtype="float64").prod()
1.0

可以使用min_count参数来控制此行为

>>> pd.Series([], dtype="float64").prod(min_count=1)
nan

由于skipna参数的存在，min_count可以处理所有 NA 和空 Series 的情况。

>>> pd.Series([np.nan]).prod()
1.0

>>> pd.Series([np.nan]).prod(min_count=1)
nan

`pandas.DataFrame.quantile`

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

DataFrame.quantile(q=0.5, axis=0, numeric_only=False, interpolation='linear', method='single')

返回请求轴上给定分位数处的值。

参数：

q浮点数或类数组，默认为 0.5（50%分位数）

值在 0 <= q <= 1 之间，要计算的分位数。

轴，默认为 0

等于 0 或‘index’表示按行，1 或‘columns’表示按列。

numeric_only布尔值，默认为 False

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

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

插值

这个可选参数指定插值方法，当所需分位数位于两个数据点 i 和 j 之间时使用：

linear：i + (j - i) * fraction，其中 fraction 是被 i 和 j 包围的索引的小数部分。
lower：i。
higher：j。
nearest：最接近的 i 或 j。
中点：(i + j) / 2。

方法，默认为‘single’

是否按列计算分位数（‘single’）还是所有列（‘table’）。当为‘table’时，唯一允许的插值方法是‘nearest’、‘lower’和‘higher’。

Series 或 DataFrame

如果q是一个数组，将返回一个 DataFrame，其中

索引是q，列是 self 的列，值是分位数。

如果q是一个浮点数，将返回一个 Series，其中

索引是 self 的列，值是分位数。

参见

core.window.rolling.Rolling.quantile

滚动分位数。

numpy.percentile

用于计算百分位数的 Numpy 函数。

示例

>>> df = pd.DataFrame(np.array([[1, 1], [2, 10], [3, 100], [4, 100]]),
...                   columns=['a', 'b'])
>>> df.quantile(.1)
a    1.3
b    3.7
Name: 0.1, dtype: float64
>>> df.quantile([.1, .5])
 a     b
0.1  1.3   3.7
0.5  2.5  55.0

指定 method=‘table’将计算所有列的分位数。

>>> df.quantile(.1, method="table", interpolation="nearest")
a    1
b    1
Name: 0.1, dtype: int64
>>> df.quantile([.1, .5], method="table", interpolation="nearest")
 a    b
0.1  1    1
0.5  3  100

指定 numeric_only=False 还将计算日期时间和时间增量数据的分位数。

>>> df = pd.DataFrame({'A': [1, 2],
...                    'B': [pd.Timestamp('2010'),
...                          pd.Timestamp('2011')],
...                    'C': [pd.Timedelta('1 days'),
...                          pd.Timedelta('2 days')]})
>>> df.quantile(0.5, numeric_only=False)
A                    1.5
B    2010-07-02 12:00:00
C        1 days 12:00:00
Name: 0.5, dtype: object

`pandas.DataFrame.rank`

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

DataFrame.rank(axis=0, method='average', numeric_only=False, na_option='keep', ascending=True, pct=False)

沿轴计算数值数据等级（1 到 n）。

默认情况下，相等的值被分配一个等级，该等级是这些值的等级的平均值。

参数：

axis，默认为 0

直接排名的索引。对于 Series 对象，此参数未使用并默认为 0。

method，默认为 ‘average’

如何对具有相同值（即并列）的记录组进行排名：

average: 组的平均等级
min: lowest rank in the group
max: 组内最高等级
first: 按数组中出现的顺序分配的等级
dense: 类似于 'min'，但在组之间等级始终增加 1。

numeric_onlybool，默认值 False

对于 DataFrame 对象，如果设置为 True，则仅对数值列进行排名。

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

na_option，默认为 ‘keep’

如何对 NaN 值进行排名：

keep: 将 NaN 值的等级分配给 NaN 值
top: assign lowest rank to NaN values
bottom: 将最高等级分配给 NaN 值

ascendingbool，默认为 True

元素是否应按升序排名。

pctbool，默认为 False

是否以百分位形式显示返回的排名。

与调用者相同的类型

返回具有数据等级作为值的 Series 或 DataFrame。

另请参阅

core.groupby.DataFrameGroupBy.rank

每个组内的值的等级。

core.groupby.SeriesGroupBy.rank

每个组内的值的等级。

示例

>>> df = pd.DataFrame(data={'Animal': ['cat', 'penguin', 'dog',
...                                    'spider', 'snake'],
...                         'Number_legs': [4, 2, 4, 8, np.nan]})
>>> df
 Animal  Number_legs
0      cat          4.0
1  penguin          2.0
2      dog          4.0
3   spider          8.0
4    snake          NaN

平局的等级（默认情况下）被分配给组的并列值。

>>> s = pd.Series(range(5), index=list("abcde"))
>>> s["d"] = s["b"]
>>> s.rank()
a    1.0
b    2.5
c    4.0
d    2.5
e    5.0
dtype: float64

下面的示例显示了上述参数的方法行为：

default_rank: 这是在不使用任何参数的情况下获得的默认行为。
max_rank: 设置 method = 'max' 后，具有相同值的记录将使用最高等级进行排名（例如：由于 'cat' 和 'dog' 都处于第 2 和第 3 位置，因此分配等级 3。）
NA_bottom: 选择 na_option = 'bottom'，如果存在 NaN 值的记录，则将它们放在排名的底部。
pct_rank: 当设置 pct = True 时，排名表示为百分位数排名。

>>> df['default_rank'] = df['Number_legs'].rank()
>>> df['max_rank'] = df['Number_legs'].rank(method='max')
>>> df['NA_bottom'] = df['Number_legs'].rank(na_option='bottom')
>>> df['pct_rank'] = df['Number_legs'].rank(pct=True)
>>> df
 Animal  Number_legs  default_rank  max_rank  NA_bottom  pct_rank
0      cat          4.0           2.5       3.0        2.5     0.625
1  penguin          2.0           1.0       1.0        1.0     0.250
2      dog          4.0           2.5       3.0        2.5     0.625
3   spider          8.0           4.0       4.0        4.0     1.000
4    snake          NaN           NaN       NaN        5.0       NaN

`pandas.DataFrame.round`

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

DataFrame.round(decimals=0, *args, **kwargs)

将 DataFrame 四舍五入到可变小数位数。

参数：

decimalsint，dict，Series

要将每列舍入到的小数位数。如果给定一个整数，则将每列舍入到相同的位数。否则，dict 和 Series 将舍入到不同数量的位数。如果 decimals 是类似 dict 的，则列名应该在键中，如果 decimals 是 Series，则列名应该在索引中。未包括在 decimals 中的任何列将保持不变。不是输入的列的 decimals 元素将被忽略。

*args

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

**kwargs

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

DataFrame

一个 DataFrame，其中受影响的列四舍五入到指定的小数位数。

另请参阅

numpy.around

将 numpy 数组四舍五入到给定的小数位数。

Series.round

将 Series 四舍五入到给定的小数位数。

示例

>>> df = pd.DataFrame([(.21, .32), (.01, .67), (.66, .03), (.21, .18)],
...                   columns=['dogs', 'cats'])
>>> df
 dogs  cats
0  0.21  0.32
1  0.01  0.67
2  0.66  0.03
3  0.21  0.18

通过提供一个整数，每列都会四舍五入到相同的小数位数。

>>> df.round(1)
 dogs  cats
0   0.2   0.3
1   0.0   0.7
2   0.7   0.0
3   0.2   0.2

使用字典，可以通过列名作为键和小数位数作为值来指定特定列的小数位数。

>>> df.round({'dogs': 1, 'cats': 0})
 dogs  cats
0   0.2   0.0
1   0.0   1.0
2   0.7   0.0
3   0.2   0.0

使用 Series，可以通过列名作为索引和小数位数作为值来指定特定列的小数位数。

>>> decimals = pd.Series([0, 1], index=['cats', 'dogs'])
>>> df.round(decimals)
 dogs  cats
0   0.2   0.0
1   0.0   1.0
2   0.7   0.0
3   0.2   0.0

`pandas.DataFrame.sem`

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

DataFrame.sem(axis=0, skipna=True, ddof=1, numeric_only=False, **kwargs)

返回请求轴上的无偏均值标准误差。

默认情况下通过 N-1 进行标准化。可以使用 ddof 参数进行更改。

参数：

轴

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

警告

使用 axis=None 的 DataFrame.sem 的行为已被弃用，在将来的版本中，这将在两个轴上减少并返回一个标量。要保留旧行为，传递 axis=0（或不传递 axis）。

skipnabool，默认为 True

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

ddofint，默认为 1

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

numeric_onlybool，默认为 False

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

Series 或 DataFrame（如果指定了级别）

示例

>>> s = pd.Series([1, 2, 3])
>>> s.sem().round(6)
0.57735

对于 DataFrame

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

使用 axis=1

>>> df.sem(axis=1)
tiger   0.5
zebra   0.5
dtype: float64

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

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

`pandas.DataFrame.skew`

pandas.pydata.org/docs/reference/api/pandas.DataFrame.skew.html

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

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

标准化为 N-1。

Parameters:

axis

Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.

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

自版本 2.0.0 起新增。

skipnabool，默认为 True

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

numeric_onlybool，默认为 False

仅包括浮点型、整型和布尔型列。对于 Series，此参数未实现。

**kwargs

Additional keyword arguments to be passed to the function.

Series 或标量

Examples

>>> s = pd.Series([1, 2, 3])
>>> s.skew()
0.0

使用 DataFrame 时

>>> df = pd.DataFrame({'a': [1, 2, 3], 'b': [2, 3, 4], 'c': [1, 3, 5]},
...                   index=['tiger', 'zebra', 'cow'])
>>> df
 a   b   c
tiger   1   2   1
zebra   2   3   3
cow     3   4   5
>>> df.skew()
a   0.0
b   0.0
c   0.0
dtype: float64

使用 axis=1

>>> df.skew(axis=1)
tiger   1.732051
zebra  -1.732051
cow     0.000000
dtype: float64

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

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

`pandas.DataFrame.sum`

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

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

返回请求轴上的值的总和。

这等同于方法numpy.sum。

参数：

axis

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

警告

具有axis=None的 DataFrame.sum 的行为已被弃用，在将来的版本中，这将在两个轴上减少并返回一个标量，为保留旧行为，请传递 axis=0（或不传递 axis）。

2.0.0 版本中的新功能。

skipna布尔值，默认为 True

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

numeric_only布尔值，默认为 False

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

min_count整数，默认为 0

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

**kwargs

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

Series 或标量

另请参阅

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.sum()
14

默认情况下，空或全部 NA Series 的总和为0。

>>> pd.Series([], dtype="float64").sum()  # min_count=0 is the default
0.0

可以使用min_count参数进行控制。例如，如果希望空系列的总和为 NaN，请传递min_count=1。

>>> pd.Series([], dtype="float64").sum(min_count=1)
nan

由于skipna参数的存在，min_count处理所有 NA 和空系列的方式相同。

>>> pd.Series([np.nan]).sum()
0.0

>>> pd.Series([np.nan]).sum(min_count=1)
nan

`pandas.DataFrame.std`

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

DataFrame.std(axis=0, skipna=True, ddof=1, numeric_only=False, **kwargs)

返回请求轴上的样本标准差。

默认情况下通过 N-1 进行标准化。可以使用 ddof 参数进行更改。

参数：

轴

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

警告

DataFrame.std 在axis=None下的行为已被弃用，在将来的版本中，这将减少两个轴并返回一个标量。要保留旧的行为，请传递 axis=0（或不传递 axis）。

skipna布尔值，默认为 True

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

ddof整数，默认为 1

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

numeric_only布尔值，默认为 False

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

Series 或 DataFrame（如果指定了级别）

注意

要使行为与 numpy.std 相同，请使用 ddof=0（而不是默认的 ddof=1）

示例

>>> df = pd.DataFrame({'person_id': [0, 1, 2, 3],
...                    'age': [21, 25, 62, 43],
...                    'height': [1.61, 1.87, 1.49, 2.01]}
...                   ).set_index('person_id')
>>> df
 age  height
person_id
0           21    1.61
1           25    1.87
2           62    1.49
3           43    2.01

列的标准差可以如下找到：

>>> df.std()
age       18.786076
height     0.237417
dtype: float64

或者，可以将 ddof=0 设置为通过 N 而不是 N-1 进行标准化：

>>> df.std(ddof=0)
age       16.269219
height     0.205609
dtype: float64

`pandas.DataFrame.var`

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

DataFrame.var(axis=0, skipna=True, ddof=1, numeric_only=False, **kwargs)

返回请求轴上的无偏方差。

默认按 N-1 进行标准化。可以使用 ddof 参数进行更改。

参数：

axis {索引 (0)，列 (1)}

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

警告

DataFrame.var 对于 axis=None 的行为已经过时，在将来的版本中，这将在两个轴上进行缩减并返回一个标量。为保留旧的行为，请传递 axis=0（或者不传递 axis）。

skipna bool，默认值为 True

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

ddof int，默认值为 1

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

numeric_only bool，默认值为 False

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

Series 或 DataFrame（如果指定了级别）

示例

>>> df = pd.DataFrame({'person_id': [0, 1, 2, 3],
...                    'age': [21, 25, 62, 43],
...                    'height': [1.61, 1.87, 1.49, 2.01]}
...                   ).set_index('person_id')
>>> df
 age  height
person_id
0           21    1.61
1           25    1.87
2           62    1.49
3           43    2.01

>>> df.var()
age       352.916667
height      0.056367
dtype: float64

或者，可以设置 ddof=0 来通过 N 而不是 N-1 进行标准化：

>>> df.var(ddof=0)
age       264.687500
height      0.042275
dtype: float64

`pandas.DataFrame.nunique`

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

DataFrame.nunique(axis=0, dropna=True)

统计指定轴上不同元素的数量。

返回一个包含不同元素数量的 Series。可以忽略 NaN 值。

参数：

axis，默认为 0

要使用的轴。行向为 0 或 'index'，列向为 1 或 'columns'。

dropnabool，默认为 True

在计数中不包括 NaN 值。

返回值：

Series

另请参阅

Series.nunique

Series 的 nunique 方法。

DataFrame.count

统计每列或每行中非 NA 单元格的数量。

示例

>>> df = pd.DataFrame({'A': [4, 5, 6], 'B': [4, 1, 1]})
>>> df.nunique()
A    3
B    2
dtype: int64

>>> df.nunique(axis=1)
0    1
1    2
2    2
dtype: int64

`pandas.DataFrame.value_counts`

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

DataFrame.value_counts(subset=None, normalize=False, sort=True, ascending=False, dropna=True)

返回一个包含 Dataframe 中每个不同行频率的 Series。

参数：

subset 标签或标签列表，可选

在计算唯一组合时要使用的列。

normalize 布尔值，默认为 False

返回比例而不是频率。

sort 布尔值，默认为 True

当为 True 时按频率排序。当为 False 时按 DataFrame 列值排序。

ascending 布尔值，默认为 False

按升序排序。

dropna 布尔值，默认为 True

不包括包含 NA 值的行的计数。

版本 1.3.0 中的新功能。

Series

另请参阅

Series.value_counts

Series 上的等效方法。

注意

返回的 Series 将具有一个 MultiIndex，每个输入列对应一个级别，但对于单个标签则为一个 Index（非多级）。默认情况下，结果中省略了包含任何 NA 值的行。默认情况下，生成的 Series 将按降序排列，以使第一个元素是出现频率最高的行。

示例

>>> df = pd.DataFrame({'num_legs': [2, 4, 4, 6],
...                    'num_wings': [2, 0, 0, 0]},
...                   index=['falcon', 'dog', 'cat', 'ant'])
>>> df
 num_legs  num_wings
falcon         2          2
dog            4          0
cat            4          0
ant            6          0

>>> df.value_counts()
num_legs  num_wings
4         0            2
2         2            1
6         0            1
Name: count, dtype: int64

>>> df.value_counts(sort=False)
num_legs  num_wings
2         2            1
4         0            2
6         0            1
Name: count, dtype: int64

>>> df.value_counts(ascending=True)
num_legs  num_wings
2         2            1
6         0            1
4         0            2
Name: count, dtype: int64

>>> df.value_counts(normalize=True)
num_legs  num_wings
4         0            0.50
2         2            0.25
6         0            0.25
Name: proportion, dtype: float64

当 dropna 设置为 False 时，我们还可以计算包含 NA 值的行。

>>> df = pd.DataFrame({'first_name': ['John', 'Anne', 'John', 'Beth'],
...                    'middle_name': ['Smith', pd.NA, pd.NA, 'Louise']})
>>> df
 first_name middle_name
0       John       Smith
1       Anne        <NA>
2       John        <NA>
3       Beth      Louise

>>> df.value_counts()
first_name  middle_name
Beth        Louise         1
John        Smith          1
Name: count, dtype: int64

>>> df.value_counts(dropna=False)
first_name  middle_name
Anne        NaN            1
Beth        Louise         1
John        Smith          1
 NaN            1
Name: count, dtype: int64

>>> df.value_counts("first_name")
first_name
John    2
Anne    1
Beth    1
Name: count, dtype: int64

`pandas.DataFrame.add_prefix`

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

DataFrame.add_prefix(prefix, axis=None)

在标签前添加字符串前缀。

对于 Series，行标签会被添加前缀。对于 DataFrame，列标签会被添加前缀。

参数：

prefixstr

要在每个标签前添加的字符串。

axis，默认为 None

要添加前缀的轴

版本 2.0.0 中的新功能。

Series 或 DataFrame

带有更新标签的新 Series 或 DataFrame。

另请参阅

Series.add_suffix

在行标签后添加字符串后缀。

DataFrame.add_suffix

在列标签后添加字符串后缀。

示例

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

>>> s.add_prefix('item_')
item_0    1
item_1    2
item_2    3
item_3    4
dtype: int64

>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df
 A  B
0  1  3
1  2  4
2  3  5
3  4  6

>>> df.add_prefix('col_')
 col_A  col_B
0       1       3
1       2       4
2       3       5
3       4       6

`pandas.DataFrame.add_suffix`

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

DataFrame.add_suffix(suffix, axis=None)

使用字符串后缀标记标签。

对于 Series，行标签是后缀的。对于 DataFrame，列标签是后缀的。

参数：

suffixstr

在每个标签后添加的字符串。

axis，默认为 None

要添加后缀的轴

自 2.0.0 版新功能。

Series 或 DataFrame

返回带有更新标签的新 Series 或 DataFrame。

另请参见

Series.add_prefix

用字符串前缀给行标签加上前缀。

DataFrame.add_prefix

用字符串前缀给列标签加上前缀。

示例

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

>>> s.add_suffix('_item')
0_item    1
1_item    2
2_item    3
3_item    4
dtype: int64

>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]})
>>> df
 A  B
0  1  3
1  2  4
2  3  5
3  4  6

>>> df.add_suffix('_col')
 A_col  B_col
0       1       3
1       2       4
2       3       5
3       4       6

`pandas.DataFrame.align`

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

DataFrame.align(other, join='outer', axis=None, level=None, copy=None, fill_value=None, method=_NoDefault.no_default, limit=_NoDefault.no_default, fill_axis=_NoDefault.no_default, broadcast_axis=_NoDefault.no_default)

使用指定的连接方法在它们的轴上对齐两个对象。

为每个轴索引指定连接方法。

参数：

otherDataFrame 或 Series

join，默认为‘outer’

要执行的对齐类型。

left：仅使用左侧框架的键，保留键顺序。
right：仅使用右侧框架的键，保留键顺序。
outer：使用两个框架的键的并集，按词典顺序排序键。
inner：使用两个框架的键的交集，保留左侧键的顺序。

axis另一个对象的允许轴，默认为 None

在索引（0）、列（1）或两者（None）上对齐。

levelint 或级别名称，默认为 None

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

copy布尔值，默认为 True

始终返回新对象。如果 copy=False 并且不需要重新索引，则返回原始对象。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。 copy 关键字将在未来的 pandas 版本中被移除。

通过启用写时复制pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

fill_value标量，默认为 np.nan

用于缺失值的值。默认为 NaN，但可以是任何“兼容”的值。

method，默认为 None

用于填充重新索引 Series 中空洞的方法：

pad / ffill：将最后一个有效观察结果向前传播到下一个有效观察结果。
backfill / bfill: 使用下一个有效观察结果来填补间隙。

自版本 2.1 起已弃用。

limitint，默认为 None

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

自版本 2.1 起已弃用。

fill_axis 用于 Series，{0 或 ‘index’，1 或 ‘columns’} 用于 DataFrame，默认为 0

填充轴、方法和限制。

自版本 2.1 起已弃用。

broadcast_axis 用于 Series，{0 或 ‘index’，1 或 ‘columns’} 用于 DataFrame，默认为 None

如果需要将两个不同维度的对象对齐，则沿此轴广播值。

自版本 2.1 起已弃用。

元组（Series/DataFrame，其他类型）

对齐的对象。

示例

>>> df = pd.DataFrame(
...     [[1, 2, 3, 4], [6, 7, 8, 9]], columns=["D", "B", "E", "A"], index=[1, 2]
... )
>>> other = pd.DataFrame(
...     [[10, 20, 30, 40], [60, 70, 80, 90], [600, 700, 800, 900]],
...     columns=["A", "B", "C", "D"],
...     index=[2, 3, 4],
... )
>>> df
 D  B  E  A
1  1  2  3  4
2  6  7  8  9
>>> other
 A    B    C    D
2   10   20   30   40
3   60   70   80   90
4  600  700  800  900

在列上对齐：

>>> left, right = df.align(other, join="outer", axis=1)
>>> left
 A  B   C  D  E
1  4  2 NaN  1  3
2  9  7 NaN  6  8
>>> right
 A    B    C    D   E
2   10   20   30   40 NaN
3   60   70   80   90 NaN
4  600  700  800  900 NaN

我们还可以根据索引对齐：

>>> left, right = df.align(other, join="outer", axis=0)
>>> left
 D    B    E    A
1  1.0  2.0  3.0  4.0
2  6.0  7.0  8.0  9.0
3  NaN  NaN  NaN  NaN
4  NaN  NaN  NaN  NaN
>>> right
 A      B      C      D
1    NaN    NaN    NaN    NaN
2   10.0   20.0   30.0   40.0
3   60.0   70.0   80.0   90.0
4  600.0  700.0  800.0  900.0

最后，默认的 axis=None 将在索引和列上对齐：

>>> left, right = df.align(other, join="outer", axis=None)
>>> left
 A    B   C    D    E
1  4.0  2.0 NaN  1.0  3.0
2  9.0  7.0 NaN  6.0  8.0
3  NaN  NaN NaN  NaN  NaN
4  NaN  NaN NaN  NaN  NaN
>>> right
 A      B      C      D   E
1    NaN    NaN    NaN    NaN NaN
2   10.0   20.0   30.0   40.0 NaN
3   60.0   70.0   80.0   90.0 NaN
4  600.0  700.0  800.0  900.0 NaN

`pandas.DataFrame.at_time`

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

DataFrame.at_time(time, asof=False, axis=None)

选择特定时间段内的数值（例如，上午 9:30）。

参数：

timedatetime.time 或 str

要选择的数值。

axis，默认为 0

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

Series 或 DataFrame

引发：

TypeError

如果索引不是DatetimeIndex

另请参阅

between_time

选择特定时间段内的数值。

first

基于日期偏移量选择时间序列的初始时间段。

last

基于日期偏移量选择时间序列的最终时间段。

DatetimeIndex.indexer_at_time

获取特定时间段的数值的索引位置。

示例

>>> i = pd.date_range('2018-04-09', periods=4, freq='12h')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
 A
2018-04-09 00:00:00  1
2018-04-09 12:00:00  2
2018-04-10 00:00:00  3
2018-04-10 12:00:00  4

>>> ts.at_time('12:00')
 A
2018-04-09 12:00:00  2
2018-04-10 12:00:00  4

`pandas.DataFrame.between_time`

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

DataFrame.between_time(start_time, end_time, inclusive='both', axis=None)

选择一天中特定时间之间的值（例如，上午 9:00-9:30）。

通过将 start_time 设置为晚于 end_time，您可以获得那些不在两个时间之间的时间。

参数：

start_timedatetime.time 或 str

初始时间作为时间过滤限制。

end_timedatetime.time 或 str

结束时间作为时间过滤限制。

inclusive，默认为 “both”

包括边界；是否将每个边界设置为闭合或开放。

axis，默认为 0

确定索引或列值上的范围时间。对于 Series，此参数未使用，默认为 0。

Series 或 DataFrame

从原始对象中过滤到指定日期范围的数据。

引发：

TypeError

如果索引不是 DatetimeIndex

另请参见

at_time

选择一天中特定时间的值。

first

基于日期偏移选择时间序列的初始时间段。

last

基于日期偏移选择时间序列的最终时间段。

DatetimeIndex.indexer_between_time

仅获取一天中特定时间之间的索引位置。

示例

>>> i = pd.date_range('2018-04-09', periods=4, freq='1D20min')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
 A
2018-04-09 00:00:00  1
2018-04-10 00:20:00  2
2018-04-11 00:40:00  3
2018-04-12 01:00:00  4

>>> ts.between_time('0:15', '0:45')
 A
2018-04-10 00:20:00  2
2018-04-11 00:40:00  3

通过将 start_time 设置为晚于 end_time，您可以获得那些不在两个时间之间的时间：

>>> ts.between_time('0:45', '0:15')
 A
2018-04-09 00:00:00  1
2018-04-12 01:00:00  4

`pandas.DataFrame.drop`

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

DataFrame.drop(labels=None, *, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

从行或列中删除指定的标签。

通过指定标签名称和相应轴，或直接指定索引或列名称来删除行或列。在使用多重索引时，可以通过指定级别来删除不同级别的标签。有关有关当前未使用的级别的更多信息，请参见用户指南。

参数：

labels单个标签或类似列表

要删除的索引或列标签。元组将被用作单个标签，而不被视为类似列表。

axis，默认为 0

是否从索引（0 或 ‘index’）或列（1 或 ‘columns’）中删除标签。

index单个标签或类似列表

指定轴的替代方法（labels, axis=0 等同于 index=labels）。

columns单个标签或类似列表

指定轴的替代方法（labels, axis=1 等同于 columns=labels）。

levelint 或级别名称，可选

对于多重索引，将要删除标签的级别。

inplacebool，默认为 False

如果为 False，则返回一个副本。否则，就地执行操作并返回 None。

errors，默认为 ‘raise’

如果为‘ignore’，则抑制错误并仅删除现有标签。

DataFrame 或 None

返回删除了指定索引或列标签的 DataFrame，或者如果 inplace=True，则返回 None。

引发：

KeyError

如果在所选轴中找不到任何标签。

另请参见

DataFrame.loc

基于标签的位置索引器，用于按标签进行选择。

DataFrame.dropna

返回省略了给定轴上数据缺失的标签的 DataFrame，其中数据（全部或任意）缺失。

DataFrame.drop_duplicates

返回删除了重复行的 DataFrame，可选择只考虑某些列。

Series.drop

返回已删除指定索引标签的 Series。

示例

>>> df = pd.DataFrame(np.arange(12).reshape(3, 4),
...                   columns=['A', 'B', 'C', 'D'])
>>> df
 A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

删除列

>>> df.drop(['B', 'C'], axis=1)
 A   D
0  0   3
1  4   7
2  8  11

>>> df.drop(columns=['B', 'C'])
 A   D
0  0   3
1  4   7
2  8  11

通过索引删除行

>>> df.drop([0, 1])
 A  B   C   D
2  8  9  10  11

删除多重索引 DataFrame 的列和/或行

>>> midx = pd.MultiIndex(levels=[['llama', 'cow', 'falcon'],
...                              ['speed', 'weight', 'length']],
...                      codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],
...                             [0, 1, 2, 0, 1, 2, 0, 1, 2]])
>>> df = pd.DataFrame(index=midx, columns=['big', 'small'],
...                   data=[[45, 30], [200, 100], [1.5, 1], [30, 20],
...                         [250, 150], [1.5, 0.8], [320, 250],
...                         [1, 0.8], [0.3, 0.2]])
>>> df
 big     small
llama   speed   45.0    30.0
 weight  200.0   100.0
 length  1.5     1.0
cow     speed   30.0    20.0
 weight  250.0   150.0
 length  1.5     0.8
falcon  speed   320.0   250.0
 weight  1.0     0.8
 length  0.3     0.2

从多重索引 DataFrame 中删除特定索引组合，即删除组合'falcon'和'weight'，这仅会删除相应的行。

>>> df.drop(index=('falcon', 'weight'))
 big     small
llama   speed   45.0    30.0
 weight  200.0   100.0
 length  1.5     1.0
cow     speed   30.0    20.0
 weight  250.0   150.0
 length  1.5     0.8
falcon  speed   320.0   250.0
 length  0.3     0.2

>>> df.drop(index='cow', columns='small')
 big
llama   speed   45.0
 weight  200.0
 length  1.5
falcon  speed   320.0
 weight  1.0
 length  0.3

>>> df.drop(index='length', level=1)
 big     small
llama   speed   45.0    30.0
 weight  200.0   100.0
cow     speed   30.0    20.0
 weight  250.0   150.0
falcon  speed   320.0   250.0
 weight  1.0     0.8

`pandas.DataFrame.drop_duplicates`

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

DataFrame.drop_duplicates(subset=None, *, keep='first', inplace=False, ignore_index=False)

返回删除重复行后的 DataFrame。

考虑某些列是可选的。索引，包括时间索引，都会被忽略。

参数：

subset：列标签或标签序列，可选。

仅考虑用于标识重复项的某些列，默认情况下使用所有列。

keep：{‘first’, ‘last’, False}，默认为 ‘first’。

确定要保留哪些重复项（如果有）。

‘first’：保留首次出现的重复项。
‘last’：保留最后一次出现的重复项。
False：删除所有重复项。

inplace：布尔值，默认为 False。

是否修改 DataFrame 而不是创建新的 DataFrame。

ignore_index：布尔值，默认为 False。

如果为 True，则生成的轴将被标记为 0、1、…、n - 1。

返回值：

DataFrame 或 None

去重后的 DataFrame，如果 inplace=True 则为 None。

另请参阅

DataFrame.value_counts

计算列的唯一组合。

示例

考虑包含拉面评分的数据集。

>>> df = pd.DataFrame({
...     'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'],
...     'style': ['cup', 'cup', 'cup', 'pack', 'pack'],
...     'rating': [4, 4, 3.5, 15, 5]
... })
>>> df
 brand style  rating
0  Yum Yum   cup     4.0
1  Yum Yum   cup     4.0
2  Indomie   cup     3.5
3  Indomie  pack    15.0
4  Indomie  pack     5.0

默认情况下，基于所有列删除重复行。

>>> df.drop_duplicates()
 brand style  rating
0  Yum Yum   cup     4.0
2  Indomie   cup     3.5
3  Indomie  pack    15.0
4  Indomie  pack     5.0

若要删除特定列上的重复项，请使用 subset。

>>> df.drop_duplicates(subset=['brand'])
 brand style  rating
0  Yum Yum   cup     4.0
2  Indomie   cup     3.5

若要删除重复项并保留最后出现的重复项，请使用 keep。

>>> df.drop_duplicates(subset=['brand', 'style'], keep='last')
 brand style  rating
1  Yum Yum   cup     4.0
2  Indomie   cup     3.5
4  Indomie  pack     5.0

`pandas.DataFrame.duplicated`

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

DataFrame.duplicated(subset=None, keep='first')

返回布尔 Series 表示重复行。

考虑某些列是可选的。

参数：

subset列标签或标签序列，可选

仅考虑特定列以识别重复值，默认情况下使用所有列。

keep，默认为‘first’

确定要标记哪些重复值（如果有）。

first：除第一次出现外，将重复值标记为True。
last：除最后一次出现外，将重复值标记为True。
False：将所有重复值标记为True。

Series

每个重复行的布尔系列。

参见

Index.duplicated

索引上的等效方法。

Series.duplicated

Series 上的等效方法。

Series.drop_duplicates

从 Series 中删除重复值。

DataFrame.drop_duplicates

从 DataFrame 中删除重复值。

示例

考虑包含拉面评分的数据集。

>>> df = pd.DataFrame({
...     'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'],
...     'style': ['cup', 'cup', 'cup', 'pack', 'pack'],
...     'rating': [4, 4, 3.5, 15, 5]
... })
>>> df
 brand style  rating
0  Yum Yum   cup     4.0
1  Yum Yum   cup     4.0
2  Indomie   cup     3.5
3  Indomie  pack    15.0
4  Indomie  pack     5.0

默认情况下，对于每组重复值，第一次出现设置为 False，其他所有出现设置为 True。

>>> df.duplicated()
0    False
1     True
2    False
3    False
4    False
dtype: bool

通过使用‘last’，每组重复值的最后一次出现设置为 False，其他所有出现设置为 True。

>>> df.duplicated(keep='last')
0     True
1    False
2    False
3    False
4    False
dtype: bool

通过将keep设置为 False，所有重复值都为 True。

>>> df.duplicated(keep=False)
0     True
1     True
2    False
3    False
4    False
dtype: bool

要查找特定列上的重复值，请使用subset。

>>> df.duplicated(subset=['brand'])
0    False
1     True
2    False
3     True
4     True
dtype: bool

`pandas.DataFrame.equals`

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

DataFrame.equals(other)

测试两个对象是否包含相同的元素。

此函数允许比较两个 Series 或 DataFrames 是否具有相同的形状和元素。相同位置的 NaN 被视为相等。

行/列索引不需要具有相同类型，只要值被视为相等即可。相应的列和索引必须具有相同的 dtype。

参数：

otherSeries 或 DataFrame

与第一个要比较的其他 Series 或 DataFrame。

布尔值

如果两个对象中的所有元素都相同，则返回 True，否则返回 False。

另请参阅

Series.eq

比较两个长度相同的 Series 对象，并返回一个 Series，其中每个元素如果在每个 Series 中的元素相等则为 True，否则为 False。

DataFrame.eq

比较两个形状相同的 DataFrame 对象，并返回一个 DataFrame，其中每个元素如果在每个 DataFrame 中的相应元素相等则为 True，否则为 False。

testing.assert_series_equal

如果左侧和右侧不相等，则引发 AssertionError。提供了一个简单的接口来忽略 dtype、索引和精度等方面的不同。

testing.assert_frame_equal

类似于 assert_series_equal，但针对 DataFrames。

numpy.array_equal

如果两个数组具有相同的形状和元素，则返回 True，否则返回 False。

示例

>>> df = pd.DataFrame({1: [10], 2: [20]})
>>> df
 1   2
0  10  20

DataFrames df 和 exactly_equal 具有相同类型和元素以及列标签，将返回 True。

>>> exactly_equal = pd.DataFrame({1: [10], 2: [20]})
>>> exactly_equal
 1   2
0  10  20
>>> df.equals(exactly_equal)
True

DataFrames df 和 different_column_type 具有相同的元素类型和值，但列标签的类型不同，仍将返回 True。

>>> different_column_type = pd.DataFrame({1.0: [10], 2.0: [20]})
>>> different_column_type
 1.0  2.0
0   10   20
>>> df.equals(different_column_type)
True

DataFrames df 和 different_data_type 具有相同值的不同类型的元素，即使它们的列标签是相同的值和类型，也将返回 False。

>>> different_data_type = pd.DataFrame({1: [10.0], 2: [20.0]})
>>> different_data_type
 1     2
0  10.0  20.0
>>> df.equals(different_data_type)
False

`pandas.DataFrame.filter`

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

DataFrame.filter(items=None, like=None, regex=None, axis=None)

根据指定的索引标签对数据框行或列进行子集过滤。

请注意，此例程不会根据数据框的内容进行过滤。过滤器应用于索引的标签。

参数：

items类似列表

保留 items 中存在的轴标签。

like字符串

保留“标签中的 like == True”的轴标签。

regex字符串（正则表达式）

保留“re.search(regex，label) == True”的轴标签。

axis，默认为 None

要过滤的轴，表示为索引（int）或轴名称（str）。默认情况下，这是信息轴，对于 DataFrame 是‘columns’。对于 Series，此参数未使用并默认为 None。

与输入对象相同类型

另请参见

DataFrame.loc

通过标签或布尔数组访问一组行和列。

注意

items，like和regex参数被强制互斥。

axis默认为使用[]进行索引时使用的信息轴。

示例

>>> df = pd.DataFrame(np.array(([1, 2, 3], [4, 5, 6])),
...                   index=['mouse', 'rabbit'],
...                   columns=['one', 'two', 'three'])
>>> df
 one  two  three
mouse     1    2      3
rabbit    4    5      6

>>> # select columns by name
>>> df.filter(items=['one', 'three'])
 one  three
mouse     1      3
rabbit    4      6

>>> # select columns by regular expression
>>> df.filter(regex='e$', axis=1)
 one  three
mouse     1      3
rabbit    4      6

>>> # select rows containing 'bbi'
>>> df.filter(like='bbi', axis=0)
 one  two  three
rabbit    4    5      6

`pandas.DataFrame.first`

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

DataFrame.first(offset)

根据日期偏移选择时间序列数据的初始时间段。

自 2.1 版以来已弃用：first() 已弃用，并将在以后的版本中删除。请使用 .loc 创建掩码并进行过滤。

对于具有排序的 DatetimeIndex 的 DataFrame，此函数可以根据日期偏移选择前几行。

参数：

offsetstr，DateOffset 或 dateutil.relativedelta

将要选择的数据的偏移长度。例如，‘1ME’将显示所有索引在第一个月内的行。

Series 或 DataFrame

调用者的子集。

抛出：

TypeError

如果索引不是 DatetimeIndex

另请参见

last

根据日期偏移选择时间序列的最后一段时间。

at_time

选择特定时间的值。

between_time

选择特定时间段之间的值。

示例

>>> i = pd.date_range('2018-04-09', periods=4, freq='2D')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
 A
2018-04-09  1
2018-04-11  2
2018-04-13  3
2018-04-15  4

获取前 3 天的行：

>>> ts.first('3D')
 A
2018-04-09  1
2018-04-11  2

注意，返回了前 3 天的日历天的数据，而不是数据集中观察到的前 3 天的数据，因此未返回 2018-04-13 的数据。

`pandas.DataFrame.head`

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

DataFrame.head(n=5)

返回前 n 行。

此函数根据位置返回对象的前 n 行。它对于快速测试对象是否具有正确类型的数据非常有用。

对于 n 的负值，此函数返回除最后|n|行之外的所有行，相当于df[:n]。

如果 n 大于行数，则此函数返回所有行。

参数：

nint，默认为 5

要选择的行数。

与调用者相同的类型

调用对象的前 n 行。

另请参见

DataFrame.tail

返回最后 n 行。

示例

>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
 animal
0  alligator
1        bee
2     falcon
3       lion
4     monkey
5     parrot
6      shark
7      whale
8      zebra

查看前 5 行

>>> df.head()
 animal
0  alligator
1        bee
2     falcon
3       lion
4     monkey

查看前 n 行（在这种情况下为三行）

>>> df.head(3)
 animal
0  alligator
1        bee
2     falcon

对于 n 的负值

>>> df.head(-3)
 animal
0  alligator
1        bee
2     falcon
3       lion
4     monkey
5     parrot

`pandas.DataFrame.idxmax`

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

DataFrame.idxmax(axis=0, skipna=True, numeric_only=False)

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

排除 NA/null 值。

参数：

axis，默认为 0

要使用的轴。0 或'index'表示按行，1 或'columns'表示按列。

skipna布尔值，默认为 True

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

numeric_only布尔值，默认为 False

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

版本 1.5.0 中的新功能。

系列

沿指定轴的最大值的索引。

引发：

值错误

如果行/列为空

参见

Series.idxmax

返回最大元素的索引。

注意

这个方法是ndarray.argmax的 DataFrame 版本。

示例

考虑一个包含阿根廷食品消费的数据集。

>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
...                     'co2_emissions': [37.2, 19.66, 1712]},
...                   index=['Pork', 'Wheat Products', 'Beef'])

>>> df
 consumption  co2_emissions
Pork                  10.51         37.20
Wheat Products       103.11         19.66
Beef                  55.48       1712.00

默认情况下，返回每列中最大值的索引。

>>> df.idxmax()
consumption     Wheat Products
co2_emissions             Beef
dtype: object

要返回每行中最大值的索引，请使用axis="columns"。

>>> df.idxmax(axis="columns")
Pork              co2_emissions
Wheat Products     consumption
Beef              co2_emissions
dtype: object

`pandas.DataFrame.idxmin`

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

DataFrame.idxmin(axis=0, skipna=True, numeric_only=False)

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

排除 NA/空值。

参数：

axis，默认为 0

要使用的轴。0 或'index'表示按行，1 或'columns'表示按列。

skipna布尔值，默认为 True

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

numeric_only布尔值，默认为 False

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

新版本 1.5.0 中新增。

Series

沿指定轴的最小值的索引。

引发：

值错误

如果行/列为空

另请参见

Series.idxmin

返回最小元素的索引。

注意

此方法是ndarray.argmin的 DataFrame 版本。

示例

考虑一个包含阿根廷食品消费的数据集。

>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48],
...                     'co2_emissions': [37.2, 19.66, 1712]},
...                   index=['Pork', 'Wheat Products', 'Beef'])

>>> df
 consumption  co2_emissions
Pork                  10.51         37.20
Wheat Products       103.11         19.66
Beef                  55.48       1712.00

默认情况下，它返回每列中最小值的索引。

>>> df.idxmin()
consumption                Pork
co2_emissions    Wheat Products
dtype: object

要返回每行中最小值的索引，请使用axis="columns"。

>>> df.idxmin(axis="columns")
Pork                consumption
Wheat Products    co2_emissions
Beef                consumption
dtype: object

`pandas.DataFrame.last`

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

DataFrame.last(offset)

根据日期偏移选择时间序列数据的最终时期。

自版本 2.1 起弃用：last()已弃用，并将在将来的版本中删除。请创建一个掩码并使用.loc 进行过滤。

对于具有排序的 DatetimeIndex 的 DataFrame，此函数根据日期偏移选择最后几行。

参数：

offsetstr, DateOffset, dateutil.relativedelta

将要选择的数据的偏移长度。例如，‘3D’将显示所有索引在最近 3 天内的行。

Series 或 DataFrame

调用者的子集。

引发：

类型错误

如果索引不是DatetimeIndex

另请参阅

first

根据日期偏移选择时间序列的初始时期。

at_time

选择一天中特定时间的值。

between_time

选择一天中特定时间之间的值。

注意事项

自版本 2.1.0 起弃用：请创建一个掩码并使用.loc 进行过滤

示例

>>> i = pd.date_range('2018-04-09', periods=4, freq='2D')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
 A
2018-04-09  1
2018-04-11  2
2018-04-13  3
2018-04-15  4

获取最近 3 天的行：

>>> ts.last('3D')  
 A
2018-04-13  3
2018-04-15  4

注意返回了过去 3 个日历日的数据，而不是数据集中观察到的最后 3 天的数据，因此没有返回 2018-04-11 的数据。

`pandas.DataFrame.reindex`

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

DataFrame.reindex(labels=None, *, index=None, columns=None, axis=None, method=None, copy=None, level=None, fill_value=nan, limit=None, tolerance=None)

将 DataFrame 符合到新索引的逻辑中可选的填充。

将 NA/NaN 放在没有值的先前索引位置。除非新索引等效于当前索引且 copy=False，否则将生成新对象。

参数：

标签数组样式，可选

用于符合由‘axis’指定的轴的新标签/索引。

索引数组样式，可选

索引的新标签。最好是一个 Index 对象，以避免重复数据。

列数组样式，可选

列的新标签。最好是一个 Index 对象，以避免重复数据。

轴整数或字符串，可选

要定位的轴。可以是轴名称（‘index’、‘columns’）或编号（0、1）。

方法

用于填充重新索引的 DataFrame 中的空洞的方法。请注意：这仅适用于具有单调递增/递减索引的 DataFrame/Series。

None（默认）：不填充间隙
pad / ffill：向前传播上一个有效观测值以填充到下一个有效观测值。
backfill / bfill：使用下一个有效观测值填充间隙。
nearest：使用最近的有效观测值填充间隙。

copy布尔值，默认为 True

返回一个新对象，即使传递的索引与当前索引相同。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有具有 copy 关键字的方法都将使用惰性复制机制来推迟复制并忽略 copy 关键字。将来版本的 pandas 将删除 copy 关键字。

通过启用写时复制 pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

级别整数或名称

在级别上广播，匹配传递的 MultiIndex 级别上的 Index 值。

fill_value标量，默认为 np.nan

用于缺失值的值。默认为 NaN，但可以是任何“兼容”的值。

限制整数，默认为 None

最大连续元素数，用于前向或后向填充。

容差可选

用于不精确匹配的原始标签和新标签之间的最大距离。在匹配位置上索引的值最满足方程 abs(index[indexer] - target) <= tolerance。

容差可以是标量值，它将相同的容差应用于所有值，也可以是类似列表的，它将每个元素的可变容差应用于元素。类似列表包括列表、元组、数组、Series，必须与索引的大小完全匹配，并且其 dtype 必须完全匹配索引的类型。

具有更改索引的 DataFrame。

另请参阅

DataFrame.set_index

设置行标签。

DataFrame.reset_index

删除行标签或将它们移动到新列。

DataFrame.reindex_like

更改为与其他数据框相同的索引。

示例

DataFrame.reindex支持两种调用约定

(index=index_labels, columns=column_labels, ...)
(labels, axis={'index', 'columns'}, ...)

我们强烈建议使用关键字参数来明确您的意图。

创建一个带有一些虚构数据的数据框。

>>> index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']
>>> df = pd.DataFrame({'http_status': [200, 200, 404, 404, 301],
...                   'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},
...                   index=index)
>>> df
 http_status  response_time
Firefox            200           0.04
Chrome             200           0.02
Safari             404           0.07
IE10               404           0.08
Konqueror          301           1.00

创建一个新索引并重新索引数据框。默认情况下，新索引中没有对应记录的值将被分配为NaN。

>>> new_index = ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',
...              'Chrome']
>>> df.reindex(new_index)
 http_status  response_time
Safari               404.0           0.07
Iceweasel              NaN            NaN
Comodo Dragon          NaN            NaN
IE10                 404.0           0.08
Chrome               200.0           0.02

通过向关键字fill_value传递一个值，我们可以填补缺失的数值。因为索引不是单调递增或递减的，所以我们不能使用关键字method的参数来填充NaN值。

>>> df.reindex(new_index, fill_value=0)
 http_status  response_time
Safari                 404           0.07
Iceweasel                0           0.00
Comodo Dragon            0           0.00
IE10                   404           0.08
Chrome                 200           0.02

>>> df.reindex(new_index, fill_value='missing')
 http_status response_time
Safari                404          0.07
Iceweasel         missing       missing
Comodo Dragon     missing       missing
IE10                  404          0.08
Chrome                200          0.02

我们还可以重新索引列。

>>> df.reindex(columns=['http_status', 'user_agent'])
 http_status  user_agent
Firefox            200         NaN
Chrome             200         NaN
Safari             404         NaN
IE10               404         NaN
Konqueror          301         NaN

或者我们可以使用“轴样式”关键字参数

>>> df.reindex(['http_status', 'user_agent'], axis="columns")
 http_status  user_agent
Firefox            200         NaN
Chrome             200         NaN
Safari             404         NaN
IE10               404         NaN
Konqueror          301         NaN

为了进一步说明reindex中的填充功能，我们将创建一个具有单调递增索引的数据框（例如，日期序列）。

>>> date_index = pd.date_range('1/1/2010', periods=6, freq='D')
>>> df2 = pd.DataFrame({"prices": [100, 101, np.nan, 100, 89, 88]},
...                    index=date_index)
>>> df2
 prices
2010-01-01   100.0
2010-01-02   101.0
2010-01-03     NaN
2010-01-04   100.0
2010-01-05    89.0
2010-01-06    88.0

假设我们决定扩展数据框以涵盖更广泛的日期范围。

>>> date_index2 = pd.date_range('12/29/2009', periods=10, freq='D')
>>> df2.reindex(date_index2)
 prices
2009-12-29     NaN
2009-12-30     NaN
2009-12-31     NaN
2010-01-01   100.0
2010-01-02   101.0
2010-01-03     NaN
2010-01-04   100.0
2010-01-05    89.0
2010-01-06    88.0
2010-01-07     NaN

在原始数据框中没有值的索引条目（例如，'2009-12-29'）默认填充为NaN。如果需要，我们可以使用几种选项填补缺失值。

例如，要通过将bfill作为method关键字的参数来反向传播最后一个有效值以填充NaN值。

>>> df2.reindex(date_index2, method='bfill')
 prices
2009-12-29   100.0
2009-12-30   100.0
2009-12-31   100.0
2010-01-01   100.0
2010-01-02   101.0
2010-01-03     NaN
2010-01-04   100.0
2010-01-05    89.0
2010-01-06    88.0
2010-01-07     NaN

请注意，在原始数据框中存在的NaN值（在索引值为 2010-01-03 时）不会被任何值传播方案填充。这是因为在重新索引时填充不会查看数据框的值，而是仅比较原始和所需的索引。如果确实希望填充原始数据框中存在的NaN值，请使用fillna()方法。

请参阅用户指南以获取更多信息。

`pandas.DataFrame.reindex_like`

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

DataFrame.reindex_like(other, method=None, copy=None, limit=None, tolerance=None)

返回一个具有与其他对象匹配索引的对象。

使对象在所有轴上与相同索引对齐。可选的填充逻辑，在前一个索引中没有值的位置放置 NaN。除非新索引等同于当前索引且 copy=False，否则会生成一个新对象。

参数:

other相同数据类型的对象

其行和列索引用于定义此对象的新索引。

method

用于填补重新索引的 DataFrame 中的空洞的方法。请注意：这仅适用于具有单调递增/递减索引的 DataFrame/Series。

None（默认）：不填充间隙
pad / ffill: 将最后一个有效观察结果向前传播到下一个有效结果
backfill / bfill: 使用下一个有效观察结果填充间隙
nearest: 使用最近的有效观察结果填充间隙。

copy布尔值，默认为 True

返回一个新对象，即使传递的索引相同。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。在未来的 pandas 版本中，将删除 copy 关键字。

通过启用写时复制pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

limit整数，默认为 None

用于填充不精确匹配的最大连续标签数。

tolerance可选

不精确匹配的原始标签和新标签之间的最大距离。匹配位置的索引值必须满足方程abs(index[indexer] - target) <= tolerance。

容差可以是标量值，它将对所有值应用相同的容差，或者类似列表，它将对每个元素应用可变容差。类似列表包括列表、元组、数组、Series，必须与索引的大小完全匹配且其 dtype 必须与索引的类型完全匹配。

Series 或 DataFrame

与调用者相同类型，但在每个轴上具有更改的索引。

另请参见

DataFrame.set_index

设置行标签。

DataFrame.reset_index

删除行标签或将它们移动到新列中。

DataFrame.reindex

更改为新索引或扩展索引。

注意

等同于调用.reindex(index=other.index, columns=other.columns,...)。

示例

>>> df1 = pd.DataFrame([[24.3, 75.7, 'high'],
...                     [31, 87.8, 'high'],
...                     [22, 71.6, 'medium'],
...                     [35, 95, 'medium']],
...                    columns=['temp_celsius', 'temp_fahrenheit',
...                             'windspeed'],
...                    index=pd.date_range(start='2014-02-12',
...                                        end='2014-02-15', freq='D'))

>>> df1
 temp_celsius  temp_fahrenheit windspeed
2014-02-12          24.3             75.7      high
2014-02-13          31.0             87.8      high
2014-02-14          22.0             71.6    medium
2014-02-15          35.0             95.0    medium

>>> df2 = pd.DataFrame([[28, 'low'],
...                     [30, 'low'],
...                     [35.1, 'medium']],
...                    columns=['temp_celsius', 'windspeed'],
...                    index=pd.DatetimeIndex(['2014-02-12', '2014-02-13',
...                                            '2014-02-15']))

>>> df2
 temp_celsius windspeed
2014-02-12          28.0       low
2014-02-13          30.0       low
2014-02-15          35.1    medium

>>> df2.reindex_like(df1)
 temp_celsius  temp_fahrenheit windspeed
2014-02-12          28.0              NaN       low
2014-02-13          30.0              NaN       low
2014-02-14           NaN              NaN       NaN
2014-02-15          35.1              NaN    medium

`pandas.DataFrame.rename`

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

DataFrame.rename(mapper=None, *, index=None, columns=None, axis=None, copy=None, inplace=False, level=None, errors='ignore')

重命名列或索引标签。

函数/字典值必须是唯一的（1 对 1）。不包含在字典/Series 中的标签将保持不变。列出的额外标签不会引发错误。

有关更多信息，请参阅用户指南。

参数：

mapper类似字典或函数

类似字典或函数转换以应用于该轴的值。使用 mapper 和 axis 来指定要用 mapper 目标的轴，或者使用 index 和 columns。

index类似字典或函数

指定轴的替代方法（mapper，axis=0 等同于 index=mapper）。

columns类似字典或函数

指定轴的替代方法（mapper，axis=1 等同于 columns=mapper）。

axis，默认为 0

用 mapper 目标轴。可以是轴名称（'index'，'columns'）或数字（0，1）。默认为 'index'。

copy布尔值，默认为 True

也复制底层数据。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启��，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。将来的 pandas 版本中将删除 copy 关键字。

您可以通过启用写时复制 pd.options.mode.copy_on_write = True 来获得未来的行为和改进。

inplace布尔值，默认为 False

是否修改 DataFrame 而不是创建新的。如果为 True，则忽略 copy 的值。

levelint 或级别名称，默认为 None

对于 MultiIndex，仅重命名指定级别中的标签。

errors，默认为 'ignore'

如果为 'raise'，则在 dict-like mapper、index 或 columns 包含不在正在转换的索引中的标签时引发 KeyError。如果为 'ignore'，现有键将被重命名，额外键将被忽略。

DataFrame 或 None

具有重命名轴标签的 DataFrame 或如果 inplace=True 则为 None。

引发：

KeyError

如果在选择的轴中找不到任何标签，并且“errors='raise'”。

另请参见

DataFrame.rename_axis

设置轴的名称。

示例

DataFrame.rename 支持两种调用约定

(index=index_mapper，columns=columns_mapper，...)
(mapper，axis={'index'，'columns'}，...)

我们强烈建议使用关键字参数来澄清您的意图。

使用映射重命名列：

>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
>>> df.rename(columns={"A": "a", "B": "c"})
 a  c
0  1  4
1  2  5
2  3  6

使用映射重命名索引：

>>> df.rename(index={0: "x", 1: "y", 2: "z"})
 A  B
x  1  4
y  2  5
z  3  6

将索引标签转换为不同类型：

>>> df.index
RangeIndex(start=0, stop=3, step=1)
>>> df.rename(index=str).index
Index(['0', '1', '2'], dtype='object')

>>> df.rename(columns={"A": "a", "B": "b", "C": "c"}, errors="raise")
Traceback (most recent call last):
KeyError: ['C'] not found in axis

使用轴样式参数：

>>> df.rename(str.lower, axis='columns')
 a  b
0  1  4
1  2  5
2  3  6

>>> df.rename({1: 2, 2: 4}, axis='index')
 A  B
0  1  4
2  2  5
4  3  6

`pandas.DataFrame.rename_axis`

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

DataFrame.rename_axis(mapper=_NoDefault.no_default, *, index=_NoDefault.no_default, columns=_NoDefault.no_default, axis=0, copy=None, inplace=False)

设置索引或列的轴名称。

参数：

mapper标量，类似列表，可选

要设置轴名称属性的值。

index, columns标量，类似列表，类似字典或函数，可选

一个标量，类似列表，类似字典或函数的转换，应用于该轴的值。请注意，如果对象是 Series，则不允许使用columns参数。此参数仅适用于 DataFrame 类型对象。

使用mapper和axis来指定要使用mapper目标的轴，或者使用index和/或columns。

axis，默认为 0

要重命名的轴。对于 Series，此参数未使用，默认为 0。

copy布尔值，默认为 None

也复制底层数据。

注意

在 pandas 3.0 中，copy 关键字将更改行为。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在未来的 pandas 版本中被移除。

您可以通过启用写时复制pd.options.mode.copy_on_write = True来获得未来的行为和改进。

inplace布尔值，默认为 False

直接修改对象，而不是创建新的 Series 或 DataFrame。

Series，DataFrame 或 None

与调用者相同类型，如果inplace=True则为 None。

参见

Series.rename

更改 Series 索引标签或名称。

DataFrame.rename

更改 DataFrame 索引标签或名称。

Index.rename

设置索引的新名称。

注意

DataFrame.rename_axis支持两种调用约定

(index=index_mapper，columns=columns_mapper，...)
(mapper，axis={'index'，'columns'}，...)

第一种调用约定仅修改索引的名称和/或作为列的 Index 对象的名称。在这种情况下，参数copy将被忽略。

第二种调用约定将修改相应索引的名称，如果 mapper 是列表或标量。但是，如果 mapper 类似于字典或函数，则将使用已弃用的行为来修改轴标签。

我们强烈建议使用关键字参数来澄清您的意图。

示例

Series

>>> s = pd.Series(["dog", "cat", "monkey"])
>>> s
0       dog
1       cat
2    monkey
dtype: object
>>> s.rename_axis("animal")
animal
0    dog
1    cat
2    monkey
dtype: object

DataFrame

>>> df = pd.DataFrame({"num_legs": [4, 4, 2],
...                    "num_arms": [0, 0, 2]},
...                   ["dog", "cat", "monkey"])
>>> df
 num_legs  num_arms
dog            4         0
cat            4         0
monkey         2         2
>>> df = df.rename_axis("animal")
>>> df
 num_legs  num_arms
animal
dog            4         0
cat            4         0
monkey         2         2
>>> df = df.rename_axis("limbs", axis="columns")
>>> df
limbs   num_legs  num_arms
animal
dog            4         0
cat            4         0
monkey         2         2

MultiIndex

>>> df.index = pd.MultiIndex.from_product([['mammal'],
...                                        ['dog', 'cat', 'monkey']],
...                                       names=['type', 'name'])
>>> df
limbs          num_legs  num_arms
type   name
mammal dog            4         0
 cat            4         0
 monkey         2         2

>>> df.rename_axis(index={'type': 'class'})
limbs          num_legs  num_arms
class  name
mammal dog            4         0
 cat            4         0
 monkey         2         2

>>> df.rename_axis(columns=str.upper)
LIMBS          num_legs  num_arms
type   name
mammal dog            4         0
 cat            4         0
 monkey         2         2

`pandas.DataFrame.reset_index`

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

DataFrame.reset_index(level=None, *, drop=False, inplace=False, col_level=0, col_fill='', allow_duplicates=_NoDefault.no_default, names=None)

重置索引或其级别。

重置 DataFrame 的索引，并使用默认索引。如果 DataFrame 具有 MultiIndex，则此方法可以移除一个或多个级别。

参数：

levelint、str、元组或列表，默认为 None

仅从索引中移除给定级别。默认情况下移除所有级别。

dropbool，默认为 False

不要尝试将索引插入到 DataFrame 列中。这将重置索引为默认整数索引。

inplacebool，默认为 False

是否修改 DataFrame 而不是创建一个新的。

col_levelint 或 str，默认为 0

如果列具有多个级别，则确定标签插入到哪个级别。默认情况下插入到第一个级别。

col_fill对象，默认为‘’

如果列具有多个级别，则确定如何命名其他级别。如果为 None，则重复索引名称。

allow_duplicatesbool，可选，默认为 lib.no_default

允许创建重复的列标签。

新版本 1.5.0 中新增。

namesint、str 或一维列表，默认为 None

使用给定的字符串，重命名包含索引数据的 DataFrame 列。如果 DataFrame 具有 MultiIndex，则必须是长度等于级别数的列表或元组。

新版本 1.5.0 中新增。

DataFrame 或 None

具有新索引的 DataFrame 或如果inplace=True则为 None。

另请参阅

DataFrame.set_index

reset_index 的相反操作。

DataFrame.reindex

更改为新索引或扩展索引。

DataFrame.reindex_like

更改为与其他 DataFrame 相同的索引。

示例

>>> df = pd.DataFrame([('bird', 389.0),
...                    ('bird', 24.0),
...                    ('mammal', 80.5),
...                    ('mammal', np.nan)],
...                   index=['falcon', 'parrot', 'lion', 'monkey'],
...                   columns=('class', 'max_speed'))
>>> df
 class  max_speed
falcon    bird      389.0
parrot    bird       24.0
lion    mammal       80.5
monkey  mammal        NaN

当我们重置索引时，旧索引会被添加为一列，并使用新的顺序索引：

>>> df.reset_index()
 index   class  max_speed
0  falcon    bird      389.0
1  parrot    bird       24.0
2    lion  mammal       80.5
3  monkey  mammal        NaN

我们可以使用 drop 参数来避免将旧索引添加为列：

>>> df.reset_index(drop=True)
 class  max_speed
0    bird      389.0
1    bird       24.0
2  mammal       80.5
3  mammal        NaN

您还可以使用 MultiIndex 重置索引。

>>> index = pd.MultiIndex.from_tuples([('bird', 'falcon'),
...                                    ('bird', 'parrot'),
...                                    ('mammal', 'lion'),
...                                    ('mammal', 'monkey')],
...                                   names=['class', 'name'])
>>> columns = pd.MultiIndex.from_tuples([('speed', 'max'),
...                                      ('species', 'type')])
>>> df = pd.DataFrame([(389.0, 'fly'),
...                    (24.0, 'fly'),
...                    (80.5, 'run'),
...                    (np.nan, 'jump')],
...                   index=index,
...                   columns=columns)
>>> df
 speed species
 max    type
class  name
bird   falcon  389.0     fly
 parrot   24.0     fly
mammal lion     80.5     run
 monkey    NaN    jump

使用 names 参数，为索引列选择一个名称：

>>> df.reset_index(names=['classes', 'names'])
 classes   names  speed species
 max    type
0    bird  falcon  389.0     fly
1    bird  parrot   24.0     fly
2  mammal    lion   80.5     run
3  mammal  monkey    NaN    jump

如果索引具有多个级别，我们可以重置其中的一个子集：

>>> df.reset_index(level='class')
 class  speed species
 max    type
name
falcon    bird  389.0     fly
parrot    bird   24.0     fly
lion    mammal   80.5     run
monkey  mammal    NaN    jump

如果我们不删除索引，默认情况下会将其放在顶级。我们可以将其放在另一个级别：

>>> df.reset_index(level='class', col_level=1)
 speed species
 class    max    type
name
falcon    bird  389.0     fly
parrot    bird   24.0     fly
lion    mammal   80.5     run
monkey  mammal    NaN    jump

当索引插入到另一个级别下时，我们可以使用参数 col_fill 指定插入到哪个级别下：

>>> df.reset_index(level='class', col_level=1, col_fill='species')
 species  speed species
 class    max    type
name
falcon           bird  389.0     fly
parrot           bird   24.0     fly
lion           mammal   80.5     run
monkey         mammal    NaN    jump

如果我们为 col_fill 指定一个不存在的级别，它将被创建：

>>> df.reset_index(level='class', col_level=1, col_fill='genus')
 genus  speed species
 class    max    type
name
falcon           bird  389.0     fly
parrot           bird   24.0     fly
lion           mammal   80.5     run
monkey         mammal    NaN    jump

`pandas.DataFrame.sample`

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

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None, ignore_index=False)

从对象的轴中返回项目的随机样本。

您可以使用 random_state 来实现可重现性。

参数：

n整数，可选

要返回的轴项目数。如果 frac = None，则默认为 1。

frac浮点数，可选

要返回的轴项目的分数。不能与 n 一起使用。

replace布尔值，默认为 False

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

weights字符串或类似 ndarray，可选

默认值为“None”，导致等概率加权。如果传递了一个 Series，将在索引上与目标对象对齐。在样本对象中找不到的索引值将被忽略，而在权重中找不到的样本对象中的索引值将被分配为零权重。如果在 DataFrame 上调用，当 axis = 0 时将接受列的名称。除非权重是 Series，否则权重必须与被采样的轴的长度相同。如果权重不总和为 1，则将对其进行归一化以总和为 1。权重列中的缺失值将被视为零。不允许无限值。

random_state整数，类似数组，BitGenerator，np.random.RandomState，np.random.Generator，可选

如果是整数，类似数组或 BitGenerator，则为随机数生成器的种子。如果是 np.random.RandomState 或 np.random.Generator，则按给定方式使用。

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

axis，默认为 None

要采样的轴。接受轴编号或名称。对于 Series，此参数未使用并默认为 None。

ignore_index布尔值，默认为 False

如果为 True，则生成的索引将标记为 0, 1, …, n - 1。

版本 1.3.0 中的新功能。

Series 或 DataFrame

与调用者相同类型的新对象，其中包含从调用者对象中随机抽取的 n 个项目。

另请参见

DataFrameGroupBy.sample

从 DataFrame 对象的每个组中生成随机样本。

SeriesGroupBy.sample

从 Series 对象的每个组生成随机样本。

numpy.random.choice

从给定的 1-D numpy 数组中生成随机样本。

注意

如果 frac > 1，则应将 replace 设置为 True。

示例

>>> df = pd.DataFrame({'num_legs': [2, 4, 8, 0],
...                    'num_wings': [2, 0, 0, 0],
...                    'num_specimen_seen': [10, 2, 1, 8]},
...                   index=['falcon', 'dog', 'spider', 'fish'])
>>> df
 num_legs  num_wings  num_specimen_seen
falcon         2          2                 10
dog            4          0                  2
spider         8          0                  1
fish           0          0                  8

从Series df['num_legs']中提取 3 个随机元素：请注意，我们使用 random_state 来确保示例的可重现性。

>>> df['num_legs'].sample(n=3, random_state=1)
fish      0
spider    8
falcon    2
Name: num_legs, dtype: int64

带替换的DataFrame的随机 50%样本：

>>> df.sample(frac=0.5, replace=True, random_state=1)
 num_legs  num_wings  num_specimen_seen
dog          4          0                  2
fish         0          0                  8

带替换的DataFrame的上采样样本：请注意，对于 frac 参数> 1，replace 参数必须为 True。

>>> df.sample(frac=2, replace=True, random_state=1)
 num_legs  num_wings  num_specimen_seen
dog            4          0                  2
fish           0          0                  8
falcon         2          2                 10
falcon         2          2                 10
fish           0          0                  8
dog            4          0                  2
fish           0          0                  8
dog            4          0                  2

使用 DataFrame 列作为权重。在 num_specimen_seen 列中具有较大值的行更有可能被抽样。

>>> df.sample(n=2, weights='num_specimen_seen', random_state=1)
 num_legs  num_wings  num_specimen_seen
falcon         2          2                 10
fish           0          0                  8

`pandas.DataFrame.set_axis`

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

DataFrame.set_axis(labels, *, axis=0, copy=None)

将所需的索引分配给给定的轴。

通过分配类似列表或索引，可以更改列或行标签的索引。

参数：

labels类似列表，索引

新索引的值。

axis，默认为 0

要更新的轴。值 0 表示行。对于 Series，此参数未使用，默认为 0。

copybool，默认为 True

是否复制底层数据。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在未来的 pandas 版本中被移除。

通过启用写时复制 pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

DataFrame

一个 DataFrame 类型的对象。

另请参阅

DataFrame.rename_axis

更改索引或列的名称。

示例

>>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})

更改行标签。

>>> df.set_axis(['a', 'b', 'c'], axis='index')
 A  B
a  1  4
b  2  5
c  3  6

更改列标签。

>>> df.set_axis(['I', 'II'], axis='columns')
 I  II
0  1   4
1  2   5
2  3   6

`pandas.DataFrame.set_index`

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

DataFrame.set_index(keys, *, drop=True, append=False, inplace=False, verify_integrity=False)

使用现有列设置 DataFrame 的索引。

使用一个或多个现有列或数组（长度正确）设置 DataFrame 的索引（行标签）。索引可以替换现有索引或扩展现有索引。

参数：

keys标签或类似数组或标签/数组列表

此参数可以是单个列键，与调用 DataFrame 长度相同的单个数组，或包含任意组合列键和数组的列表。这里，“数组”包括Series、Index、np.ndarray和Iterator.

drop布尔值，默认为 True

删除要用作新索引的列。

append布尔值，默认为 False

是否将列附加到现有索引。

inplace布尔值，默认为 False

是否修改 DataFrame 而不是创建新的 DataFrame。

verify_integrity布尔值，默认为 False

检查新索引是否存在重复。否则，推迟检查直到必要时。将其设置为 False 将提高此方法的性能。

DataFrame 或 None

如果inplace=True，则更改的行标签或 None。

另请参见

DataFrame.reset_index

set_index 的相反操作。

DataFrame.reindex

更改为新的索引或扩展索引。

DataFrame.reindex_like

更改为与其他 DataFrame 相同的索引。

示例

>>> df = pd.DataFrame({'month': [1, 4, 7, 10],
...                    'year': [2012, 2014, 2013, 2014],
...                    'sale': [55, 40, 84, 31]})
>>> df
 month  year  sale
0      1  2012    55
1      4  2014    40
2      7  2013    84
3     10  2014    31

将索引设置为“month”列：

>>> df.set_index('month')
 year  sale
month
1      2012    55
4      2014    40
7      2013    84
10     2014    31

使用“year”和“month”列创建一个 MultiIndex：

>>> df.set_index(['year', 'month'])
 sale
year  month
2012  1     55
2014  4     40
2013  7     84
2014  10    31

使用索引和列创建一个 MultiIndex：

>>> df.set_index([pd.Index([1, 2, 3, 4]), 'year'])
 month  sale
 year
1  2012  1      55
2  2014  4      40
3  2013  7      84
4  2014  10     31

使用两个 Series 创建一个 MultiIndex：

>>> s = pd.Series([1, 2, 3, 4])
>>> df.set_index([s, s**2])
 month  year  sale
1 1       1  2012    55
2 4       4  2014    40
3 9       7  2013    84
4 16     10  2014    31

`pandas.DataFrame.tail`

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

DataFrame.tail(n=5)

返回最后 n 行。

此函数根据位置从对象返回最后 n 行。例如，在排序或追加行后，快速验证数据非常有用。

对于 n 的负值，此函数返回除前|n|行之外的所有行，相当于df[|n|:]。

如果 n 大于行数，则此函数返回所有行。

参数：

nint，默认为 5

要选择的行数。

调用者的类型

调用对象的最后 n 行。

另请参见

DataFrame.head

调用对象的前 n 行。

例子

>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
...                    'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
 animal
0  alligator
1        bee
2     falcon
3       lion
4     monkey
5     parrot
6      shark
7      whale
8      zebra

查看最后 5 行

>>> df.tail()
 animal
4  monkey
5  parrot
6   shark
7   whale
8   zebra

查看最后 n 行（在这种情况下为三行）

>>> df.tail(3)
 animal
6  shark
7  whale
8  zebra

对于 n 的负值

>>> df.tail(-3)
 animal
3    lion
4  monkey
5  parrot
6   shark
7   whale
8   zebra

`pandas.DataFrame.take`

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

DataFrame.take(indices, axis=0, **kwargs)

返回沿轴的给定位置索引的元素。

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

参数：

indices类似数组

一个指示要获取哪些位置的整数数组。

axis，默认为 0

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

**kwargs

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

与调用者相同的类型

包含从对象中获取的元素的类似数组。

另请参阅

DataFrame.loc

通过标签选择 DataFrame 的子集。

DataFrame.iloc

通过位置选择 DataFrame 的子集。

numpy.take

沿轴从数组中获取元素。

示例

>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
...                    ('parrot', 'bird', 24.0),
...                    ('lion', 'mammal', 80.5),
...                    ('monkey', 'mammal', np.nan)],
...                   columns=['name', 'class', 'max_speed'],
...                   index=[0, 2, 3, 1])
>>> df
 name   class  max_speed
0  falcon    bird      389.0
2  parrot    bird       24.0
3    lion  mammal       80.5
1  monkey  mammal        NaN

在轴 0 上获取位置为 0 和 3 的元素（默认）。

注意实际选择的索引（0 和 1）与我们选择的索引 0 和 3 不对应。这是因为我们选择的是第 0 和第 3 行，而不是索引等于 0 和 3 的行。

>>> df.take([0, 3])
 name   class  max_speed
0  falcon    bird      389.0
1  monkey  mammal        NaN

在轴 1 上获取索引为 1 和 2 的元素（列选择）。

>>> df.take([1, 2], axis=1)
 class  max_speed
0    bird      389.0
2    bird       24.0
3  mammal       80.5
1  mammal        NaN

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

>>> df.take([-1, -2])
 name   class  max_speed
1  monkey  mammal        NaN
3    lion  mammal       80.5

`pandas.DataFrame.truncate`

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

DataFrame.truncate(before=None, after=None, axis=None, copy=None)

截断 Series 或 DataFrame 在某个索引值之前和之后。

这是一个基于索引值在某些阈值以上或以下进行布尔索引的有用简写。

参数：

beforedate, str, int

截断此索引值之前的所有行。

afterdate, str, int

截断此索引值之后的所有行。

axis，可选

要截断的轴。默认情况下截断索引（行）。对于 Series，此参数未使用且默认为 0。

copybool，默认为 True，

返回截断部分的副本。

注意

在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在未来的 pandas 版本中被移除。

通过启用写时复制pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。

调用者的类型

截断的 Series 或 DataFrame。

参见

DataFrame.loc

通过标签选择 DataFrame 的子集。

DataFrame.iloc

通过位置选择 DataFrame 的子集。

注意

如果要截断的索引只包含日期时间值，则可以将 before 和 after 指定为字符串，而不是时间戳。

示例

>>> df = pd.DataFrame({'A': ['a', 'b', 'c', 'd', 'e'],
...                    'B': ['f', 'g', 'h', 'i', 'j'],
...                    'C': ['k', 'l', 'm', 'n', 'o']},
...                   index=[1, 2, 3, 4, 5])
>>> df
 A  B  C
1  a  f  k
2  b  g  l
3  c  h  m
4  d  i  n
5  e  j  o

>>> df.truncate(before=2, after=4)
 A  B  C
2  b  g  l
3  c  h  m
4  d  i  n

DataFrame 的列可以被截断。

>>> df.truncate(before="A", after="B", axis="columns")
 A  B
1  a  f
2  b  g
3  c  h
4  d  i
5  e  j

对于 Series，只能截断行。

>>> df['A'].truncate(before=2, after=4)
2    b
3    c
4    d
Name: A, dtype: object

truncate中的索引值可以是日期时间或字符串日期。

>>> dates = pd.date_range('2016-01-01', '2016-02-01', freq='s')
>>> df = pd.DataFrame(index=dates, data={'A': 1})
>>> df.tail()
 A
2016-01-31 23:59:56  1
2016-01-31 23:59:57  1
2016-01-31 23:59:58  1
2016-01-31 23:59:59  1
2016-02-01 00:00:00  1

>>> df.truncate(before=pd.Timestamp('2016-01-05'),
...             after=pd.Timestamp('2016-01-10')).tail()
 A
2016-01-09 23:59:56  1
2016-01-09 23:59:57  1
2016-01-09 23:59:58  1
2016-01-09 23:59:59  1
2016-01-10 00:00:00  1

因为索引是仅包含日期的 DatetimeIndex，所以我们可以将 before 和 after 指定为字符串。它们将在截断之前被强制转换为时间戳。

>>> df.truncate('2016-01-05', '2016-01-10').tail()
 A
2016-01-09 23:59:56  1
2016-01-09 23:59:57  1
2016-01-09 23:59:58  1
2016-01-09 23:59:59  1
2016-01-10 00:00:00  1

请注意，truncate假定任何未指定时间组件（午夜）的值为 0。这与部分字符串切片不同，后者返回任何部分匹配的日期。

>>> df.loc['2016-01-05':'2016-01-10', :].tail()
 A
2016-01-10 23:59:55  1
2016-01-10 23:59:56  1
2016-01-10 23:59:57  1
2016-01-10 23:59:58  1
2016-01-10 23:59:59  1

`pandas.DataFrame.backfill`

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

DataFrame.backfill(*, axis=None, inplace=False, limit=None, downcast=_NoDefault.no_default)

使用下一个有效观察结果填充缺失的 NA/NaN 值。

从版本 2.0 开始弃用：Series/DataFrame.backfill 已弃用。请使用 Series/DataFrame.bfill 代替。

Series/DataFrame 或 None

填充了缺失值的对象，如果inplace=True则为 None。

示例

请参见DataFrame.bfill()或Series.bfill()的示例。

`pandas.DataFrame.bfill`

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

DataFrame.bfill(*, axis=None, inplace=False, limit=None, limit_area=None, downcast=_NoDefault.no_default)

使用下一个有效观察结果填补空缺的 NA/NaN 值。

参数：

axis对于 Series，{0 或‘index’，1 或‘columns’}对于 DataFrame

用于填充缺失值的轴。对于 Series，此参数未使用，默认为 0。

inplacebool，默认为 False

如果为 True，则原地填充。注意：这将修改此对象上的任何其他视图（例如，DataFrame 中列的无副本切片）。

limitint，默认为 None

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

limit_area，默认为 None

如果指定了限制，连续的 NaN 值将受到此限制的填充。

None：无填充限制。
‘inside’：仅填充被有效值包围的 NaN 值（内插）。
‘outside’：仅在有效值之外填充 NaN 值（外推）。

新版本 2.2.0 中新增。

downcastdict，默认为 None

一个项目->dtype 的字典，如果可能的话，用于向下转换，或字符串‘infer’，它将尝试向下转换为适当的相等类型（例如，如果可能的话，从 float64 向下转换为 int64）。

自版本 2.2.0 起弃用。

Series/DataFrame 或 None

填充了缺失值的对象或如果inplace=True则为 None。

示例

对于 Series：

>>> s = pd.Series([1, None, None, 2])
>>> s.bfill()
0    1.0
1    2.0
2    2.0
3    2.0
dtype: float64
>>> s.bfill(limit=1)
0    1.0
1    NaN
2    2.0
3    2.0
dtype: float64

对于 DataFrame：

>>> df = pd.DataFrame({'A': [1, None, None, 4], 'B': [None, 5, None, 7]})
>>> df
 A     B
0   1.0   NaN
1   NaN   5.0
2   NaN   NaN
3   4.0   7.0
>>> df.bfill()
 A     B
0   1.0   5.0
1   4.0   5.0
2   4.0   7.0
3   4.0   7.0
>>> df.bfill(limit=1)
 A     B
0   1.0   5.0
1   NaN   5.0
2   4.0   7.0
3   4.0   7.0

`pandas.DataFrame.dropna`

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

DataFrame.dropna(*, axis=0, how=_NoDefault.no_default, thresh=_NoDefault.no_default, subset=None, inplace=False, ignore_index=False)

删除缺失值。

有关哪些值被视为缺失以及如何处理缺失数据的更多信息，请参阅用户指南。

参数：

axis，默认为 0

确定是否删除包含缺失值的行或列。

0 或‘index’：删除包含缺失值的行。
1 或'columns'：删除包含缺失值的列。

仅允许单个轴。

how，默认为‘any’

在至少有一个 NA 或全部 NA 时，确定是否从 DataFrame 中删除行或列。

‘any’：如果存在任何 NA 值，则删除该行或列。
‘all’：如果所有值都为 NA，则删除该行或列。

threshint，可选

需要多少非 NA 值。不能与 how 结合使用。

subset列标签或标签序列，可选

考虑沿其他轴的标签，例如，如果您正在删除行，则这些标签将是要包括的列的列表。

inplacebool，默认为 False

是否修改 DataFrame 而不是创建新的 DataFrame。

ignore_indexbool，默认为 False

如果为 True，则生成的轴将被标记为 0、1、…、n-1。

版本 2.0.0 中的新功能。

DataFrame 或 None

从中删除了 NA 条目的 DataFrame 或如果 inplace=True 则为 None。

另请参见

指示缺失值。

指示现有（非缺失）值。

替换缺失值。

删除缺失值。

删除缺失索引。

示例

>>> df = pd.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'],
...                    "toy": [np.nan, 'Batmobile', 'Bullwhip'],
...                    "born": [pd.NaT, pd.Timestamp("1940-04-25"),
...                             pd.NaT]})
>>> df
 name        toy       born
0    Alfred        NaN        NaT
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

删除至少一个元素缺失的行。

>>> df.dropna()
 name        toy       born
1  Batman  Batmobile 1940-04-25

删除至少一个元素缺失的列。

>>> df.dropna(axis='columns')
 name
0    Alfred
1    Batman
2  Catwoman

删除所有元素均缺失的行。

>>> df.dropna(how='all')
 name        toy       born
0    Alfred        NaN        NaT
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

仅保留至少有 2 个非 NA 值的行。

>>> df.dropna(thresh=2)
 name        toy       born
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

定义要查找缺失值的列。

>>> df.dropna(subset=['name', 'toy'])
 name        toy       born
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

`pandas.DataFrame.ffill`

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

DataFrame.ffill(*, axis=None, inplace=False, limit=None, limit_area=None, downcast=_NoDefault.no_default)

通过将最后一个有效观察结果传播到下一个有效观察结果来填充 NA/NaN 值。

参数：

axis 适用于 Series，{0 或 ‘index’，1 或 ‘columns’} 适用于 DataFrame

要填充缺失值的轴。对于 Series，此参数未使用并默认为 0。

inplacebool，默认为 False

如果为 True，则原地填充。注意：这将修改此对象上的任何其他视图（例如，DataFrame 中列的无副本切片）。

limitint，默认为 None

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

limit_area，默认为 None

如果指定了 limit，则连续 NaN 将受到此限制的填充。

None：无填充限制。
‘inside’：仅填充被有效值包围的 NaN（插值）。
‘outside’：仅在有效值外部填充 NaN（外推）。

在 2.2.0 版本中新增。

downcastdict，默认为 None

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

从 2.2.0 版本开始已弃用。

Series/DataFrame 或 None

填充了缺失值的对象或如果 inplace=True 则为 None。

示例

>>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],
...                    [3, 4, np.nan, 1],
...                    [np.nan, np.nan, np.nan, np.nan],
...                    [np.nan, 3, np.nan, 4]],
...                   columns=list("ABCD"))
>>> df
 A    B   C    D
0  NaN  2.0 NaN  0.0
1  3.0  4.0 NaN  1.0
2  NaN  NaN NaN  NaN
3  NaN  3.0 NaN  4.0

>>> df.ffill()
 A    B   C    D
0  NaN  2.0 NaN  0.0
1  3.0  4.0 NaN  1.0
2  3.0  4.0 NaN  1.0
3  3.0  3.0 NaN  4.0

>>> ser = pd.Series([1, np.nan, 2, 3])
>>> ser.ffill()
0   1.0
1   1.0
2   2.0
3   3.0
dtype: float64

`pandas.DataFrame.fillna`

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

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

使用指定的方法填充 NA/NaN 值。

参数：

value标量、字典、Series 或 DataFrame

用于填充空洞的值（例如 0），或者是一个指定每个索引（对于 Series）或列（对于 DataFrame）使用哪个值的字典/Series/DataFrame。字典/Series/DataFrame 中不包含的值将不会被填充。此值不能是列表。

method，默认为 None

用于填充重新索引的 Series 中空洞的方法：

ffill：向前传播最后一个有效观测值到下一个有效值。
backfill / bfill：使用下一个有效观测值填充间隙。

自 2.1.0 版本起已废弃：请使用 ffill 或 bfill 代替。

axis（对于 Series），{0 或 ‘index’、1 或 ‘columns’}（对于 DataFrame）

用于填充缺失值的轴。对于 Series，此参数未使用，默认为 0。

inplace布尔值，默认为 False

如果为 True，则就地填充。注意：这将修改对象的任何其他视图（例如，DataFrame 中列的无复制切片）。

limit整数，默认为 None

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

downcast字典，默认为 None

一个项目->dtype 的字典，如果可能的话用于向下转换，或者字符串 ‘infer’，它将尝试向下转换为适当的相等类型（例如 float64 到 int64 如果可能的话）。

自 2.2.0 版本起已废弃。

Series/DataFrame 或 None

填充了缺失值的对象，如果 inplace=True 则为 None。

另请参阅

向前填充

通过将最后一个有效观测值传播到下一个有效值来填充值。

使用下一个有效观测值填充间隙。

使用插值填充 NaN 值。

将对象调整为新的索引。

将时间序列转换为指定的频率。

示例

>>> df = pd.DataFrame([[np.nan, 2, np.nan, 0],
...                    [3, 4, np.nan, 1],
...                    [np.nan, np.nan, np.nan, np.nan],
...                    [np.nan, 3, np.nan, 4]],
...                   columns=list("ABCD"))
>>> df
 A    B   C    D
0  NaN  2.0 NaN  0.0
1  3.0  4.0 NaN  1.0
2  NaN  NaN NaN  NaN
3  NaN  3.0 NaN  4.0

用 0 替换所有 NaN 元素。

>>> df.fillna(0)
 A    B    C    D
0  0.0  2.0  0.0  0.0
1  3.0  4.0  0.0  1.0
2  0.0  0.0  0.0  0.0
3  0.0  3.0  0.0  4.0

用 0、1、2 和 3 替换列 ‘A’、‘B’、‘C’ 和 ‘D’ 中的所有 NaN 元素。

>>> values = {"A": 0, "B": 1, "C": 2, "D": 3}
>>> df.fillna(value=values)
 A    B    C    D
0  0.0  2.0  2.0  0.0
1  3.0  4.0  2.0  1.0
2  0.0  1.0  2.0  3.0
3  0.0  3.0  2.0  4.0

只替换第一个 NaN 元素。

>>> df.fillna(value=values, limit=1)
 A    B    C    D
0  0.0  2.0  2.0  0.0
1  3.0  4.0  NaN  1.0
2  NaN  1.0  NaN  3.0
3  NaN  3.0  NaN  4.0

当使用 DataFrame 进行填充时，替换发生在相同的列名和相同的索引上

>>> df2 = pd.DataFrame(np.zeros((4, 4)), columns=list("ABCE"))
>>> df.fillna(df2)
 A    B    C    D
0  0.0  2.0  0.0  0.0
1  3.0  4.0  0.0  1.0
2  0.0  0.0  0.0  NaN
3  0.0  3.0  0.0  4.0

注意列 D 不受影响，因为它不存在于 df2 中。

`pandas.DataFrame.interpolate`

译文：pandas.pydata.org/docs/reference/api/pandas.DataFrame.interpolate.html

DataFrame.interpolate(method='linear', *, axis=0, limit=None, inplace=False, limit_direction=None, limit_area=None, downcast=_NoDefault.no_default, **kwargs)

使用插值方法填充 NaN 值。

请注意，仅支持 DataFrame/Series 具有 MultiIndex 的method='linear'。

参数：

methodstr，默认为‘linear’

要使用的插值技术。其中之一：

‘linear’：忽略索引并将值视为等间距。这是 MultiIndexes 支持的唯一方法。
‘time’: 用于对每日及更高分辨率数据进行插值，以插值给定长度的间隔。
‘index’，‘values’：使用索引的实际数值。
‘pad’: 使用现有值填充 NaN。
‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘barycentric’, ‘polynomial’: 传递给 scipy.interpolate.interp1d，而‘spline’传递给 scipy.interpolate.UnivariateSpline。这些方法使用索引的数值。‘polynomial’和‘spline’都要求您还指定一个阶数（int），例如df.interpolate(method='polynomial', order=5)。请注意，Pandas 中的 slinear 方法指的是 Scipy 的一阶样条，而不是 Pandas 的一阶样条。
‘krogh’, ‘piecewise_polynomial’, ‘spline’, ‘pchip’, ‘akima’, ‘cubicspline’: SciPy 插值方法的包装器，与类似名称的方法相似。请参阅注释。
‘from_derivatives’：指的是 scipy.interpolate.BPoly.from_derivatives。

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

要进行插值的轴。对于 Series，此参数未使用且默认为 0。

limitint，可选

要填充的最大连续 NaN 数。必须大于 0。

inplacebool，默认为 False

尽可能就地更新数据。

limit_direction{{‘forward’，‘backward’，‘both’}}，可选

连续的 NaN 将以此方向填充。

如果指定了限制：

如果‘method’为‘pad’或‘ffill’，‘limit_direction’必须为‘forward’。
如果‘method’为‘backfill’或‘bfill’，‘limit_direction’必须为‘backwards’。

如果未指定‘limit’：

如果‘method’为‘backfill’或‘bfill’，默认为‘backward’
否则默认为‘forward’

如果 limit_direction 为‘forward’或‘both’且引发 ValueError

如果‘method’为‘backfill’或‘bfill’。

如果 limit_direction 为‘backward’或‘both’且引发 ValueError

如果‘method’为‘pad’或‘ffill’。

limit_area{{None，‘inside’，‘outside’}}，默认为 None

如果指定了限制，连续的 NaN 将受到此限制的填充。

None：无填充限制。
‘inside’：仅填充被有效值包围的 NaN（插值）。
‘outside’：仅填充有效值之外的 NaN（外推）。

downcast可选，‘infer’或 None，默认为 None

尽可能降低数据类型。

自版本 2.1.0 起已弃用。

**kwargs可选

传递给插值函数的关键字参数。

Series 或 DataFrame 或 None

返回与调用者相同的对象类型，在一些或所有NaN值进行插值，如果inplace=True则返回 None。

另请参见

fillna

使用不同的方法填充缺失值。

scipy.interpolate.Akima1DInterpolator

分段立方多项式（Akima 插值器）。

scipy.interpolate.BPoly.from_derivatives

Bernstein 基础的分段多项式。

scipy.interpolate.interp1d

插值 1-D 函数。

scipy.interpolate.KroghInterpolator

插值多项式（Krogh 插值器）。

scipy.interpolate.PchipInterpolator

PCHIP 1 维单调立方插值。

scipy.interpolate.CubicSpline

立方样条数据插值器。

注意事项

‘krogh’、‘piecewise_polynomial’、‘spline’、‘pchip’ 和 ‘akima’ 方法都是类似名字的 SciPy 实现的包装器。这些方法使用索引的实际数值。有关它们的行为的更多信息，请参阅SciPy 文档。

例子

通过线性插值填充 Series 中的 NaN。

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

通过多项式插值或样条插值填充 Series 中的 NaN：‘polynomial’ 和 ‘spline’ 方法都要求您指定一个 order（整数）。

>>> s = pd.Series([0, 2, np.nan, 8])
>>> s.interpolate(method='polynomial', order=2)
0    0.000000
1    2.000000
2    4.666667
3    8.000000
dtype: float64

沿着每列向下填充 DataFrame（即向下填充）使用线性插值。

注意‘a’ 列中的最后一个条目如何进行不同的插值，因为它后面没有条目可用于插值。注意‘b’ 列中的第一个条目保持为 NaN，因为它前面没有条目可用于插值。

>>> df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),
...                    (np.nan, 2.0, np.nan, np.nan),
...                    (2.0, 3.0, np.nan, 9.0),
...                    (np.nan, 4.0, -4.0, 16.0)],
...                   columns=list('abcd'))
>>> df
 a    b    c     d
0  0.0  NaN -1.0   1.0
1  NaN  2.0  NaN   NaN
2  2.0  3.0  NaN   9.0
3  NaN  4.0 -4.0  16.0
>>> df.interpolate(method='linear', limit_direction='forward', axis=0)
 a    b    c     d
0  0.0  NaN -1.0   1.0
1  1.0  2.0 -2.0   5.0
2  2.0  3.0 -3.0   9.0
3  2.0  4.0 -4.0  16.0

使用多项式插值。

>>> df['d'].interpolate(method='polynomial', order=2)
0     1.0
1     4.0
2     9.0
3    16.0
Name: d, dtype: float64

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

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

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

Pandas 2.2 中文文档（二十二）

pandas.DataFrame.min

pandas.DataFrame.mode

pandas.DataFrame.pct_change

pandas.DataFrame.prod

pandas.DataFrame.product

pandas.DataFrame.quantile

pandas.DataFrame.rank

pandas.DataFrame.round

pandas.DataFrame.sem

pandas.DataFrame.skew

pandas.DataFrame.sum

pandas.DataFrame.std

pandas.DataFrame.var

pandas.DataFrame.nunique

pandas.DataFrame.value_counts

pandas.DataFrame.add_prefix

pandas.DataFrame.add_suffix

pandas.DataFrame.align

pandas.DataFrame.at_time

pandas.DataFrame.between_time

pandas.DataFrame.drop

pandas.DataFrame.drop_duplicates

pandas.DataFrame.duplicated

pandas.DataFrame.equals

pandas.DataFrame.filter

pandas.DataFrame.first

pandas.DataFrame.head

pandas.DataFrame.idxmax

pandas.DataFrame.idxmin

pandas.DataFrame.last

pandas.DataFrame.reindex

pandas.DataFrame.reindex_like

pandas.DataFrame.rename

pandas.DataFrame.rename_axis

pandas.DataFrame.reset_index

pandas.DataFrame.sample

pandas.DataFrame.set_axis

pandas.DataFrame.set_index

pandas.DataFrame.tail

pandas.DataFrame.take

pandas.DataFrame.truncate

pandas.DataFrame.backfill

pandas.DataFrame.bfill

pandas.DataFrame.dropna

pandas.DataFrame.ffill

pandas.DataFrame.fillna

pandas.DataFrame.interpolate

公告

`pandas.DataFrame.min`

`pandas.DataFrame.mode`

`pandas.DataFrame.pct_change`

`pandas.DataFrame.prod`

`pandas.DataFrame.product`

`pandas.DataFrame.quantile`

`pandas.DataFrame.rank`

`pandas.DataFrame.round`

`pandas.DataFrame.sem`

`pandas.DataFrame.skew`

`pandas.DataFrame.sum`

`pandas.DataFrame.std`

`pandas.DataFrame.var`

`pandas.DataFrame.nunique`

`pandas.DataFrame.value_counts`

`pandas.DataFrame.add_prefix`

`pandas.DataFrame.add_suffix`

`pandas.DataFrame.align`

`pandas.DataFrame.at_time`

`pandas.DataFrame.between_time`

`pandas.DataFrame.drop`

`pandas.DataFrame.drop_duplicates`

`pandas.DataFrame.duplicated`

`pandas.DataFrame.equals`

`pandas.DataFrame.filter`

`pandas.DataFrame.first`

`pandas.DataFrame.head`

`pandas.DataFrame.idxmax`

`pandas.DataFrame.idxmin`

`pandas.DataFrame.last`

`pandas.DataFrame.reindex`

`pandas.DataFrame.reindex_like`

`pandas.DataFrame.rename`

`pandas.DataFrame.rename_axis`

`pandas.DataFrame.reset_index`

`pandas.DataFrame.sample`

`pandas.DataFrame.set_axis`

`pandas.DataFrame.set_index`

`pandas.DataFrame.tail`

`pandas.DataFrame.take`

`pandas.DataFrame.truncate`

`pandas.DataFrame.backfill`

`pandas.DataFrame.bfill`

`pandas.DataFrame.dropna`

`pandas.DataFrame.ffill`

`pandas.DataFrame.fillna`

`pandas.DataFrame.interpolate`