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 4falcon 2
cold fish 0spider 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'))
>>> dfspecies 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'])
>>> dfFR 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'])
>>> df2016 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]})
>>> dfAnimal 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)
>>> dfAnimal 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'])
>>> dfdogs 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'])
>>> dfa 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'])
>>> dfa 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 4falcon 2
cold fish 0spider 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')
>>> dfage 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')
>>> dfage 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'])
>>> dfnum_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']})
>>> dffirst_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 1NaN 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]})
>>> dfA 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]})
>>> dfA 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],
... )
>>> dfD B E A
1 1 2 3 4
2 6 7 8 9
>>> otherA 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)
>>> leftA B C D E
1 4 2 NaN 1 3
2 9 7 NaN 6 8
>>> rightA 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)
>>> leftD 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
>>> rightA 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)
>>> leftA 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
>>> rightA 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)
>>> tsA
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)
>>> tsA
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'])
>>> dfA 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]])
>>> dfbig small
llama speed 45.0 30.0weight 200.0 100.0length 1.5 1.0
cow speed 30.0 20.0weight 250.0 150.0length 1.5 0.8
falcon speed 320.0 250.0weight 1.0 0.8length 0.3 0.2
从多重索引 DataFrame 中删除特定索引组合,即删除组合'falcon'
和'weight'
,这仅会删除相应的行。
>>> df.drop(index=('falcon', 'weight'))big small
llama speed 45.0 30.0weight 200.0 100.0length 1.5 1.0
cow speed 30.0 20.0weight 250.0 150.0length 1.5 0.8
falcon speed 320.0 250.0length 0.3 0.2
>>> df.drop(index='cow', columns='small')big
llama speed 45.0weight 200.0length 1.5
falcon speed 320.0weight 1.0length 0.3
>>> df.drop(index='length', level=1)big small
llama speed 45.0 30.0weight 200.0 100.0
cow speed 30.0 20.0weight 250.0 150.0
falcon speed 320.0 250.0weight 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]
... })
>>> dfbrand 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]
... })
>>> dfbrand 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]})
>>> df1 2
0 10 20
DataFrames df 和 exactly_equal 具有相同类型和元素以及列标签,将返回 True。
>>> exactly_equal = pd.DataFrame({1: [10], 2: [20]})
>>> exactly_equal1 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_type1.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_type1 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'])
>>> dfone 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)
>>> tsA
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']})
>>> dfanimal
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'])
>>> dfconsumption 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'])
>>> dfconsumption 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)
>>> tsA
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)
>>> dfhttp_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)
>>> df2prices
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'))
>>> df1temp_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']))
>>> df2temp_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"])
>>> dfnum_legs num_arms
dog 4 0
cat 4 0
monkey 2 2
>>> df = df.rename_axis("animal")
>>> dfnum_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 0cat 4 0monkey 2 2
>>> df.rename_axis(index={'type': 'class'})
limbs num_legs num_arms
class name
mammal dog 4 0cat 4 0monkey 2 2
>>> df.rename_axis(columns=str.upper)
LIMBS num_legs num_arms
type name
mammal dog 4 0cat 4 0monkey 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'))
>>> dfclass 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)
>>> dfspeed speciesmax type
class name
bird falcon 389.0 flyparrot 24.0 fly
mammal lion 80.5 runmonkey NaN jump
使用 names 参数,为索引列选择一个名称:
>>> df.reset_index(names=['classes', 'names'])classes names speed speciesmax 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 speciesmax 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 speciesclass 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 speciesclass 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 speciesclass 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'])
>>> dfnum_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]})
>>> dfmonth 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 saleyear
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']})
>>> dfanimal
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])
>>> dfname 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])
>>> dfA 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]})
>>> dfA 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]})
>>> dfname 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"))
>>> dfA 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"))
>>> dfA 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'))
>>> dfa 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