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 或‘index’，1 或‘columns’}，默认为 0
等于 0 或‘index’表示按行，1 或‘columns’表示按列。
numeric_only布尔值，默认为 False
仅包括浮点数、整数或布尔数据。
在版本 2.0.0 中更改：numeric_only的默认值现在为False。
插值{‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}
这个可选参数指定插值方法，当所需分位数位于两个数据点 i 和 j 之间时使用：
-
linear：i + (j - i) * fraction，其中 fraction 是被 i 和 j 包围的索引的小数部分。
-
lower：i。
-
higher：j。
-
nearest：最接近的 i 或 j。
-
中点：(i + j) / 2。
方法{‘single’, ‘table’}，默认为‘single’
是否按列计算分位数（‘single’）还是所有列（‘table’）。当为‘table’时，唯一允许的插值方法是‘nearest’、‘lower’和‘higher’。
返回：
Series 或 DataFrame
如果q是一个数组，将返回一个 DataFrame，其中
索引是q，列是 self 的列，值是分位数。
如果q是一个浮点数，将返回一个 Series，其中
索引是 self 的列，值是分位数。
参见
core.window.rolling.Rolling.quantile
滚动分位数。
用于计算百分位数的 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 或 ‘index’，1 或 ‘columns’}，默认为 0
直接排名的索引。 对于 Series 对象，此参数未使用并默认为 0。
method{‘average’, ‘min’, ‘max’, ‘first’, ‘dense’}，默认为 ‘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’, ‘top’, ‘bottom’}，默认为 ‘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 数组四舍五入到给定的小数位数。
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 参数进行更改。
参数：
轴{索引 (0)，列 (1)}
对于 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{索引（0），列（1）}
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{索引（0），列（1）}
要应用函数的轴。对于 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 参数进行更改。
参数：
轴{索引（0），列（1）}
对于 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 或 ‘index’，1 或 ‘columns’}，默认为 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{0 或 ‘index’，1 或 ‘columns’，None}，默认为 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{0 或 ‘index’，1 或 ‘columns’，None}，默认为 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’, ‘inner’, ‘left’, ‘right’}，默认为‘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{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}，默认为 None
用于填充重新索引 Series 中空洞的方法：
-
pad / ffill：将最后一个有效观察结果向前传播到下一个有效观察结果。
-
backfill / bfill: 使用下一个有效观察结果来填补间隙。
自版本 2.1 起已弃用。
limitint，默认为 None
如果指定了方法，则这是连续 NaN 值的最大数量，以进行向前/向后填充。换句话说，如果有一个具有超过这个连续 NaN 数的间隙，它将只被部分填充。如果未指定方法，则这是整个轴上将填充 NaN 的条目数的最大值。如果不是 None，则必须大于 0。
自版本 2.1 起已弃用。
fill_axis{0 或 ‘index’} 用于 Series，{0 或 ‘index’，1 或 ‘columns’} 用于 DataFrame，默认为 0
填充轴、方法和限制。
自版本 2.1 起已弃用。
broadcast_axis{0 或 ‘index’} 用于 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 或 ‘index’, 1 或 ‘columns’}，默认为 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”, “neither”, “left”, “right”}，默认为 “both”
包括边界；是否将每个边界设置为闭合或开放。
axis{0 或 ‘index’，1 或 ‘columns’}，默认为 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 或 ‘index’，1 或 ‘columns’}，默认为 0
是否从索引（0 或 ‘index’）或列（1 或 ‘columns’）中删除标签。
index单个标签或类似列表
指定轴的替代方法（labels, axis=0 等同于 index=labels）。
columns单个标签或类似列表
指定轴的替代方法（labels, axis=1 等同于 columns=labels）。
levelint 或级别名称，可选
对于多重索引，将要删除标签的级别。
inplacebool，默认为 False
如果为 False，则返回一个副本。否则，就地执行操作并返回 None。
errors{‘ignore’，‘raise’}，默认为 ‘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’, ‘last’, False}，默认为‘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。
如果两个数组具有相同的形状和元素，则返回 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{0 或‘index’，1 或‘columns’，None}，默认为 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
扫一扫
1838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
