Pandas-2-2-中文文件-二十二-

绝不原创的飞龙發表於2024-06-24

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 或標量

另請參閱

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.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 或標量

另請參閱

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 和空系列的方式相同。

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

另請參見

DataFrame.isna

指示缺失值。

DataFrame.notna

指示現有（非缺失）值。

DataFrame.fillna

替換缺失值。

Series.dropna

刪除缺失值。

Index.dropna

刪除缺失索引。

示例

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

Pandas-2-2-中文文件-二十-
2024-06-24
Pandas 2.2 中文官方教程和指南（二十二）
2024-04-24
mongoose中文文件
2018-12-18
Go
aiohttp中文文件
2018-03-03
AIHTTP
GORM 中文文件
2017-01-12
GoORM
tailwindcss中文文件
2024-08-07
AICSS
Vue3學習（二十二）- 儲存文件內容
2024-03-05
Vue
JointJS中文文件
2019-02-16
JS
Laravel Package 中文文件
2021-04-18
LaravelPackage
Ace editor中文文件
2020-10-27
蘋果文件中文版
2017-12-20
蘋果
NUnit中文說明文件
2013-08-01
Activiti中文文件地址
2014-09-10
PostgreSQL 8.2.3 中文文件
2008-05-25
SQL
iptables中文man文件(轉)
2007-08-10
Elasticsearch6.5中文文件-刪除文件
2020-10-22
Elasticsearch
SnapKit 中文文件翻譯
2019-03-04
APK
PHP-redis中文文件
2021-09-09
PHPRedis
JSON Editor 中文文件
2018-11-07
JSON
Ocelot中文文件-快取
2018-05-08
快取
React Starter Kit 中文文件
2017-04-22
React
Oracle官方中文支援文件
2015-02-04
Oracle
蘋果ios 技術文件中文
2013-04-08
蘋果iOS
LaTeX 編寫中文文件
2024-05-10
rust庫-ouroboros中文文件
2024-08-21
RustROS
ES 筆記二十二：多語言及中文分詞與檢索
2019-11-17
筆記中文分詞
【Python】官方文件中文版
2019-03-22
Python
[開發文件]bootstrap中文手冊
2019-05-11
boot
HTTPie 官方文件中文翻譯版
2019-02-16
HTTP
Airflow 中文文件：快速開始
2018-11-28
AI
sharp.js中文文件
2018-11-24
JS
Nextjs中文文件
2018-09-11
NextJS
Gin 框架中文文件（翻譯）
2018-07-13
框架
POI匯入Excel中文API文件
2018-03-02
ExcelAPI
[譯] Laravel-mix 中文文件
2018-05-27
Laravel
Ocelot中文文件-微服務ServiceFabric
2018-05-08
微服務
Ocelot中文文件-轉換Claims
2018-05-08
AI
SQL SERVER 函式中文文件
2012-05-04
SQLServer函式

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`