Pandas-2-2-中文文档-十九-
Pandas 2.2 中文文档（十九）
pandas.Series.iloc
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.iloc.html
property Series.iloc
纯整数位置索引，根据位置进行选择。
自版本 2.2.0 起弃用：从可调用函数返回元组已弃用。
.iloc[]主要基于整数位置（从轴的0到length-1），但也可以与布尔数组一起使用。
允许的输入为：
-
一个整数，例如
5。 -
整数列表或数组，例如
[4, 3, 0]。 -
具有整数的切片对象，例如
1:7。 -
布尔数组。
-
具有一个参数（调用的 Series 或 DataFrame）的
callable函数，并返回用于索引的有效输出（上述之一）。在方法链中很有用，当您没有对调用对象的引用，但希望基于某个值进行选择时。 -
行和列索引的元组。元组元素由上述输入之一组成，例如
(0, 1)。
.iloc将引发IndexError，如果请求的索引器超出范围，除了切片索引器允许超出范围的索引（这符合 python/numpy 切片语义）。
在按位置选择中查看更多。
另请参见
DataFrame.iat
快速整数位置标量访问器。
DataFrame.loc
纯标签位置索引器，根据标签进行选择。
Series.iloc
纯整数位置索引，根据位置进行选择。
示例
>>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
... {'a': 100, 'b': 200, 'c': 300, 'd': 400},
... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}]
>>> df = pd.DataFrame(mydict)
>>> df
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
仅索引行
使用标量整数。
>>> type(df.iloc[0])
<class 'pandas.core.series.Series'>
>>> df.iloc[0]
a 1
b 2
c 3
d 4
Name: 0, dtype: int64
使用整数列表。
>>> df.iloc[[0]]
a b c d
0 1 2 3 4
>>> type(df.iloc[[0]])
<class 'pandas.core.frame.DataFrame'>
>>> df.iloc[[0, 1]]
a b c d
0 1 2 3 4
1 100 200 300 400
使用切片对象。
>>> df.iloc[:3]
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
使用与索引长度相同的布尔掩码。
>>> df.iloc[[True, False, True]]
a b c d
0 1 2 3 4
2 1000 2000 3000 4000
使用可调用函数，在方法链中很有用。传递给lambda的 x 是正在切片的 DataFrame。这将选择索引标签为偶数的行。
>>> df.iloc[lambda x: x.index % 2 == 0]
a b c d
0 1 2 3 4
2 1000 2000 3000 4000
同时索引两个轴
您可以混合索引器类型以选择索引和列。使用:选择��个轴。
使用标量整数。
>>> df.iloc[0, 1]
2
使用整数列表。
>>> df.iloc[[0, 2], [1, 3]]
b d
0 2 4
2 2000 4000
使用切片对象。
>>> df.iloc[1:3, 0:3]
a b c
1 100 200 300
2 1000 2000 3000
使用长度与列匹配的布尔数组。
>>> df.iloc[:, [True, False, True, False]]
a c
0 1 3
1 100 300
2 1000 3000
使用期望 Series 或 DataFrame 的可调用函数。
>>> df.iloc[:, lambda df: [0, 2]]
a c
0 1 3
1 100 300
2 1000 3000
pandas.Series.__iter__
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.__iter__.html
Series.__iter__()
返回值的迭代器。
这些都是标量类型，即 Python 标量（对于 str、int、float）或 pandas 标量（对于 Timestamp/Timedelta/Interval/Period）
返回值：
迭代器
示例
>>> s = pd.Series([1, 2, 3])
>>> for x in s:
... print(x)
1
2
3
pandas.Series.items
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.items.html
Series.items()
懒惰地迭代（索引，数值）元组。
此方法返回一个可迭代的元组（索引，数值）。如果您想创建一个惰性迭代器，这很方便。
返回：
可迭代的
包含 Series 中（索引，数值）对的元组的可迭代对象。
另请参阅
DataFrame.items
迭代（列名，Series）对。
DataFrame.iterrows
以（索引，Series）对的形式迭代 DataFrame 行。
示例
>>> s = pd.Series(['A', 'B', 'C'])
>>> for index, value in s.items():
... print(f"Index : {index}, Value : {value}")
Index : 0, Value : A
Index : 1, Value : B
Index : 2, Value : C
pandas.Series.keys
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.keys.html
Series.keys()
返回索引的别名。
返回：
索引
系列的索引。
示例
>>> s = pd.Series([1, 2, 3], index=[0, 1, 2])
>>> s.keys()
Index([0, 1, 2], dtype='int64')
pandas.Series.pop
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.pop.html
Series.pop(item)
从系列中返回项目并删除。如果未找到，则引发 KeyError。
参数：
item标签
需要被移除的元素的索引。
返回：
从系列中弹出的值。
示例
>>> ser = pd.Series([1, 2, 3])
>>> ser.pop(0)
1
>>> ser
1 2
2 3
dtype: int64
pandas.Series.item
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.item.html
Series.item()
将底层数据的第一个元素作为 Python 标量返回。
返回：
标量
Series 或 Index 的第一个元素。
引发：
值错误
如果数据长度不等于 1。
示例
>>> s = pd.Series([1])
>>> s.item()
1
对于索引：
>>> s = pd.Series([1], index=['a'])
>>> s.index.item()
'a'
pandas.Series.xs
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.xs.html
Series.xs(key, axis=0, level=None, drop_level=True)
从 Series/DataFrame 返回横截面。
此方法接受一个键参数，以选择 MultiIndex 的特定级别的数据。
参数：
key标签或标签元组
包含在索引中的标签，或部分包含在 MultiIndex 中。
axis，默认为 0
要检索横截面的轴。
level对象，默认为前 n 个级别（n=1 或 len(key)）
如果键部分包含在 MultiIndex 中，请指示使用哪些级别。级别可以通过标签或位置引用。
drop_level布尔值，默认为 True
如果为 False，则返回与 self 相同级别的对象。
返回：
Series 或 DataFrame
从原始 Series 或 DataFrame 中获取与所选索引级别对应的横截面。
另请参阅
DataFrame.loc
通过标签或布尔数组访问一组行和列。
DataFrame.iloc
纯整数位置索引，按位置选择。
备注
无法使用 xs 来设置值。
MultiIndex Slicers 是一种通用的方式，可以在任何级别上获取/设置值。它是 xs 功能的超集，请参阅 MultiIndex Slicers。
示例
>>> d = {'num_legs': [4, 4, 2, 2],
... 'num_wings': [0, 0, 2, 2],
... 'class': ['mammal', 'mammal', 'mammal', 'bird'],
... 'animal': ['cat', 'dog', 'bat', 'penguin'],
... 'locomotion': ['walks', 'walks', 'flies', 'walks']}
>>> df = pd.DataFrame(data=d)
>>> df = df.set_index(['class', 'animal', 'locomotion'])
>>> df
num_legs num_wings
class animal locomotion
mammal cat walks 4 0
dog walks 4 0
bat flies 2 2
bird penguin walks 2 2
获取指定索引处的值
>>> df.xs('mammal')
num_legs num_wings
animal locomotion
cat walks 4 0
dog walks 4 0
bat flies 2 2
获取多个索引处的值
>>> df.xs(('mammal', 'dog', 'walks'))
num_legs 4
num_wings 0
Name: (mammal, dog, walks), dtype: int64
获取指定索引和级别处的值
>>> df.xs('cat', level=1)
num_legs num_wings
class locomotion
mammal walks 4 0
获取多个索引和级别处的值
>>> df.xs(('bird', 'walks'),
... level=[0, 'locomotion'])
num_legs num_wings
animal
penguin 2 2
获取指定列和轴处的值
>>> df.xs('num_wings', axis=1)
class animal locomotion
mammal cat walks 0
dog walks 0
bat flies 2
bird penguin walks 2
Name: num_wings, dtype: int64
pandas.Series.add
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.add.html
Series.add(other, level=None, fill_value=None, axis=0)
返回系列和其他的加法，逐元素进行（二进制运算符加法）。
等同于series + other，但支持在两个输入中的任一输入中替换缺失数据的fill_value。
参数：
other系列或标量值
level整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_value无或浮点值，默认为 None（NaN）
在计算之前，填充现有的缺失（NaN）值，并填充任何新元素以成功对齐系列，使用此值。如果两个对应的系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis
未使用。与 DataFrame 兼容性所需的参数。
返回：
系列
操作的结果。
另请参见
Series.radd
反向加法运算符，请参阅Python 文档以获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.add(b, fill_value=0)
a 2.0
b 1.0
c 1.0
d 1.0
e NaN
dtype: float64
pandas.Series.sub
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.sub.html
Series.sub(other, level=None, fill_value=None, axis=0)
返回系列和其他的减法，逐元素进行（二进制运算符 sub）。
等同于series - other，但支持用填充值替换任一输入中的缺失数据。
参数：
其他系列或标量值
级别整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_valueNone 或浮点值，默认为 None（NaN）
在计算之前，使用此值填充现有的缺失（NaN）值，并且为了成功的系列对齐，需要任何新元素。如果两个对应的系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
轴
未使用。与 DataFrame 兼容性所需的参数。
返回：
系列
操作的结果。
另请参阅
Series.rsub
减法运算符的反向，更多细节请参阅Python 文档。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.subtract(b, fill_value=0)
a 0.0
b 1.0
c 1.0
d -1.0
e NaN
dtype: float64
pandas.Series.mul
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.mul.html
Series.mul(other, level=None, fill_value=None, axis=0)
返回序列和其他元素的乘积，逐元素进行（二进制运算符 mul）。
等同于series * other，但支持在任一输入中为缺失数据替换填充值。
参数：
other为 Series 或标量值。
level为整数或名称。
在级别上广播，与传递的 MultiIndex 级别上的索引值匹配。
fill_value为 None 或浮点数值，默认为 None（NaN）。
在计算之前，使用此值填充现有的缺失值（NaN），以及成功序列对齐所需的任何新元素。如果两个对应序列位置的数据均缺失，则填充的结果（在该位置）将是缺失的。
axis为{0 或‘index’}。
未使用。与 DataFrame 兼容性所需的参数。
返回：
Series
操作的结果。
另请参阅
Series.rmul
乘法运算符的反向操作，请参阅Python 文档获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.multiply(b, fill_value=0)
a 1.0
b 0.0
c 0.0
d 0.0
e NaN
dtype: float64
pandas.Series.div
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.div.html
Series.div(other, level=None, fill_value=None, axis=0)
返回系列和其他的浮点除法，逐元素进行（二进制运算符 truediv）。
等同于series / other，但支持用填充值替换输入中任一数据缺失的情况。
参数：
other系列或标量值
levelint 或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的 Index 值。
fill_value无或浮点值，默认为无（NaN）
填充现有缺失（NaN）值，并为成功的系列对齐所需的任何新元素，使用此值进行计算。如果两个对应系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis
未使用。与 DataFrame 兼容性所需的参数。
返回：
系列
操作的结果。
另请参阅
Series.rtruediv
浮点除法运算符的反向操作，请参阅Python 文档获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.divide(b, fill_value=0)
a 1.0
b inf
c inf
d 0.0
e NaN
dtype: float64
pandas.Series.truediv
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.truediv.html
Series.truediv(other, level=None, fill_value=None, axis=0)
返回系列和其他元素的浮点除法，逐元素进行（二进制运算符 truediv）。
等同于series / other，但支持用 fill_value 替换任一输入中的缺失数据。
参数：
other 系列或标量值
level 整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_value 无或浮点值，默认为无（NaN）
在计算之前，使用此值填充现有缺失（NaN）值以及成功系列对齐所需的任何新元素。 如果两个对应系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis {0 或'index'}
未使用。 为了与 DataFrame 兼容性而需要的参数。
返回：
系列
操作的结果。
另请参阅
Series.rtruediv
浮点除法运算符的反向操作，请参阅Python 文档获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.divide(b, fill_value=0)
a 1.0
b inf
c inf
d 0.0
e NaN
dtype: float64
pandas.Series.floordiv
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.floordiv.html
Series.floordiv(other, level=None, fill_value=None, axis=0)
返回系列和其他的整数除法，逐元素进行（二进制运算符 floordiv）。
等同于series // other，但支持用一个填充值替换任一输入中的缺失数据。
参数：
其他系列或标量值
级别整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
填充值无或浮点值，默认无（NaN）
在计算之前，用此值填充现有的缺失（NaN）值，并为成功的系列对齐需要的任何新元素。如果两个对应系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
轴
未使用。与 DataFrame 兼容性所需的参数。
返回：
系列
操作的结果。
另请参阅
Series.rfloordiv
整数除法运算符的反向操作，请参阅Python 文档以获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.floordiv(b, fill_value=0)
a 1.0
b inf
c inf
d 0.0
e NaN
dtype: float64
pandas.Series.mod
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.mod.html
Series.mod(other, level=None, fill_value=None, axis=0)
返回系列和其他的模数，逐元素进行（二进制运算符 mod）。
等同于series % other，但支持用一个 fill_value 替换输入中任一数据缺失的情况。
参数：
otherSeries 或标量值
levelint 或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的 Index 值。
fill_valueNone 或浮点值，默认为 None（NaN）
在计算之前，用此值填充现有的缺失（NaN）值，以及为了成功的 Series 对齐而需要的任何新元素。如果两个对应的 Series 位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis
未使用。与 DataFrame 兼容性所需的参数。
返回：
Series
操作的结果。
另请参阅
Series.rmod
模数运算符的反向操作，请参阅Python 文档获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.mod(b, fill_value=0)
a 0.0
b NaN
c NaN
d 0.0
e NaN
dtype: float64
pandas.Series.pow
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.pow.html
Series.pow(other, level=None, fill_value=None, axis=0)
返回 Series 和 other 的指数幂，逐元素进行（二元运算符 pow）。
等同于series ** other，但支持用一个 fill_value 替换任一输入中的缺失数据。
参数：
otherSeries 或标量值
level整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_valueNone 或浮点值，默认为 None（NaN）
在计算之前，用这个值填充现有的缺失（NaN）值，以及任何需要成功对齐 Series 的新元素。如果两个对应 Series 位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis
未使用。与 DataFrame 兼容性所需的参数。
返回：
Series
操作的结果。
另请参阅
Series.rpow
指数幂运算符的反向，更多细节请参阅Python 文档。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.pow(b, fill_value=0)
a 1.0
b 1.0
c 1.0
d 0.0
e NaN
dtype: float64
pandas.Series.radd
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.radd.html
Series.radd(other, level=None, fill_value=None, axis=0)
返回系列和其他元素逐元素相加的结果（二元操作符 radd）。
等同于 other + series，但支持在两个输入中的任意一个中替换缺失数据的 fill_value。
参数：
other：系列或标量值
level：int 或名称
在一个级别上进行广播，与传递的 MultiIndex 级别上的索引值匹配。
fill_value：None 或浮点值，默认为 None（NaN）
在计算之前，用该值填充现有缺失（NaN）值，并填充任何新需要的元素以成功地对齐系列。 如果两个对应的系列位置的数据都缺失，那么填充的结果（在该位置）将是缺失的。
axis：{0 或 'index'}
未使用。 与 DataFrame 兼容所需的参数。
返回：
系列
操作的结果。
另请参见
Series.add
逐元素加法，请参阅Python 文档了解更多详情。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.add(b, fill_value=0)
a 2.0
b 1.0
c 1.0
d 1.0
e NaN
dtype: float64
pandas.Series.rsub
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.rsub.html
Series.rsub(other, level=None, fill_value=None, axis=0)
返回 series 和 other 的减法，逐元素进行（二进制运算符 rsub）。
等同于other - series，但支持在输入的任一数据中替换缺失数据的填充值。
参数：
otherSeries 或标量值
level整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_value为 None 或浮点值，默认为 None（NaN）。
在计算之前，使用此值填充现有的缺失（NaN）值，并填充任何需要成功 Series 对齐的新元素。如果两个对应 Series 位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis
未使用。与 DataFrame 兼容性所需的参数。
返回：
Series
操作的结果。
另请参阅
Series.sub
逐元素减法，详细信息请参阅Python 文档。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.subtract(b, fill_value=0)
a 0.0
b 1.0
c 1.0
d -1.0
e NaN
dtype: float64
pandas.Series.rmul
原文链接：
pandas.pydata.org/docs/reference/api/pandas.Series.rmul.html
Series.rmul(other, level=None, fill_value=None, axis=0)
返回序列和其他的乘法，逐元素（二元操作符 rmul）。
等同于 other * series，但支持在任一输入中用 fill_value 替换缺失数据。
参数：
other：Series 或标量值
level：整数或名称。
广播到级别，匹配传递的 MultiIndex 级别上的索引值。
fill_value：None 或浮点值，默认为 None（NaN）。
在计算之前，填充现有的缺失（NaN）值和成功对齐序列所需的任何新元素。如果在对应的序列位置上的数据都缺失，那么填充的结果（在该位置上）将是缺失的。
axis：{0 或 ‘index’}
未使用。与 DataFrame 兼容性所需的参数。
返回：
Series
操作的结果。
请参阅
逐元素相乘，请参阅 Python 文档 获取更多细节。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.multiply(b, fill_value=0)
a 1.0
b 0.0
c 0.0
d 0.0
e NaN
dtype: float64
pandas.Series.rdiv
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.rdiv.html
Series.rdiv(other, level=None, fill_value=None, axis=0)
返回系列和其他的浮点除法，逐元素进行（二进制运算符 rtruediv）。
等同于other / series，但支持用填充值替换任一输入中的缺失数据。
参数：
其他系列或标量值
级别int 或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
填充值无或浮点值，默认为无（NaN）
在计算之前，使用此值填充现有缺失（NaN）值和任何新元素，以确保系列对齐成功。如果两个对应系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
轴
未使用。与 DataFrame 兼容所需的参数。
返回：
系列
操作的结果。
另请参阅
Series.truediv
逐元素浮点除法，请参阅Python 文档以获取更多详细信息。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.divide(b, fill_value=0)
a 1.0
b inf
c inf
d 0.0
e NaN
dtype: float64
pandas.Series.rtruediv
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.rtruediv.html
Series.rtruediv(other, level=None, fill_value=None, axis=0)
返回系列和其他的浮点除法，逐元素（二元操作符 rtruediv）。
等同于other / series，但支持在输入的任何一个中替换丢失数据的填充值。
参数：
other系列或标量值
level整数或名称
广播横跨级别，匹配传递的 MultiIndex 级别上的索引值。
fill_value无或浮点值，默认为 None（NaN）
在计算之前，使用此值填充现有的丢失（NaN）值，并且对于成功的 Series 对齐，需要任何新的元素。 如果在相应的 Series 位置中的数据丢失，则填充的结果（在该位置）将丢失。
axis
未使用。 与 DataFrame 兼容所需的参数。
返回：
系列
操作的结果。
另请参阅
Series.truediv
元素级浮点除法，请参阅Python 文档获取更多细节。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.divide(b, fill_value=0)
a 1.0
b inf
c inf
d 0.0
e NaN
dtype: float64
pandas.Series.rfloordiv
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.rfloordiv.html
Series.rfloordiv(other, level=None, fill_value=None, axis=0)
返回 series 和 other 的整数除法，逐元素进行（二元运算符 rfloordiv）。
相当于 other // series，但支持在输入中的任一一个中替换缺失数据的填充值。
参数：
otherSeries 或标量值
level整数或名称
在一个级别上进行广播，匹配通过 MultiIndex 级别传递的索引值。
fill_valueNone 或浮点值，默认为 None（NaN）
在计算之前，使用此值填充现有缺失的 (NaN) 值，并填充任何需要成功进行 Series 对齐的新元素。如果两个对应的 Series 位置的数据都缺失，则填充结果（在该位置）将会缺失。
axis
未使用。为了与 DataFrame 兼容而需要的参数。
返回值：
Series
操作的结果。
另请参阅
Series.floordiv
逐元素的整数除法，更多细节请参阅Python 文档。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.floordiv(b, fill_value=0)
a 1.0
b inf
c inf
d 0.0
e NaN
dtype: float64
pandas.Series.rmod
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.rmod.html
Series.rmod(other, level=None, fill_value=None, axis=0)
返回系列和其他的模运算，逐元素进行（二元运算符 rmod）。
等效于 other % series，但支持用 fill_value 替换其中一个输入中的缺失数据。
参数：
other：系列或标量值
level：整数或名称
在一个级别上广播，匹配传递的多级索引级别上的索引值。
fill_value：None 或浮点值，默认为 None（NaN）
在计算之前，使用此值填充现有缺失的（NaN）值，以及任何成功系列对齐所需的新元素。如果两个对应系列位置的数据均缺失，则填充结果（在该位置）将是缺失的。
axis：{0 或 'index'}
未使用。与 DataFrame 兼容性所需的参数。
返回：
系列
操作的结果。
另请参阅
Series.mod
逐元素的模运算，请参阅 Python 文档 获取更多细节。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.mod(b, fill_value=0)
a 0.0
b NaN
c NaN
d 0.0
e NaN
dtype: float64
pandas.Series.rpow
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.rpow.html
Series.rpow(other, level=None, fill_value=None, axis=0)
返回系列和其他的指数幂，逐元素计算（二元运算符 rpow）。
等同于other ** series，但支持用一个fill_value替换其中一个输入中的缺失数据。
参数：
other系列或标量值
level整数或名称
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_valueNone 或浮点值，默认为 None（NaN）
在计算之前，用这个值填充现有的缺失（NaN）值，以及任何新元素需要成功对齐系列。如果两个对应系列位置的数据都缺失，则填充的结果（在该位置）将是缺失的。
axis
未使用。为了与 DataFrame 兼容而需要的参数。
返回：
系列
操作的结果。
另请参见
Series.pow
逐元素指数幂，更多细节请参阅Python 文档。
示例
>>> a = pd.Series([1, 1, 1, np.nan], index=['a', 'b', 'c', 'd'])
>>> a
a 1.0
b 1.0
c 1.0
d NaN
dtype: float64
>>> b = pd.Series([1, np.nan, 1, np.nan], index=['a', 'b', 'd', 'e'])
>>> b
a 1.0
b NaN
d 1.0
e NaN
dtype: float64
>>> a.pow(b, fill_value=0)
a 1.0
b 1.0
c 1.0
d 0.0
e NaN
dtype: float64
pandas.Series.combine
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.combine.html
Series.combine(other, func, fill_value=None)
根据 func 将 Series 与 Series 或标量组合。
使用 func 将 Series 和其他对象组合，以执行组合 Series 的逐元素选择。当两个对象中的某个索引处的值缺失时，假定 fill_value。
参数：
other Series 或标量
与 Series 组合的值。
func 函数
接受两个标量作为输入并返回一个元素的函数。
fill_value 标量，可选
当一个 Series 中的索引在另一个 Series 中缺失时，假定的值。默认情况下，使用 Series 底层数据类型的适当 NaN 值。
返回：
Series
将 Series 与其他对象组合的结果。
另请参见
Series.combine_first
组合 Series 值，优先选择调用 Series 的值。
示例
考虑包含不同鸟类最高飞行速度的 2 个数据集 s1 和 s2。
>>> s1 = pd.Series({'falcon': 330.0, 'eagle': 160.0})
>>> s1
falcon 330.0
eagle 160.0
dtype: float64
>>> s2 = pd.Series({'falcon': 345.0, 'eagle': 200.0, 'duck': 30.0})
>>> s2
falcon 345.0
eagle 200.0
duck 30.0
dtype: float64
现在，将两个数据集组合起来，查看两个数据集中鸟类的最高速度
>>> s1.combine(s2, max)
duck NaN
eagle 200.0
falcon 345.0
dtype: float64
在前面的示例中，鸭子的结果值缺失，因为 NaN 和浮点数的最大值是 NaN。因此，在示例中，我们设置 fill_value=0，这样返回的最大值将是某个数据集中的值。
>>> s1.combine(s2, max, fill_value=0)
duck 30.0
eagle 200.0
falcon 345.0
dtype: float64
pandas.Series.combine_first
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.combine_first.html
Series.combine_first(other)
使用“other”中相同位置的值更新空元素。
通过使用另一个 Series 中的非空值填充一个 Series 中的空值来组合两个 Series 对象。结果索引将是两个索引的并集。
参数：
otherSeries
用于填充空值的值。
返回：
Series
将提供的 Series 与其他对象组合的结果。
另请参见
Series.combine
使用给定函数在两个 Series 上执行逐元素操作。
示例
>>> s1 = pd.Series([1, np.nan])
>>> s2 = pd.Series([3, 4, 5])
>>> s1.combine_first(s2)
0 1.0
1 4.0
2 5.0
dtype: float64
如果该空值的位置在其他 Series 中不存在，则空值仍然存在
>>> s1 = pd.Series({'falcon': np.nan, 'eagle': 160.0})
>>> s2 = pd.Series({'eagle': 200.0, 'duck': 30.0})
>>> s1.combine_first(s2)
duck 30.0
eagle 160.0
falcon NaN
dtype: float64
pandas.Series.round
原文：
pandas.pydata.org/docs/reference/api/pandas.Series.round.html
Series.round(decimals=0, *args, **kwargs)
将 Series 中的每个值四舍五入到给定的小数位数。
参数：
decimalsint，默认为 0
小数点保留的位数。如果 decimals 是负数，则指定小数点左边的位数。
***args, kwargs
额外的参数和关键词没有效果，但可能被接受以保持与 NumPy 的兼容性。
返回值：
Series
Series 的值四舍五入。
另请参见
四舍五入 np.array 的值。
DataFrame.round
四舍五入 DataFrame 的值。
示例
>>> s = pd.Series([0.1, 1.3, 2.7])
>>> s.round()
0 0.0
1 1.0
2 3.0
dtype: float64
DataFrame
构造函数
DataFrame([data, index, columns, dtype, copy]) |
二维的、大小可变的、可能异构的表格数据。 |
|---|
属性和底层数据
轴
DataFrame.index |
DataFrame 的索引（行标签）。 |
|---|---|
DataFrame.columns |
DataFrame 的列标签。 |
DataFrame.dtypes |
返回 DataFrame 中的数据类型。 |
DataFrame.info([verbose, buf, max_cols, ...]) |
打印 DataFrame 的简洁摘要。 |
DataFrame.select_dtypes([include, exclude]) |
根据列的数据类型返回 DataFrame 的子集。 |
DataFrame.values |
返回 DataFrame 的 Numpy 表示。 |
DataFrame.axes |
返回表示 DataFrame 的轴的列表。 |
DataFrame.ndim |
返回表示轴数/数组维度的整数。 |
DataFrame.size |
返回表示此对象中元素数量的整数。 |
DataFrame.shape |
返回表示 DataFrame 维度的元组。 |
DataFrame.memory_usage([index, deep]) |
返回每列的内存使用量（以字节为单位）。 |
DataFrame.empty |
指示 Series/DataFrame 是否为空。 |
DataFrame.set_flags(*[, copy, ...]) |
返回具有更新标志的新对象。 |
转换
DataFrame.astype(dtype[, copy, errors]) |
将 pandas 对象转换为指定的数据类型 dtype。 |
|---|---|
DataFrame.convert_dtypes([infer_objects, ...]) |
使用支持pd.NA的 dtype 将列转换为最佳可能的 dtype。 |
DataFrame.infer_objects([copy]) |
尝试为对象列推断更好的 dtype。 |
DataFrame.copy([deep]) |
复制此对象的索引和数据。 |
DataFrame.bool() |
(已弃用) 返回单个元素 Series 或 DataFrame 的布尔值。 |
DataFrame.to_numpy([dtype, copy, na_value]) |
将 DataFrame 转换为 NumPy 数组。 |
索引，迭代
DataFrame.head([n]) |
返回前 n 行。 |
|---|---|
DataFrame.at |
访问行/列标签对的单个值。 |
DataFrame.iat |
通过整数位置访问行/列对的单个值。 |
DataFrame.loc |
通过标签或布尔数组访问一组行和列。 |
DataFrame.iloc |
(已弃用) 纯整数位置索引，按位置选择。 |
DataFrame.insert(loc, column, value[, ...]) |
在指定位置将列插入 DataFrame。 |
DataFrame.__iter__() |
在信息轴上进行迭代。 |
DataFrame.items() |
迭代(column name, Series)对。 |
DataFrame.keys() |
获取'信息轴'（详见索引）。 |
DataFrame.iterrows() |
以(index, Series)对的形式迭代 DataFrame 行。 |
DataFrame.itertuples([index, name]) |
以命名元组形式迭代 DataFrame 行。 |
DataFrame.pop(item) |
返回项目并从框架中删除。 |
DataFrame.tail([n]) |
返回最后 n 行。 |
DataFrame.xs(key[, axis, level, drop_level]) |
从系列/数据帧返回横截面。 |
DataFrame.get(key[, default]) |
获取给定键的对象中的项目（例如：数据帧列）。 |
DataFrame.isin(values) |
数据帧中的每个元素是否包含在值中。 |
DataFrame.where(cond[, other, inplace, ...]) |
替换条件为假的值。 |
DataFrame.mask(cond[, other, inplace, axis, ...]) |
替换条件为真的值。 |
DataFrame.query(expr, *[, inplace]) |
使用布尔表达式查询数据帧的列。 |
有关.at、.iat、.loc和.iloc的更多信息，请参阅索引文档。
二元运算符函数
DataFrame.__add__(other) |
获��数据帧和其他数据的加法，按列进行。 |
|---|---|
DataFrame.add(other[, axis, level, fill_value]) |
获取数据帧和其他数据的加法，逐元素进行（二元运算符 add）。 |
DataFrame.sub(other[, axis, level, fill_value]) |
获取数据帧和其他数据的减法，逐元素进行（二元运算符 sub）。 |
DataFrame.mul(other[, axis, level, fill_value]) |
获取数据帧和其他数据的乘法，逐元素进行（二元运算符 mul）。 |
DataFrame.div(other[, axis, level, fill_value]) |
获取数据帧和其他数据的浮点除法，逐元素进行（二元运算符 truediv）。 |
DataFrame.truediv(other[, axis, level, ...]) |
获取数据帧和其他数据的浮点除法，逐元素进行（二元运算符 truediv）。 |
DataFrame.floordiv(other[, axis, level, ...]) |
获取数据帧和其他数据的整数除法，逐元素进行（二元运算符 floordiv）。 |
DataFrame.mod(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的模数，按元素计算（二元运算符 mod）。 |
DataFrame.pow(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的指数幂，按元素计算（二元运算符 pow）。 |
DataFrame.dot(other) |
计算 DataFrame 和其他对象之间的矩阵乘法。 |
DataFrame.radd(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的加法，按元素计算（二元运算符 radd）。 |
DataFrame.rsub(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的减法，按元素计算（二元运算符 rsub）。 |
DataFrame.rmul(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的乘法，按元素计算（二元运算符 rmul）。 |
DataFrame.rdiv(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的浮点数除法，按元素计算（二元运算符 rtruediv）。 |
DataFrame.rtruediv(other[, axis, level, ...]) |
获取 dataframe 和其他对象的浮点数除法，按元素计算（二元运算符 rtruediv）。 |
DataFrame.rfloordiv(other[, axis, level, ...]) |
获取 dataframe 和其他对象的整数除法，按元素计算（二元运算符 rfloordiv）。 |
DataFrame.rmod(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的模数，按元素计算（二元运算符 rmod）。 |
DataFrame.rpow(other[, axis, level, fill_value]) |
获取 dataframe 和其他对象的指数幂，按元素计算（二元运算符 rpow）。 |
DataFrame.lt(other[, axis, level]) |
获取 dataframe 和其他对象的小于，按元素计算（二元运算符 lt）。 |
DataFrame.gt(other[, axis, level]) |
获取 dataframe 和其他对象的大于，按元素计算（二元运算符 gt）。 |
DataFrame.le(other[, axis, level]) |
获取 dataframe 和其他对象的小于或等于，按元素计算（二元运算符 le）。 |
DataFrame.ge(other[, axis, level]) |
获取 DataFrame 和其他对象的大于或等于，逐元素进行（二进制运算符 ge）。 |
DataFrame.ne(other[, axis, level]) |
获取 DataFrame 和其他对象的不相等，逐元素进行（二进制运算符 ne）。 |
DataFrame.eq(other[, axis, level]) |
获取 DataFrame 和其他对象的相等，逐元素进行（二进制运算符 eq）。 |
DataFrame.combine(other, func[, fill_value, ...]) |
与另一个 DataFrame 执行按列合并。 |
DataFrame.combine_first(other) |
使用其他位置的值更新空元素。 |
函数应用，GroupBy 和窗口
DataFrame.apply(func[, axis, raw, ...]) |
沿着 DataFrame 的一个轴应用函数。 |
|---|---|
DataFrame.map(func[, na_action]) |
对 DataFrame 逐元素应用函数。 |
DataFrame.applymap(func[, na_action]) |
（已弃用）对 DataFrame 逐元素应用函数。 |
DataFrame.pipe(func, *args, **kwargs) |
应用可链式调用的函数，这些函数期望 Series 或 DataFrames。 |
DataFrame.agg([func, axis]) |
使用一个或多个操作在指定轴上进行聚合。 |
DataFrame.aggregate([func, axis]) |
使用一个或多个操作在指定轴上进行聚合。 |
DataFrame.transform(func[, axis]) |
对自身调用 func，生成一个与自身轴形状相同的 DataFrame。 |
DataFrame.groupby([by, axis, level, ...]) |
使用映射器或一系列列对 DataFrame 进行分组。 |
DataFrame.rolling(window[, min_periods, ...]) |
提供滚动窗口计算。 |
DataFrame.expanding([min_periods, axis, method]) |
提供扩展窗口计算。 |
DataFrame.ewm([com, span, halflife, alpha, ...]) |
提供指数加权（EW）计算。 |
计算 / 描述性统计
DataFrame.abs() |
返回每个元素的绝对数值的 Series/DataFrame。 |
|---|---|
DataFrame.all([axis, bool_only, skipna]) |
返回是否所有元素为 True，可能沿着一个轴。 |
DataFrame.any(*[, axis, bool_only, skipna]) |
返回是否有任何元素为 True，可能沿着一个轴。 |
DataFrame.clip([lower, upper, axis, inplace]) |
在输入阈值处修剪值。 |
DataFrame.corr([method, min_periods, ...]) |
计算列之间的成对相关性，排除 NA/null 值。 |
DataFrame.corrwith(other[, axis, drop, ...]) |
计算成对相关性。 |
DataFrame.count([axis, numeric_only]) |
计算每列或每行的非 NA 单元格数。 |
DataFrame.cov([min_periods, ddof, numeric_only]) |
计算列之间的成对协方差，排除 NA/null 值。 |
DataFrame.cummax([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积最大值。 |
DataFrame.cummin([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积最小值。 |
DataFrame.cumprod([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积乘积。 |
DataFrame.cumsum([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积和。 |
DataFrame.describe([percentiles, include, ...]) |
生成描述性统计。 |
DataFrame.diff([periods, axis]) |
元素的第一个离散差分。 |
DataFrame.eval(expr, *[, inplace]) |
对描述 DataFrame 列操作的字符串进行求值。 |
DataFrame.kurt([axis, skipna, numeric_only]) |
返回请求轴上的无偏峰度。 |
DataFrame.kurtosis([axis, skipna, numeric_only]) |
返回请求轴上的无偏峰度。 |
DataFrame.max([axis, skipna, numeric_only]) |
返回请求轴上值的最大值。 |
DataFrame.mean([axis, skipna, numeric_only]) |
返回请求轴上值的均值。 |
DataFrame.median([axis, skipna, numeric_only]) |
返回请求轴上值的中位数。 |
DataFrame.min([axis, skipna, numeric_only]) |
返回请求轴上值的最小值。 |
DataFrame.mode([axis, numeric_only, dropna]) |
获取沿所选轴的每个元素的众数。 |
DataFrame.pct_change([periods, fill_method, ...]) |
当前元素与先前元素之间的分数变化。 |
DataFrame.prod([axis, skipna, numeric_only, ...]) |
返回请求轴上值的乘积。 |
DataFrame.product([axis, skipna, ...]) |
返回请求轴上值的乘积。 |
DataFrame.quantile([q, axis, numeric_only, ...]) |
返回请求轴上给定分位数处的值。 |
DataFrame.rank([axis, method, numeric_only, ...]) |
沿轴计算数值数据的排名（1 到 n）。 |
DataFrame.round([decimals]) |
将 DataFrame 四舍五入到可变数量的小数位数。 |
DataFrame.sem([axis, skipna, ddof, numeric_only]) |
返回请求轴上均值的无偏标准误差。 |
DataFrame.skew([axis, skipna, numeric_only]) |
返回请求轴上的无偏偏度。 |
DataFrame.sum([axis, skipna, numeric_only, ...]) |
返回请求轴上值的总和。 |
DataFrame.std([axis, skipna, ddof, numeric_only]) |
返回请求轴上的样本标准差。 |
DataFrame.var([axis, skipna, ddof, numeric_only]) |
返回请求轴上的无偏方差。 |
DataFrame.nunique([axis, dropna]) |
计算指定轴上不同元素的数量。 |
DataFrame.value_counts([subset, normalize, ...]) |
返回包含数据帧中每个不同行频率的 Series。 |
重新索引/选择/标签操作
DataFrame.add_prefix(prefix[, axis]) |
用字符串前缀给标签加前缀。 |
|---|---|
DataFrame.add_suffix(suffix[, axis]) |
用字符串后缀给标签加后缀。 |
DataFrame.align(other[, join, axis, level, ...]) |
使用指定的连接方法在它们的轴上对齐两个对象。 |
DataFrame.at_time(time[, asof, axis]) |
选择一天中特定时间的值（例如，上午 9:30）。 |
DataFrame.between_time(start_time, end_time) |
选择一天中特定时间段之间的值（例如，上午 9:00-9:30）。 |
DataFrame.drop([labels, axis, index, ...]) |
从行或列中删除指定标签。 |
DataFrame.drop_duplicates([subset, keep, ...]) |
返回删除重复行的数据帧。 |
DataFrame.duplicated([subset, keep]) |
返回表示重复行的布尔 Series。 |
DataFrame.equals(other) |
测试两个对象是否包含相同的元素。 |
DataFrame.filter([items, like, regex, axis]) |
根据指定的索引标签对数据帧的行或列进行子集筛选。 |
DataFrame.first(offset) |
(已弃用) 根据日期偏移量选择时间序列数据的初始周期。 |
DataFrame.head([n]) |
返回前 n 行。 |
DataFrame.idxmax([axis, skipna, numeric_only]) |
返回请求轴上最大值的第一次出现的索引。 |
DataFrame.idxmin([axis, skipna, numeric_only]) |
返回请求轴上最小值的第一次出现的索引。 |
DataFrame.last(offset) |
(已弃用) 根据日期偏移量选择时间序列数据的最终周期。 |
DataFrame.reindex([labels, index, columns, ...]) |
将 DataFrame 调整为新索引，可选择填充逻辑。 |
DataFrame.reindex_like(other[, method, ...]) |
返回具有与其他对象匹配索引的对象。 |
DataFrame.rename([mapper, index, columns, ...]) |
重命名列或索引标签。 |
DataFrame.rename_axis([mapper, index, ...]) |
为索引或列设置轴的名称。 |
DataFrame.reset_index([level, drop, ...]) |
重置索引或其级别。 |
DataFrame.sample([n, frac, replace, ...]) |
从对象的轴中返回随机样本项。 |
DataFrame.set_axis(labels, *[, axis, copy]) |
为给定轴分配所需的索引。 |
DataFrame.set_index(keys, *[, drop, append, ...]) |
使用现有列设置 DataFrame 索引。 |
DataFrame.tail([n]) |
返回最后 n 行。 |
DataFrame.take(indices[, axis]) |
返回沿轴的给定位置索引的元素。 |
DataFrame.truncate([before, after, axis, copy]) |
在某个索引值之前和之后截断 Series 或 DataFrame。 |
处理缺失数据
DataFrame.backfill(*[, axis, inplace, ...]) |
(已弃用)使用下一个有效观察结果填充 NA/NaN 值以填补空白。 |
|---|---|
DataFrame.bfill(*[, axis, inplace, limit, ...]) |
通过使用下一个有效观察结果填充 NA/NaN 值以填补空白。 |
DataFrame.dropna(*[, axis, how, thresh, ...]) |
删除缺失值。 |
DataFrame.ffill(*[, axis, inplace, limit, ...]) |
通过将最后一个有效观察结果传播到下一个有效观察结果来填充 NA/NaN 值。 |
DataFrame.fillna([value, method, axis, ...]) |
使用指定方法填充 NA/NaN 值。 |
DataFrame.interpolate([method, axis, limit, ...]) |
使用插值方法填充 NaN 值。 |
DataFrame.isna() |
检测缺失值。 |
DataFrame.isnull() |
DataFrame.isnull 是 DataFrame.isna 的别名。 |
DataFrame.notna() |
检测存在的（非缺失）值。 |
DataFrame.notnull() |
DataFrame.notnull 是 DataFrame.notna 的别名。 |
DataFrame.pad(*[, axis, inplace, limit, ...]) |
(已弃用)通过将最后一个有效观察结果传播到下一个有效观察结果来填充 NA/NaN 值。 |
DataFrame.replace([to_replace, value, ...]) |
用 value 替换 to_replace 中给定的值。 |
重塑、排序、转置
DataFrame.droplevel(level[, axis]) |
返回删除请求的索引/列级别的 Series/DataFrame。 |
|---|---|
DataFrame.pivot(*, columns[, index, values]) |
返回由给定索引/列值组织的重塑 DataFrame。 |
DataFrame.pivot_table([values, index, ...]) |
创建一个类似电子表格样式的透视表作为 DataFrame。 |
DataFrame.reorder_levels(order[, axis]) |
使用输入顺序重新排列索引级别。 |
DataFrame.sort_values(by, *[, axis, ...]) |
沿着任一轴的值进行排序。 |
DataFrame.sort_index(*[, axis, level, ...]) |
按标签（沿着一个轴）对对象进行排序。 |
DataFrame.nlargest(n, columns[, keep]) |
按列按降序排序的方式返回前 n 行。 |
DataFrame.nsmallest(n, columns[, keep]) |
按列按升序排序的方式返回前 n 行。 |
DataFrame.swaplevel([i, j, axis]) |
在 MultiIndex 中交换级别 i 和 j。 |
DataFrame.stack([level, dropna, sort, ...]) |
将指定级别的列堆叠到索引中。 |
DataFrame.unstack([level, fill_value, sort]) |
对（必然是分层的）索引标签的级别进行透视。 |
DataFrame.swapaxes(axis1, axis2[, copy]) |
（已弃用）交换轴并适当交换值轴。 |
DataFrame.melt([id_vars, value_vars, ...]) |
将 DataFrame 从宽格式转换为长格式，可选择保留标识符设置。 |
DataFrame.explode(column[, ignore_index]) |
将类似列表的每个元素转换为一行，复制索引值。 |
DataFrame.squeeze([axis]) |
将 1 维轴对象压缩为标量。 |
DataFrame.to_xarray() |
从 pandas 对象返回一个 xarray 对象。 |
DataFrame.T |
DataFrame 的转置。 |
DataFrame.transpose(*args[, copy]) |
转置索引和列。 |
合并/比较/连接/合并
DataFrame.assign(**kwargs) |
为 DataFrame 分配新列。 |
|---|---|
DataFrame.compare(other[, align_axis, ...]) |
与另一个 DataFrame 进行比较并显示差异。 |
DataFrame.join(other[, on, how, lsuffix, ...]) |
加入另一个 DataFrame 的列。 |
DataFrame.merge(right[, how, on, left_on, ...]) |
与数据库风格的连接方式合并 DataFrame 或命名 Series 对象。 |
DataFrame.update(other[, join, overwrite, ...]) |
使用另一个 DataFrame 中的非 NA 值就地修改。 |
与时间序列相关
DataFrame.asfreq(freq[, method, how, ...]) |
将时间序列转换为指定的频率。 |
|---|---|
DataFrame.asof(where[, subset]) |
返回在 where 之前没有任何 NaN 的最后一行。 |
DataFrame.shift([periods, freq, axis, ...]) |
将索引按所需的周期数移动，可选择性地指定时间频率。 |
DataFrame.first_valid_index() |
返回第一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。 |
DataFrame.last_valid_index() |
返回最后一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。 |
DataFrame.resample(rule[, axis, closed, ...]) |
对时间序列数据重新采样。 |
DataFrame.to_period([freq, axis, copy]) |
将 DataFrame 从 DatetimeIndex 转换为 PeriodIndex。 |
DataFrame.to_timestamp([freq, how, axis, copy]) |
转换为时间戳的 DatetimeIndex，位于周期的开始。 |
DataFrame.tz_convert(tz[, axis, level, copy]) |
将带有时区信息的轴转换为目标时区。 |
DataFrame.tz_localize(tz[, axis, level, ...]) |
将 Series 或 DataFrame 的 tz-naive 索引本地化到目标时区。 |
标志
标志指的是 pandas 对象的属性。数据集的属性（如记录日期、访问的 URL 等）应存储在 DataFrame.attrs 中。
| Flags(obj, *, allows_duplicate_labels) | 适用于 pandas 对象的标志。 | ## 元数据
DataFrame.attrs 是用于存储此 DataFrame 的全局元数据的字典。
警告
DataFrame.attrs 被视为实验性内容，可能会在没有警告的情况下更改。
| DataFrame.attrs | 此数据集的全局属性字典。 | ## 绘图
DataFrame.plot 既是一个可调用的方法，也是特定绘图方法的命名空间属性，形式为 DataFrame.plot.<kind>。
DataFrame.plot([x, y, kind, ax, ....]) |
DataFrame 绘图访问器和方法 |
|---|---|
DataFrame.plot.area([x, y, stacked]) |
绘制堆叠面积图。 |
DataFrame.plot.bar([x, y]) |
垂直条形图。 |
DataFrame.plot.barh([x, y]) |
绘制水平条形图。 |
DataFrame.plot.box([by]) |
绘制 DataFrame 列的箱线图。 |
DataFrame.plot.density([bw_method, ind]) |
使用高斯核生成核密度估计图。 |
DataFrame.plot.hexbin(x, y[, C, ...]) |
生成六边形二进制图。 |
DataFrame.plot.hist([by, bins]) |
绘制 DataFrame 列的直方图。 |
DataFrame.plot.kde([bw_method, ind]) |
使用高斯核生成核密度估计图。 |
DataFrame.plot.line([x, y]) |
将 Series 或 DataFrame 绘制为线条。 |
DataFrame.plot.pie(**kwargs) |
生成饼图。 |
DataFrame.plot.scatter(x, y[, s, c]) |
创建一个带有不同标记点大小和颜色的散点图。 |
DataFrame.boxplot([column, by, ax, ...]) |
从 DataFrame 列制作箱线图。 |
| DataFrame.hist([column, by, grid, ...]) | 绘制 DataFrame 列的直方图。 | ## 稀疏访问器
提供了特定于稀疏-dtype 的方法和属性，可以在 DataFrame.sparse 访问器下找到。
DataFrame.sparse.density |
非稀疏点与总数据点（密集）的比率。 |
|---|---|
DataFrame.sparse.from_spmatrix(data[, ...]) |
从 scipy 稀疏矩阵创建一个新的 DataFrame。 |
DataFrame.sparse.to_coo() |
将帧的内容作为稀疏 SciPy COO 矩阵返回。 |
DataFrame.sparse.to_dense() |
将具有稀疏值的 DataFrame 转换为密集形式。 |
序列化 / IO / 转换
DataFrame.from_dict(data[, orient, dtype, ...]) |
从数组样式或字典的字典构造 DataFrame。 |
|---|---|
DataFrame.from_records(data[, index, ...]) |
将结构化或记录 ndarray 转换为 DataFrame。 |
DataFrame.to_orc([path, engine, index, ...]) |
将 DataFrame 写入 ORC 格式。 |
DataFrame.to_parquet([path, engine, ...]) |
将 DataFrame 写入二进制 parquet 格式。 |
DataFrame.to_pickle(path, *[, compression, ...]) |
将对象序列化为文件。 |
DataFrame.to_csv([path_or_buf, sep, na_rep, ...]) |
将对象写入逗号分隔值（csv）文件。 |
DataFrame.to_hdf(path_or_buf, *, key[, ...]) |
使用 HDFStore 将包含的数据写入 HDF5 文件。 |
DataFrame.to_sql(name, con, *[, schema, ...]) |
将存储在 DataFrame 中的记录写入 SQL 数据库。 |
DataFrame.to_dict([orient, into, index]) |
将 DataFrame 转换为字典。 |
DataFrame.to_excel(excel_writer, *[, ...]) |
将对象写入 Excel 表格。 |
DataFrame.to_json([path_or_buf, orient, ...]) |
将对象转换为 JSON 字符串。 |
DataFrame.to_html([buf, columns, col_space, ...]) |
将 DataFrame 呈现为 HTML 表格。 |
DataFrame.to_feather(path, **kwargs) |
将 DataFrame 写入二进制 Feather 格式。 |
DataFrame.to_latex([buf, columns, header, ...]) |
将对象呈现为 LaTeX 表格、长表格或嵌套表格。 |
DataFrame.to_stata(path, *[, convert_dates, ...]) |
将 DataFrame 对象导出为 Stata dta 格式。 |
DataFrame.to_gbq(destination_table, *[, ...]) |
(已弃用) 将 DataFrame 写入 Google BigQuery 表格。 |
DataFrame.to_records([index, column_dtypes, ...]) |
将 DataFrame 转换为 NumPy 记录数组。 |
DataFrame.to_string([buf, columns, ...]) |
将 DataFrame 呈现为适合控制台的表格输出。 |
DataFrame.to_clipboard(*[, excel, sep]) |
将对象复制到系统剪贴板。 |
DataFrame.to_markdown([buf, mode, index, ...]) |
以适合 Markdown 的格式打印 DataFrame。 |
DataFrame.style |
返回一个 Styler 对象。 |
DataFrame.__dataframe__([nan_as_null, ...]) |
返回实现交换协议的数据帧交换对象。 |
构造函数
DataFrame([data, index, columns, dtype, copy]) |
二维、大小可变、可能异构的表格数据。 |
|---|
属性和底层数据
轴
DataFrame.index |
DataFrame 的索引（行标签）。 |
|---|---|
DataFrame.columns |
DataFrame 的列标签。 |
DataFrame.dtypes |
返回 DataFrame 中的数据类型。 |
DataFrame.info([verbose, buf, max_cols, ...]) |
打印 DataFrame 的简明摘要。 |
DataFrame.select_dtypes([include, exclude]) |
根据列的数据类型返回 DataFrame 列的子集。 |
DataFrame.values |
返回 DataFrame 的 Numpy 表示。 |
DataFrame.axes |
返回表示 DataFrame 轴的列表。 |
DataFrame.ndim |
返回表示轴数/数组维度的整数。 |
DataFrame.size |
返回表示此对象中元素数量的整数。 |
DataFrame.shape |
返回表示 DataFrame 维度的元组。 |
DataFrame.memory_usage([index, deep]) |
返回每列的内存使用量（以字节为单位）。 |
DataFrame.empty |
指示 Series/DataFrame 是否为空。 |
DataFrame.set_flags(*[, copy, ...]) |
返回具有更新标志的新对象。 |
转换
DataFrame.astype(dtype[, copy, errors]) |
将 pandas 对象转换为指定的 dtype dtype。 |
|---|---|
DataFrame.convert_dtypes([infer_objects, ...]) |
使用支持pd.NA的数据类型，将列转换为最佳数据类型。 |
DataFrame.infer_objects([copy]) |
尝试为对象列推断更好的数据类型。 |
DataFrame.copy([deep]) |
复制此对象的索引和数据。 |
DataFrame.bool() |
（已弃用）返回单个元素 Series 或 DataFrame 的布尔值。 |
DataFrame.to_numpy([dtype, copy, na_value]) |
将 DataFrame 转换为 NumPy 数组。 |
索引，迭代
DataFrame.head([n]) |
返回前 n 行。 |
|---|---|
DataFrame.at |
访问行/列标签对的单个值。 |
DataFrame.iat |
通过整数位置访问行/列对的单个值。 |
DataFrame.loc |
通过标签或布尔数组访问一组行和列。 |
DataFrame.iloc |
（已弃用）基于纯整数位置的索引，按位置选择。 |
DataFrame.insert(loc, column, value[, ...]) |
在指定位置将列插入 DataFrame。 |
DataFrame.__iter__() |
迭代信息轴。 |
DataFrame.items() |
以（列名，Series）对的形式迭代。 |
DataFrame.keys() |
获取“信息轴”（详见索引）。 |
DataFrame.iterrows() |
以（索引，Series）对的形式迭代 DataFrame 行。 |
DataFrame.itertuples([index, name]) |
以命名元组形式迭代 DataFrame 行。 |
DataFrame.pop(item) |
返回项目并从框架中删除。 |
DataFrame.tail([n]) |
返回最后 n 行。 |
DataFrame.xs(key[, axis, level, drop_level]) |
从 Series/DataFrame 返回横截面。 |
DataFrame.get(key[, default]) |
获取给定键的对象中的项目（例如：数据框列）。 |
DataFrame.isin(values) |
检查数据框中的每个元素是否包含在给定值中。 |
DataFrame.where(cond[, other, inplace, ...]) |
替换条件为 False 的值。 |
DataFrame.mask(cond[, other, inplace, axis, ...]) |
替换条件为 True 的值。 |
DataFrame.query(expr, *[, inplace]) |
使用布尔表达式查询数据框的列。 |
关于.at, .iat, .loc, 和 .iloc的更多信息，请参阅索引文档。
二元运算符函数
DataFrame.__add__(other) |
获取数据框和其他数据的加法，按列进行。 |
|---|---|
DataFrame.add(other[, axis, level, fill_value]) |
获取数据框和其他数据的加法，逐元素进行（二元运算符加法）。 |
DataFrame.sub(other[, axis, level, fill_value]) |
获取数据框和其他数据的减法，逐元素进行（二元运算符减法）。 |
DataFrame.mul(other[, axis, level, fill_value]) |
获取数据框和其他数据的乘法，逐元素进行（二元运算符乘法）。 |
DataFrame.div(other[, axis, level, fill_value]) |
获取数据框和其他数据的浮点除法，逐元素进行（二元运算符真除法）。 |
DataFrame.truediv(other[, axis, level, ...]) |
获取数据框和其他数据的浮点除法，逐元素进行（二元运算符真除法）。 |
DataFrame.floordiv(other[, axis, level, ...]) |
获取数据框和其他数据的整数除法，逐元素进行（二元运算符整数除法）。 |
DataFrame.mod(other[, axis, level, fill_value]) |
获取数据框和其他数据的模数，逐元素计算（二元运算符 mod）。 |
DataFrame.pow(other[, axis, level, fill_value]) |
获取数据框和其他数据的指数幂，逐元素计算（二元运算符 pow）。 |
DataFrame.dot(other) |
计算数据框和其他数据的矩阵乘法。 |
DataFrame.radd(other[, axis, level, fill_value]) |
获取数据框和其他数据的加法，逐元素计算（二元运算符 radd）。 |
DataFrame.rsub(other[, axis, level, fill_value]) |
获取数据框和其他数据的减法，逐元素计算（二元运算符 rsub）。 |
DataFrame.rmul(other[, axis, level, fill_value]) |
获取数据框和其他数据的乘法，逐元素计算（二元运算符 rmul）。 |
DataFrame.rdiv(other[, axis, level, fill_value]) |
获取数据框和其他数据的浮点数除法，逐元素计算（二元运算符 rtruediv）。 |
DataFrame.rtruediv(other[, axis, level, ...]) |
获取数据框和其他数据的浮点数除法，逐元素计算（二元运算符 rtruediv）。 |
DataFrame.rfloordiv(other[, axis, level, ...]) |
获取数据框和其他数据的整数除法，逐元素计算（二元运算符 rfloordiv）。 |
DataFrame.rmod(other[, axis, level, fill_value]) |
获取数据框和其他数据的模数，逐元素计算（二元运算符 rmod）。 |
DataFrame.rpow(other[, axis, level, fill_value]) |
获取数据框和其他数据的指数幂，逐元素计算（二元运算符 rpow）。 |
DataFrame.lt(other[, axis, level]) |
获取数据框和其他数据的小于关系，逐元素计算（二元运算符 lt）。 |
DataFrame.gt(other[, axis, level]) |
获取数据框和其他数据的大于关系，逐元素计算（二元运算符 gt）。 |
DataFrame.le(other[, axis, level]) |
获取数据框和其他数据的小于等于关系，逐元素计算（二元运算符 le）。 |
DataFrame.ge(other[, axis, level]) |
获取 DataFrame 和其他元素的大于或等于，逐元素进行（二进制运算符 ge）。 |
DataFrame.ne(other[, axis, level]) |
获取 DataFrame 和其他元素的不等于，逐元素进行（二进制运算符 ne）。 |
DataFrame.eq(other[, axis, level]) |
获取 DataFrame 和其他元素的等于，逐元素进行（二进制运算符 eq）。 |
DataFrame.combine(other, func[, fill_value, ...]) |
与另一个 DataFrame 执行按列合并。 |
DataFrame.combine_first(other) |
使用其他位置相同的值更新空元素。 |
函数应用，GroupBy 和窗口
DataFrame.apply(func[, axis, raw, ...]) |
沿 DataFrame 的轴应用函数。 |
|---|---|
DataFrame.map(func[, na_action]) |
对 DataFrame 逐元素应用函数。 |
DataFrame.applymap(func[, na_action]) |
(已弃用) 对 DataFrame 逐元素应用函数。 |
DataFrame.pipe(func, *args, **kwargs) |
应用可链式调用的函数，期望 Series 或 DataFrames。 |
DataFrame.agg([func, axis]) |
沿指定轴使用一个或多个操作进行聚合。 |
DataFrame.aggregate([func, axis]) |
沿指定轴使用一个或多个操作进行聚合。 |
DataFrame.transform(func[, axis]) |
在自身上调用func，生成一个与自身轴形状相同的 DataFrame。 |
DataFrame.groupby([by, axis, level, ...]) |
使用映射器或列系列对 DataFrame 进行分组。 |
DataFrame.rolling(window[, min_periods, ...]) |
提供滚动窗口计算。 |
DataFrame.expanding([min_periods, axis, method]) |
提供扩展窗口计算。 |
DataFrame.ewm([com, span, halflife, alpha, ...]) |
提供指数加权（EW）计算。 |
计算 / 描述性统计
DataFrame.abs() |
返回每个元素的绝对数值的 Series/DataFrame。 |
|---|---|
DataFrame.all([axis, bool_only, skipna]) |
返回是否所有元素为 True，可能沿着一个轴。 |
DataFrame.any(*[, axis, bool_only, skipna]) |
返回是否有任何元素为 True，可能沿着一个轴。 |
DataFrame.clip([lower, upper, axis, inplace]) |
在输入阈值处修剪值。 |
DataFrame.corr([method, min_periods, ...]) |
计算列的成对相关性，不包括 NA/null 值。 |
DataFrame.corrwith(other[, axis, drop, ...]) |
计算成对的相关性。 |
DataFrame.count([axis, numeric_only]) |
计算每列或每行的非 NA 单元格数。 |
DataFrame.cov([min_periods, ddof, numeric_only]) |
计算列的成对协方差，不包括 NA/null 值。 |
DataFrame.cummax([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积最大值。 |
DataFrame.cummin([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积最小值。 |
DataFrame.cumprod([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积乘积。 |
DataFrame.cumsum([axis, skipna]) |
返回 DataFrame 或 Series 轴上的累积和。 |
DataFrame.describe([percentiles, include, ...]) |
生成描述性统计。 |
DataFrame.diff([periods, axis]) |
元素的第一个离散差异。 |
DataFrame.eval(expr, *[, inplace]) |
对描述 DataFrame 列操作的字符串进行评估。 |
DataFrame.kurt([axis, skipna, numeric_only]) |
返回请求轴上的无偏峰度。 |
DataFrame.kurtosis([axis, skipna, numeric_only]) |
返回请求轴上的无偏峰度。 |
DataFrame.max([axis, skipna, numeric_only]) |
返回请求轴上的最大值。 |
DataFrame.mean([axis, skipna, numeric_only]) |
返回请求轴上的均值。 |
DataFrame.median([axis, skipna, numeric_only]) |
返回请求轴上的中位数。 |
DataFrame.min([axis, skipna, numeric_only]) |
返回请求轴上的最小值。 |
DataFrame.mode([axis, numeric_only, dropna]) |
获取所选轴上每个元素的众数。 |
DataFrame.pct_change([periods, fill_method, ...]) |
当前元素与前一个元素之间的分数变化。 |
DataFrame.prod([axis, skipna, numeric_only, ...]) |
返回请求轴上值的乘积。 |
DataFrame.product([axis, skipna, ...]) |
返回请求轴上的值的乘积。 |
DataFrame.quantile([q, axis, numeric_only, ...]) |
返回请求轴上给定分位数的值。 |
DataFrame.rank([axis, method, numeric_only, ...]) |
沿轴计算数值数据排名（1 到 n）。 |
DataFrame.round([decimals]) |
将 DataFrame 四舍五入到可变数量的小数位数。 |
DataFrame.sem([axis, skipna, ddof, numeric_only]) |
返回请求轴上均值的无偏标准误差。 |
DataFrame.skew([axis, skipna, numeric_only]) |
返回请求轴上的无偏偏斜。 |
DataFrame.sum([axis, skipna, numeric_only, ...]) |
返回请求轴上数值的总和。 |
DataFrame.std([axis, skipna, ddof, numeric_only]) |
返回请求轴上的样本标准差。 |
DataFrame.var([axis, skipna, ddof, numeric_only]) |
返回请求轴上的无偏方差。 |
DataFrame.nunique([axis, dropna]) |
计算指定轴上不同元素的数量。 |
DataFrame.value_counts([subset, normalize, ...]) |
返回一个包含数据框中每个不同行频率的 Series。 |
重新索引/选择/标签操作
DataFrame.add_prefix(prefix[, axis]) |
使用字符串前缀给标签加前缀。 |
|---|---|
DataFrame.add_suffix(suffix[, axis]) |
使用字符串后缀给标签加后缀。 |
DataFrame.align(other[, join, axis, level, ...]) |
使用指定的连接方法在它们的轴上对齐两���对象。 |
DataFrame.at_time(time[, asof, axis]) |
选择一天中特定时间的值（例如，上午 9:30）。 |
DataFrame.between_time(start_time, end_time) |
选择一天中特定时间段之间的值（例如，上午 9:00-9:30）。 |
DataFrame.drop([labels, axis, index, ...]) |
从行或列中删除指定标签。 |
DataFrame.drop_duplicates([subset, keep, ...]) |
返回删除重复行的数据框。 |
DataFrame.duplicated([subset, keep]) |
返回表示重复行的布尔 Series。 |
DataFrame.equals(other) |
测试两个对象是否包含相同的元素。 |
DataFrame.filter([items, like, regex, axis]) |
根据指定的索引标签对数据框行或列进行子集选择。 |
DataFrame.first(offset) |
(已弃用) 根据日期偏移量选择时间序列数据的初始周期。 |
DataFrame.head([n]) |
返回前 n 行。 |
DataFrame.idxmax([axis, skipna, numeric_only]) |
返回请求轴上最大值的第一次出现的索引。 |
DataFrame.idxmin([axis, skipna, numeric_only]) |
返回请求轴上最小值的第一次出现的索引。 |
DataFrame.last(offset) |
(已弃用) 根据日期偏移量选择时间序列数据的最终周期。 |
DataFrame.reindex([labels, index, columns, ...]) |
使用可选的填充逻辑使 DataFrame 符合新索引。 |
DataFrame.reindex_like(other[, method, ...]) |
返回具有与其他对象匹配索引的对象。 |
DataFrame.rename([mapper, index, columns, ...]) |
重命名列或索引标签。 |
DataFrame.rename_axis([mapper, index, ...]) |
设置索引或列的轴的名称。 |
DataFrame.reset_index([level, drop, ...]) |
重置索引或其级别。 |
DataFrame.sample([n, frac, replace, ...]) |
从对象的轴中返回随机样本项。 |
DataFrame.set_axis(labels, *[, axis, copy]) |
将所需的索引分配给给定的轴。 |
DataFrame.set_index(keys, *[, drop, append, ...]) |
使用现有列设置 DataFrame 索引。 |
DataFrame.tail([n]) |
返回最后 n 行。 |
DataFrame.take(indices[, axis]) |
返回沿轴的给定 位置 索引的元素。 |
DataFrame.truncate([before, after, axis, copy]) |
截断 Series 或 DataFrame，在某个索引值之前和之后。 |
处理缺失数据
DataFrame.backfill(*[, axis, inplace, ...]) |
(已弃用) 使用下一个有效观测值填充 NA/NaN 值。 |
|---|---|
DataFrame.bfill(*[, axis, inplace, limit, ...]) |
使用下一个有效观测值填充 NA/NaN 值。 |
DataFrame.dropna(*[, axis, how, thresh, ...]) |
删除缺失值。 |
DataFrame.ffill(*[, axis, inplace, limit, ...]) |
通过将最后一个有效观测值传播到下一个有效值来填充 NA/NaN 值。 |
DataFrame.fillna([value, method, axis, ...]) |
使用指定方法填充 NA/NaN 值。 |
DataFrame.interpolate([method, axis, limit, ...]) |
使用插值方法填充 NaN 值。 |
DataFrame.isna() |
检测缺失值。 |
DataFrame.isnull() |
DataFrame.isnull 是 DataFrame.isna 的别名。 |
DataFrame.notna() |
检测存在的（非缺失）值。 |
DataFrame.notnull() |
DataFrame.notnull 是 DataFrame.notna 的别名。 |
DataFrame.pad(*[, axis, inplace, limit, ...]) |
(已弃用) 通过将最后一个有效观测值传播到下一个有效值来填充 NA/NaN 值。 |
DataFrame.replace([to_replace, value, ...]) |
用给定的值替换 to_replace 中的值。 |
重塑、排序、转置
DataFrame.droplevel(level[, axis]) |
返回删除请求的索引/列级别的 Series/DataFrame。 |
|---|---|
DataFrame.pivot(*, columns[, index, values]) |
返回按给定索引/列值组织的重塑 DataFrame。 |
DataFrame.pivot_table([values, index, ...]) |
创建一个类似电子表格样式的透视表作为 DataFrame。 |
DataFrame.reorder_levels(order[, axis]) |
使用输入顺序重新排列索引级别。 |
DataFrame.sort_values(by, *[, axis, ...]) |
沿任一轴的值排序。 |
DataFrame.sort_index(*[, axis, level, ...]) |
按标签（沿轴）对对象进行排序。 |
DataFrame.nlargest(n, columns[, keep]) |
按列按降序顺序返回前 n 行。 |
DataFrame.nsmallest(n, columns[, keep]) |
按升序顺序返回按列排序的前 n 行。 |
DataFrame.swaplevel([i, j, axis]) |
在 MultiIndex 中交换级别 i 和 j。 |
DataFrame.stack([level, dropna, sort, ...]) |
将指定级别的列堆叠到索引中。 |
DataFrame.unstack([level, fill_value, sort]) |
透视（必然是分层的）索引标签的一个级别。 |
DataFrame.swapaxes(axis1, axis2[, copy]) |
（已弃用）交换轴并适当交换值轴。 |
DataFrame.melt([id_vars, value_vars, ...]) |
将 DataFrame 从宽格式转换为长格式，可选择保留标识符设置。 |
DataFrame.explode(column[, ignore_index]) |
将类似列表的每个元素转换为一行，复制索引值。 |
DataFrame.squeeze([axis]) |
将 1 维轴对象压缩为标量。 |
DataFrame.to_xarray() |
从 pandas 对象返回一个 xarray 对象。 |
DataFrame.T |
DataFrame 的转置。 |
DataFrame.transpose(*args[, copy]) |
转置索引和列。 |
合并/比较/连接/合并
DataFrame.assign(**kwargs) |
将新列分配给 DataFrame。 |
|---|---|
DataFrame.compare(other[, align_axis, ...]) |
与另一个 DataFrame 进行比较并显示差异。 |
DataFrame.join(other[, on, how, lsuffix, ...]) |
加入另一个 DataFrame 的列。 |
DataFrame.merge(right[, how, on, left_on, ...]) |
与数据库风格的连接方式合并 DataFrame 或命名 Series 对象。 |
DataFrame.update(other[, join, overwrite, ...]) |
使用另一个 DataFrame 中的非 NA 值就地修改。 |
与时间序列相关
DataFrame.asfreq(freq[, method, how, ...]) |
将时间序列转换为指定频率。 |
|---|---|
DataFrame.asof(where[, subset]) |
返回在 where 之前没有任何 NaN 的最后一行。 |
DataFrame.shift([periods, freq, axis, ...]) |
将索引按所需的周期数移动，可选择时间频率。 |
DataFrame.first_valid_index() |
返回第一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。 |
DataFrame.last_valid_index() |
返回最后一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。 |
DataFrame.resample(rule[, axis, closed, ...]) |
对时间序列数据进行重新采样。 |
DataFrame.to_period([freq, axis, copy]) |
将 DataFrame 从 DatetimeIndex 转换为 PeriodIndex。 |
DataFrame.to_timestamp([freq, how, axis, copy]) |
转换为时间戳的 DatetimeIndex，位于周期的开始。 |
DataFrame.tz_convert(tz[, axis, level, copy]) |
将 tz-aware 轴转换为目标时区。 |
DataFrame.tz_localize(tz[, axis, level, ...]) |
将 Series 或 DataFrame 的 tz-naive 索引本地化到目标时区。 |
标志
标志指的是 pandas 对象的属性。数据集的属性（如记录日期、访问的 URL 等）应存储在DataFrame.attrs中。
Flags(obj, *, allows_duplicate_labels) |
适用于 pandas 对象的标志。 |
|---|
元数据
DataFrame.attrs是用于存储此 DataFrame 全局元数据的字典。
警告
DataFrame.attrs被视为实验性内容，可能会在没有警告的情况下更改。
DataFrame.attrs |
此数据集的全局属性字典。 |
|---|
绘图
DataFrame.plot既是一个可调用方法，也是特定绘图方法的命名空间属性，形式为DataFrame.plot.<kind>。
DataFrame.plot([x, y, kind, ax, ....]) |
DataFrame 绘图访问器和方法 |
|---|---|
DataFrame.plot.area |
绘制堆叠面积图。 |
DataFrame.plot.bar([x, y]) |
垂直条形图。 |
DataFrame.plot.barh([x, y]) |
绘制水平条形图。 |
DataFrame.plot.box([by]) |
绘制数据框的箱线图。 |
DataFrame.plot.density([bw_method, ind]) |
使用高斯核生成核密度估计图。 |
DataFrame.plot.hexbin(x, y[, C, ...]) |
生成六边形二进制图。 |
DataFrame.plot.hist([by, bins]) |
绘制 DataFrame 列的直方图。 |
DataFrame.plot.kde([bw_method, ind]) |
使用高斯核生成核密度估计图。 |
DataFrame.plot.line([x, y]) |
将 Series 或 DataFrame 绘制为线条。 |
DataFrame.plot.pie(**kwargs) |
生成饼图。 |
DataFrame.plot.scatter(x, y[, s, c]) |
创建散点图，可变的标记点大小和颜色。 |
DataFrame.boxplot([column, by, ax, ...]) |
从 DataFrame 列制作箱线图。 |
DataFrame.hist([column, by, grid, ...]) |
绘制 DataFrame 列的直方图。 |
稀疏访问器
提供了特定于稀疏 dtype 的方法和属性，位于 DataFrame.sparse 访问器下。
DataFrame.sparse.density |
非稀疏点与总数据点（密集）的比率。 |
|---|---|
DataFrame.sparse.from_spmatrix(data[, ...]) |
从 scipy 稀疏矩阵创建新 DataFrame。 |
DataFrame.sparse.to_coo() |
将帧内容作为稀疏 SciPy COO 矩阵返回。 |
DataFrame.sparse.to_dense() |
将具有稀疏值的 DataFrame 转换为密集。 |
序列化 / IO / 转换
DataFrame.from_dict(data[, orient, dtype, ...]) |
从数组样式或字典的字典构造 DataFrame。 |
|---|---|
DataFrame.from_records |
将结构化或记录的 ndarray 转换为 DataFrame。 |
DataFrame.to_orc([path, engine, index, ...]) |
将 DataFrame 写入 ORC 格式。 |
DataFrame.to_parquet([path, engine, ...]) |
将 DataFrame 写入二进制 parquet 格式。 |
DataFrame.to_pickle(path, *[, compression, ...]) |
将对象 pickle（序列化）到文件。 |
DataFrame.to_csv([path_or_buf, sep, na_rep, ...]) |
将对象写入逗号分隔值（csv）文件。 |
DataFrame.to_hdf(path_or_buf, *, key[, ...]) |
使用 HDFStore 将包含的数据写入 HDF5 文件。 |
DataFrame.to_sql(name, con, *[, schema, ...]) |
将存储在 DataFrame 中的记录写入 SQL 数据库。 |
DataFrame.to_dict([orient, into, index]) |
将 DataFrame 转换为字典。 |
DataFrame.to_excel(excel_writer, *[, ...]) |
将对象写入 Excel 表格。 |
DataFrame.to_json([path_or_buf, orient, ...]) |
将对象转换为 JSON 字符串。 |
DataFrame.to_html([buf, columns, col_space, ...]) |
将 DataFrame 呈现为 HTML 表格。 |
DataFrame.to_feather(path, kwargs) |
将 DataFrame 写入二进制 Feather 格式。 |
DataFrame.to_latex([buf, columns, header, ...]) |
将对象呈现为 LaTeX 表格、长表格或嵌套表格。 |
DataFrame.to_stata(path, *[, convert_dates, ...]) |
将 DataFrame 对象导出为 Stata dta 格式。 |
DataFrame.to_gbq(destination_table, *[, ...]) |
（已弃用）将 DataFrame 写入 Google BigQuery 表格。 |
DataFrame.to_records([index, column_dtypes, ...]) |
将 DataFrame 转换为 NumPy 记录数组。 |
DataFrame.to_string([buf, columns, ...]) |
将 DataFrame 呈现为适合控制台的表格输出。 |
DataFrame.to_clipboard(*[, excel, sep]) |
将对象复制到系统剪贴板。 |
DataFrame.to_markdown([buf, mode, index, ...]) |
以 Markdown 友好的格式打印 DataFrame。 |
DataFrame.style |
返回一个 Styler 对象。 |
DataFrame.__dataframe__([nan_as_null, ...]) |
返回实现交换协议的数据框交换对象。 |
pandas.DataFrame
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.html
class pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None)
二维、大小可变、可能异构的表格数据。
数据结构还包含带标签的轴（行和列）。算术运算在行和列标签上对齐。可以将其视为 Series 对象的类似字典的容器。主要的 pandas 数据结构。
参数：
datandarray（结构化或同质）、可迭代对象、字典或 DataFrame
字典可以包含 Series、数组、常量、数据类或类似列表的对象。如果数据是字典，则列顺序遵循插入顺序。如果字典包含具有定义索引的 Series，则按其索引对齐。如果数据本身是 Series 或 DataFrame，则也会发生对齐。对 Series/DataFrame 输入进行对齐。
如果数据是字典列表，则列顺序遵循插入顺序。
index索引或类似数组
用于结果框架的索引。如果输入数据中没有索引信息且未提供索引，则默认为 RangeIndex。
columns索引或类似数组
当数据没有列标签时用于结果框架的列标签，默认为 RangeIndex(0, 1, 2, …, n)。如果数据包含列标签，将执行列选择。
dtype数据类型，默认为 None
要强制使用的数据类型。只允许使用单一数据类型。如果为 None，则推断。
copybool 或 None，默认为 None
复制输入数据。对于字典数据，默认值 None 的行为类似于 copy=True。对于 DataFrame 或 2 维 ndarray 输入，默认值 None 的行为类似于 copy=False。如果数据是包含一个或多个 Series 的字典（可能具有不同数据类型），copy=False 将确保不复制这些输入。
在版本 1.3.0 中更改。
另请参见
DataFrame.from_records
从元组构造，也可以是记录数组。
DataFrame.from_dict
从 Series、数组或字典的字典构建。
read_csv
读取逗号分隔值（csv）文件到 DataFrame。
read_table
从通用分隔文件读取到 DataFrame。
read_clipboard
从剪贴板中读取文本到 DataFrame。
注意事项
请参考用户指南获取更多信息。
示例
从字典构建 DataFrame。
>>> d = {'col1': [1, 2], 'col2': [3, 4]}
>>> df = pd.DataFrame(data=d)
>>> df
col1 col2
0 1 3
1 2 4
注意推断的数据类型为 int64。
>>> df.dtypes
col1 int64
col2 int64
dtype: object
为了强制使用单一数据类型：
>>> df = pd.DataFrame(data=d, dtype=np.int8)
>>> df.dtypes
col1 int8
col2 int8
dtype: object
从包含 Series 的字典构建 DataFrame：
>>> d = {'col1': [0, 1, 2, 3], 'col2': pd.Series([2, 3], index=[2, 3])}
>>> pd.DataFrame(data=d, index=[0, 1, 2, 3])
col1 col2
0 0 NaN
1 1 NaN
2 2 2.0
3 3 3.0
从 numpy ndarray 构建 DataFrame：
>>> df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
... columns=['a', 'b', 'c'])
>>> df2
a b c
0 1 2 3
1 4 5 6
2 7 8 9
从具有标记列的 numpy ndarray 构建 DataFrame：
>>> data = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)],
... dtype=[("a", "i4"), ("b", "i4"), ("c", "i4")])
>>> df3 = pd.DataFrame(data, columns=['c', 'a'])
...
>>> df3
c a
0 3 1
1 6 4
2 9 7
从数据类构建 DataFrame：
>>> from dataclasses import make_dataclass
>>> Point = make_dataclass("Point", [("x", int), ("y", int)])
>>> pd.DataFrame([Point(0, 0), Point(0, 3), Point(2, 3)])
x y
0 0 0
1 0 3
2 2 3
从 Series/DataFrame 构建 DataFrame：
>>> ser = pd.Series([1, 2, 3], index=["a", "b", "c"])
>>> df = pd.DataFrame(data=ser, index=["a", "c"])
>>> df
0
a 1
c 3
>>> df1 = pd.DataFrame([1, 2, 3], index=["a", "b", "c"], columns=["x"])
>>> df2 = pd.DataFrame(data=df1, index=["a", "c"])
>>> df2
x
a 1
c 3
属性
T |
DataFrame 的转置。 |
|---|---|
at |
访问行/列标签对的单个值。 |
attrs |
此数据集的全局属性字典。 |
axes |
返回表示 DataFrame 轴的列表。 |
columns |
DataFrame 的列标签。 |
dtypes |
返回 DataFrame 中的数据类型。 |
empty |
指示 Series/DataFrame 是否为空。 |
flags |
获取与此 pandas 对象关联的属性。 |
iat |
通过整数位置访问行/列对的单个值。 |
iloc |
(已弃用) 纯整数位置索引，根据位置进行选择。 |
index |
DataFrame 的索引（行标签）。 |
loc |
通过标签或布尔数组访问一组行和列。 |
ndim |
返回表示轴/数组维度数量的整数。 |
shape |
返回表示 DataFrame 维度的元组。 |
size |
返回表示此对象中元素数量的整数。 |
style |
返回一个 Styler 对象。 |
values |
返回 DataFrame 的 Numpy 表示。 |
方法
abs() |
返回每个元素的绝对数值的 Series/DataFrame。 |
|---|---|
add(other[, axis, level, fill_value]) |
获取 DataFrame 和其他对象的加法，逐元素进行操作（二元操作符 add）。 |
add_prefix(prefix[, axis]) |
使用字符串前缀为标签添加前缀。 |
add_suffix(suffix[, axis]) |
使用字符串后缀添加标签。 |
agg([func, axis]) |
使用一个或多个操作在指定的轴上进行聚合。 |
aggregate([func, axis]) |
使用一个或多个操作在指定的轴上进行聚合。 |
align(other[, join, axis, level, copy, ...]) |
使用指定的连接方法在它们的轴上对齐两个对象。 |
all([axis, bool_only, skipna]) |
返回是否所有元素都为 True，可能沿轴进行计算。 |
any(*[, axis, bool_only, skipna]) |
返回是否有任何元素为 True，可能沿轴进行计算。 |
apply(func[, axis, raw, result_type, args, ...]) |
沿着 DataFrame 的轴应用函数。 |
applymap(func[, na_action]) |
（已弃用）对 DataFrame 逐元素应用函数。 |
asfreq(freq[, method, how, normalize, ...]) |
将时间序列转换为指定的频率。 |
asof(where[, subset]) |
返回 where 之前最后一行（行），不包含任何 NaN。 |
assign(**kwargs) |
将新列分配给 DataFrame。 |
astype(dtype[, copy, errors]) |
将 pandas 对象转换为指定的 dtype dtype。 |
at_time(time[, asof, axis]) |
选择一天中特定时间的值（例如，上午 9:30）。 |
backfill(*[, axis, inplace, limit, downcast]) |
（已弃用）使用下一个有效观察值填充 NA/NaN 值以填补间隙。 |
between_time(start_time, end_time[, ...]) |
选择一天中特定时间之间的值（例如，上午 9:00-9:30）。 |
bfill(*[, axis, inplace, limit, limit_area, ...]) |
使用下一个有效观察值填充 NA/NaN 值以填补间隙。 |
bool |
（已弃用）返回单个元素 Series 或 DataFrame 的布尔值。 |
boxplot |
从 DataFrame 列制作箱线图。 |
clip |
在输入阈值处修剪值。 |
combine |
与另一个 DataFrame 进行列级组合。 |
combine_first |
使用其他位置相同位置的值更新空元素。 |
compare |
与另一个 DataFrame 进行比较并显示差异。 |
convert_dtypes |
使用支持pd.NA的数据类型将列转换为最佳可能的数据类型。 |
copy |
复制此对象的索引和数据。 |
corr |
计算列的成对相关性，排除 NA/null 值。 |
corrwith |
计算成对的相关性。 |
count |
计算每列或每行的非 NA 单元格。 |
cov |
计算列的成对协方差，排除 NA/null 值。 |
cummax |
返回 DataFrame 或 Series 轴上的累积最大值。 |
cummin |
返回 DataFrame 或 Series 轴上的累积最小值。 |
cumprod |
返回 DataFrame 或 Series 轴上的累积乘积。 |
cumsum |
返回 DataFrame 或 Series 轴上的累积和。 |
describe([percentiles, include, exclude]) |
生成描述性统计信息。 |
diff([periods, axis]) |
元素的第一个离散差异。 |
div(other[, axis, level, fill_value]) |
获取数据帧和其他数据的浮点除法，元素级别（二进制运算符 truediv）。 |
divide(other[, axis, level, fill_value]) |
获取数据帧和其他数据的浮点除法，元素级别（二进制运算符 truediv）。 |
dot(other) |
计算数据帧和其他数据之间的矩阵乘法。 |
drop([labels, axis, index, columns, level, ...]) |
从行或列中删除指定标签。 |
drop_duplicates([subset, keep, inplace, ...]) |
返回删除重复行的数据帧。 |
droplevel(level[, axis]) |
返回请求的索引/列级别删除后的 Series/DataFrame。 |
dropna(*[, axis, how, thresh, subset, ...]) |
移除缺失值。 |
duplicated([subset, keep]) |
返回表示重复行的布尔 Series。 |
eq(other[, axis, level]) |
获取数据帧和其他数据相等的元素（二进制运算符 eq）。 |
equals(other) |
测试两个对象是否包含相同的元素。 |
eval(expr, *[, inplace]) |
对描述数据帧列操作的字符串进行求值。 |
ewm([com, span, halflife, alpha, ...]) |
提供指数加权（EW）计算。 |
expanding([min_periods, axis, method]) |
提供扩展窗口计算。 |
explode(column[, ignore_index]) |
将列表的每个元素转换为一行，复制索引值。 |
ffill(*[, axis, inplace, limit, limit_area, ...]) |
通过将最后一个有效观察结果传播到下一个有效值来填充 NA/NaN 值。 |
fillna([value, method, axis, inplace, ...]) |
使用指定方法填充 NA/NaN 值。 |
filter([items, like, regex, axis]) |
根据指定的索引标签对数据帧行或列进行子集筛选。 |
first(offset) |
（已弃用）根据日期偏移量选择时间序列数据的初始时间段。 |
first_valid_index() |
返回第一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。 |
floordiv(other[, axis, level, fill_value]) |
获取数据帧和其他数据的整数除法，逐元素进行（二进制运算符 floordiv）。 |
from_dict(data[, orient, dtype, columns]) |
从数组样式或字典的字典构造数据帧。 |
from_records(data[, index, exclude, ...]) |
将结构化或记录 ndarray 转换为 DataFrame。 |
ge(other[, axis, level]) |
获取数据帧和其他数据的大于或等于，逐元素进行（二进制运算符 ge）。 |
get(key[, default]) |
从对象中获取给定键（例如：DataFrame 列）的项目。 |
groupby([by, axis, level, as_index, sort, ...]) |
使用映射器或列系列对数据帧进行分组。 |
gt(other[, axis, level]) |
获取数据帧和其他数据的大于，逐元素进行（二���制运算符 gt）。 |
head([n]) |
返回前 n 行。 |
hist([column, by, grid, xlabelsize, xrot, ...]) |
绘制数据帧列的直方图。 |
idxmax([axis, skipna, numeric_only]) |
返回请求轴上最大值的第一次出现的索引。 |
idxmin([axis, skipna, numeric_only]) |
返回请求轴上最小值的第一次出现的索引。 |
infer_objects([copy]) |
尝试为对象列推断更好的数据类型。 |
info([verbose, buf, max_cols, memory_usage, ...]) |
打印 DataFrame 的简明摘要。 |
insert(loc, column, value[, allow_duplicates]) |
在指定位置将列插入 DataFrame 中。 |
interpolate([method, axis, limit, inplace, ...]) |
使用插值方法填充 NaN 值。 |
isetitem(loc, value) |
在位置 loc 的列中设置给定值。 |
isin(values) |
DataFrame 中的每个元素是否包含在 values 中。 |
isna() |
检测缺失值。 |
isnull() |
DataFrame.isnull 是 DataFrame.isna 的别名。 |
items() |
迭代(column name, Series)对。 |
iterrows() |
以(index, Series)对的形式迭代 DataFrame 行。 |
itertuples([index, name]) |
以命名元组的形式迭代 DataFrame 行。 |
join(other[, on, how, lsuffix, rsuffix, ...]) |
连接另一个 DataFrame 的列。 |
keys() |
获取“信息轴”（详见索引）。 |
kurt([axis, skipna, numeric_only]) |
返回请求轴上的无偏峰度。 |
kurtosis([axis, skipna, numeric_only]) |
返回请求轴上的无偏峰度。 |
last(offset) |
（已弃用）根据日期偏移量选择时间序列数据的最后时间段。 |
last_valid_index() |
返回最后一个非 NA 值的索引，如果找不到非 NA 值，则返回 None。 |
le(other[, axis, level]) |
获取 DataFrame 和 other 的小于或等于，逐个元素（二元操作符 le）。 |
lt(other[, axis, level]) |
获取 DataFrame 和 other 的小于，逐个元素（二元操作符 lt）。 |
map(func[, na_action]) |
对 Dataframe 逐元素应用函数。 |
mask(cond[, other, inplace, axis, level]) |
替换条件为 True 的值。 |
max([axis, skipna, numeric_only]) |
返回所请求轴上值的最大值。 |
mean([axis, skipna, numeric_only]) |
返回所请求轴上值的平均值。 |
median([axis, skipna, numeric_only]) |
返回所请求轴上值的中位数。 |
melt([id_vars, value_vars, var_name, ...]) |
将 DataFrame 从宽格式转换为长格式，可选择保留标识符。 |
memory_usage([index, deep]) |
返回每列的内存使用量（以字节为单位）。 |
merge(right[, how, on, left_on, right_on, ...]) |
用数据库风格的连接将 DataFrame 或命名 Series 对象合并。 |
min([axis, skipna, numeric_only]) |
返回所请求轴上值的最小值。 |
mod(other[, axis, level, fill_value]) |
获取 dataframe 和其他元素的模数，逐元素（二进制运算符 mod）。 |
mode([axis, numeric_only, dropna]) |
获取沿所选轴的每个元素的众数。 |
mul(other[, axis, level, fill_value]) |
获取 dataframe 和其他元素的乘积，逐元素（二进制运算符 mul）。 |
multiply(other[, axis, level, fill_value]) |
获取 dataframe 和其他元素的乘积，逐元素（二进制运算符 mul）。 |
ne(other[, axis, level]) |
获取 dataframe 和其他元素的不等于，逐元素（二进制运算符 ne）。 |
nlargest(n, columns[, keep]) |
按降序排列的列返回前 n 行。 |
notna() |
检测存在（非缺失）的值。 |
notnull() |
DataFrame.notnull 是 DataFrame.notna 的别名。 |
nsmallest(n, columns[, keep]) |
返回按升序排列的列中的前 n 行。 |
nunique([axis, dropna]) |
计算指定轴上的不同元素数量。 |
pad(*[, axis, inplace, limit, downcast]) |
（已弃用）通过将上一个有效观测值传播到下一个有效值来填充 NA/NaN 值。 |
pct_change([periods, fill_method, limit, freq]) |
当前元素与先前元素之间的分数变化。 |
pipe(func, *args, **kwargs) |
应用期望 Series 或 DataFrames 的链式函数。 |
pivot(*, columns[, index, values]) |
返回按给定索引/列值组织的重塑数据帧。 |
pivot_table([values, index, columns, ...]) |
创建一个类似电子表格的透视表，作为数据帧。 |
pop(item) |
返回项目并从数据帧中删除。 |
pow(other[, axis, level, fill_value]) |
获取数据帧和其他元素的指数幂，逐元素进行计算（二元运算符 pow）。 |
prod([axis, skipna, numeric_only, min_count]) |
返回请求轴上值的乘积。 |
product([axis, skipna, numeric_only, min_count]) |
返回请求轴上值的乘积。 |
quantile([q, axis, numeric_only, ...]) |
返回请求轴上给定分位数处的值。 |
query(expr, *[, inplace]) |
使用布尔表达式查询数据帧的列。 |
radd(other[, axis, level, fill_value]) |
获取数据帧和其他元素的加法，逐元素进行计算（二元运算符 radd）。 |
rank([axis, method, numeric_only, ...]) |
沿轴计算数值数据排名（1 到 n）。 |
rdiv(other[, axis, level, fill_value]) |
获取数据框和其他数据的浮点除法，按元素计算（二元运算符 rtruediv）。 |
reindex([labels, index, columns, axis, ...]) |
使用可选的填充逻辑将 DataFrame 调整到新索引。 |
reindex_like(other[, method, copy, limit, ...]) |
返回与其他对象具有匹配索引的对象。 |
rename([mapper, index, columns, axis, copy, ...]) |
重命名列或索引标签。 |
rename_axis([mapper, index, columns, axis, ...]) |
设置索引或列的轴名称。 |
reorder_levels(order[, axis]) |
使用输入顺序重新排列索引级别。 |
replace([to_replace, value, inplace, limit, ...]) |
用给定值替换 to_replace 中的值。 |
resample(rule[, axis, closed, label, ...]) |
重新采样时间序列数据。 |
reset_index([level, drop, inplace, ...]) |
重置索引，或其级别。 |
rfloordiv(other[, axis, level, fill_value]) |
获取数据框和其他数据的整数除法，按元素计算（二元运算符 rfloordiv）。 |
rmod(other[, axis, level, fill_value]) |
获取数据框和其他数据的模除法，按元素计算（二元运算符 rmod）。 |
rmul(other[, axis, level, fill_value]) |
获取数据框和其他数据的乘法，按元素计算（二元运算符 rmul）。 |
rolling(window[, min_periods, center, ...]) |
提供滚动窗口计算。 |
round([decimals]) |
将 DataFrame 四舍五入到可变数量的小数位数。 |
rpow(other[, axis, level, fill_value]) |
获取数据框和其他数据的指数幂，按元素计算（二元运算符 rpow）。 |
rsub(other[, axis, level, fill_value]) |
获取数据帧和其他数据的减法，逐元素进行（二进制运算符 rsub）。 |
rtruediv(other[, axis, level, fill_value]) |
获取数据帧和其他数据的浮点除法，逐元素进行（二进制运算符 rtruediv）。 |
sample([n, frac, replace, weights, ...]) |
从对象的轴中返回随机样本。 |
select_dtypes([include, exclude]) |
根据列数据类型返回数据帧列的子集。 |
sem([axis, skipna, ddof, numeric_only]) |
返回请求轴上的无偏均值标准误差。 |
set_axis(labels, *[, axis, copy]) |
将所需索引分配给给定轴。 |
set_flags(*[, copy, allows_duplicate_labels]) |
返回具有更新标志的新对象。 |
set_index(keys, *[, drop, append, inplace, ...]) |
使用现有列设置数据帧索引。 |
shift([periods, freq, axis, fill_value, suffix]) |
将索引按所需周期数移动，可选时间频率。 |
skew([axis, skipna, numeric_only]) |
返回请求轴上的无偏偏斜度。 |
sort_index(*[, axis, level, ascending, ...]) |
按标签（沿轴）对对象进行排序。 |
sort_values(by, *[, axis, ascending, ...]) |
沿着任一轴的值排序。 |
squeeze([axis]) |
将一维轴对象压缩为标量。 |
stack([level, dropna, sort, future_stack]) |
将列中的指定级别堆叠到索引中。 |
std([axis, skipna, ddof, numeric_only]) |
返回请求轴上的样本标准偏差。 |
sub(other[, axis, level, fill_value]) |
获取 DataFrame 和其他对象的减法，逐元素操作（二元减法运算符）。 |
subtract(other[, axis, level, fill_value]) |
获取 DataFrame 和其他对象的减法，逐元素操作（二元减法运算符）。 |
sum([axis, skipna, numeric_only, min_count]) |
沿请求的轴返回值的总和。 |
swapaxes(axis1, axis2[, copy]) |
（已弃用）交换轴并适当地交换值轴。 |
swaplevel([i, j, axis]) |
在 MultiIndex 中交换级别 i 和 j。 |
tail([n]) |
返回最后 n 行。 |
take(indices[, axis]) |
返回沿轴的给定 位置 索引的元素。 |
to_clipboard(*[, excel, sep]) |
将对象复制到系统剪贴板。 |
to_csv([path_or_buf, sep, na_rep, ...]) |
将对象写入逗号分隔值（csv）文件。 |
to_dict([orient, into, index]) |
将 DataFrame 转换为字典。 |
to_excel(excel_writer, *[, sheet_name, ...]) |
将对象写入 Excel 表格。 |
to_feather(path, **kwargs) |
将 DataFrame 写入二进制 Feather 格式。 |
to_gbq(destination_table, *[, project_id, ...]) |
（已弃用）将 DataFrame 写入 Google BigQuery 表。 |
to_hdf(path_or_buf, *, key[, mode, ...]) |
使用 HDFStore 将包含的数据写入 HDF5 文件。 |
to_html([buf, columns, col_space, header, ...]) |
将 DataFrame 渲染为 HTML 表格。 |
to_json([path_or_buf, orient, date_format, ...]) |
将对象转换为 JSON 字符串。 |
to_latex([buf, columns, header, index, ...]) |
将对象呈现为 LaTeX 表格、长表格或嵌套表格。 |
to_markdown([buf, mode, index, storage_options]) |
以 Markdown 友好的格式打印 DataFrame。 |
to_numpy([dtype, copy, na_value]) |
将 DataFrame 转换为 NumPy 数组。 |
to_orc([path, engine, index, engine_kwargs]) |
将 DataFrame 写入 ORC 格式。 |
to_parquet([path, engine, compression, ...]) |
将 DataFrame 写入二进制 parquet 格式。 |
to_period([freq, axis, copy]) |
将 DataFrame 从 DatetimeIndex 转换为 PeriodIndex。 |
to_pickle(path, *[, compression, protocol, ...]) |
将对象序列化（pickle）到文件。 |
to_records([index, column_dtypes, index_dtypes]) |
将 DataFrame 转换为 NumPy 记录数组。 |
to_sql(name, con, *[, schema, if_exists, ...]) |
将存储在 DataFrame 中的记录写入 SQL 数据库。 |
to_stata(path, *[, convert_dates, ...]) |
将 DataFrame 对象导出为 Stata dta 格式。 |
to_string([buf, columns, col_space, header, ...]) |
将 DataFrame 呈现为友好的控制台表格输出。 |
to_timestamp([freq, how, axis, copy]) |
转换为时间戳的 DatetimeIndex，位于周期的开始。 |
to_xarray() |
从 pandas 对象返回一个 xarray 对象。 |
to_xml([path_or_buffer, index, root_name, ...]) |
将 DataFrame 呈现为 XML 文档。 |
transform(func[, axis]) |
在自身上调用func，生成一个与自身轴形状相同的 DataFrame。 |
transpose(*args[, copy]) |
转置索引和列。 |
truediv(other[, axis, level, fill_value]) |
获取数据帧和其他的浮点除法，按元素进行操作（二元运算符 truediv）。 |
truncate([before, after, axis, copy]) |
截断 Series 或 DataFrame 在某个索引值之前和之后。 |
tz_convert(tz[, axis, level, copy]) |
将 tz-感知轴转换为目标时区。 |
tz_localize(tz[, axis, level, copy, ...]) |
将 Series 或 DataFrame 的 tz-未知索引本地化到目标时区。 |
unstack([level, fill_value, sort]) |
透视（必须是分层的）索引标签的一级。 |
update(other[, join, overwrite, ...]) |
使用另一个 DataFrame 的非 NA 值在原地进行修改。 |
value_counts([subset, normalize, sort, ...]) |
返回一个包含 DataFrame 中每个不同行的频率的 Series。 |
var([axis, skipna, ddof, numeric_only]) |
沿请求的轴返回无偏差方差。 |
where(cond[, other, inplace, axis, level]) |
在条件为 False 时替换值。 |
xs(key[, axis, level, drop_level]) |
从 Series/DataFrame 返回横截面。 |
pandas.DataFrame.index
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.index.html
DataFrame.index
DataFrame 的索引（行标签）。
DataFrame 的索引是一系列标签，用于标识每一行。这些标签可以是整数、字符串或任何其他可哈希类型。索引用于基于标签的访问和对齐，并且可以使用该属性进行访问或修改。
返回：
pandas.Index
DataFrame 的索引标签。
参见
DataFrame.columns
DataFrame 的列标签。
DataFrame.to_numpy
将 DataFrame 转换为 NumPy 数组。
示例
>>> df = pd.DataFrame({'Name': ['Alice', 'Bob', 'Aritra'],
... 'Age': [25, 30, 35],
... 'Location': ['Seattle', 'New York', 'Kona']},
... index=([10, 20, 30]))
>>> df.index
Index([10, 20, 30], dtype='int64')
在这个例子中，我们创建了一个包含姓名、年龄和位置信息的 3 行 3 列的 DataFrame。我们将索引标签设置为整数 10、20 和 30。然后我们访问 DataFrame 的索引属性，该属性返回一个包含索引标签的 Index 对象。
>>> df.index = [100, 200, 300]
>>> df
Name Age Location
100 Alice 25 Seattle
200 Bob 30 New York
300 Aritra 35 Kona
在这个例子中，我们通过将一个新的标签列表赋给索引属性来修改 DataFrame 的索引标签。然后 DataFrame 将使用新标签进行更新，输出显示修改后的 DataFrame。
pandas.DataFrame.columns
pandas.pydata.org/docs/reference/api/pandas.DataFrame.columns.html
DataFrame.columns
DataFrame 的列标签。
示例
>>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
>>> df
A B
0 1 3
1 2 4
>>> df.columns
Index(['A', 'B'], dtype='object')
pandas.DataFrame.dtypes
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.dtypes.html
property DataFrame.dtypes
返回 DataFrame 中的数据类型。
这将返回一个 Series，其中包含每列的数据类型。结果的索引是原始 DataFrame 的列。具有混合类型的列以 object 类型存储。更多信息请参见用户指南。
返回结果：
pandas.Series
每列的数据类型。
示例
>>> df = pd.DataFrame({'float': [1.0],
... 'int': [1],
... 'datetime': [pd.Timestamp('20180310')],
... 'string': ['foo']})
>>> df.dtypes
float float64
int int64
datetime datetime64[ns]
string object
dtype: object
pandas.DataFrame.info
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.info.html
DataFrame.info(verbose=None, buf=None, max_cols=None, memory_usage=None, show_counts=None)
打印 DataFrame 的简明摘要。
这个方法打印关于 DataFrame 的信息，包括索引数据类型和列，非空值和内存使用情况。
参数:
verbosebool, optional
是否打印完整摘要。默认情况下，遵循pandas.options.display.max_info_columns中的设置。
buf可写缓冲区，默认为 sys.stdout
输出的目标位置。默认情况下，输出打印到 sys.stdout。如果需要进一步处理输出，请传递一个可写缓冲区。
max_colsint, optional
何时从冗长输出切换到截断输出。如果 DataFrame 的列数超过 max_cols 列，则使用截断输出。默认情况下，使用pandas.options.display.max_info_columns中的设置。
memory_usagebool, str, optional
指定是否应显示 DataFrame 元素（包括索引）的总内存使用情况。默认情况下，这遵循pandas.options.display.memory_usage设置。
True 始终显示内存使用情况。False 从不显示内存使用情况。值为“deep”等同于“使用深度内省的 True”。内存使用情况以人类可读的单位（基于 2 的表示）显示。没有深度内省时，基于列数据类型和行数进行内存估算，假设值对应的数据类型消耗相同的内存量。通过深度内存内省，进行实际的内存使用量计算，但会消耗计算资源。有关更多详细信息，请参阅常见问题解答。
show_countsbool, optional
是否显示非空计数。默认情况下，仅在 DataFrame 小于pandas.options.display.max_info_rows和pandas.options.display.max_info_columns时才显示。True 始终显示计数，False 从不显示计数。
返回:
None
这个方法打印 DataFrame 的摘要并返回 None。
另请参阅
DataFrame.describe
生成 DataFrame 列的描述性统计信息。
DataFrame.memory_usage
DataFrame 列的内存使用情况。
示例
>>> int_values = [1, 2, 3, 4, 5]
>>> text_values = ['alpha', 'beta', 'gamma', 'delta', 'epsilon']
>>> float_values = [0.0, 0.25, 0.5, 0.75, 1.0]
>>> df = pd.DataFrame({"int_col": int_values, "text_col": text_values,
... "float_col": float_values})
>>> df
int_col text_col float_col
0 1 alpha 0.00
1 2 beta 0.25
2 3 gamma 0.50
3 4 delta 0.75
4 5 epsilon 1.00
打印所有列的信息:
>>> df.info(verbose=True)
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 int_col 5 non-null int64
1 text_col 5 non-null object
2 float_col 5 non-null float64
dtypes: float64(1), int64(1), object(1)
memory usage: 248.0+ bytes
打印列计数及其数据类型的摘要，但不包括每列信息:
>>> df.info(verbose=False)
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Columns: 3 entries, int_col to float_col
dtypes: float64(1), int64(1), object(1)
memory usage: 248.0+ bytes
将 DataFrame.info 的输出管道到缓冲区而不是 sys.stdout，获取缓冲区内容并写入文本文件:
>>> import io
>>> buffer = io.StringIO()
>>> df.info(buf=buffer)
>>> s = buffer.getvalue()
>>> with open("df_info.txt", "w",
... encoding="utf-8") as f:
... f.write(s)
260
memory_usage 参数允许深度内省模式，特别适用于大型 DataFrame 和精细调整内存优化:
>>> random_strings_array = np.random.choice(['a', 'b', 'c'], 10 ** 6)
>>> df = pd.DataFrame({
... 'column_1': np.random.choice(['a', 'b', 'c'], 10 ** 6),
... 'column_2': np.random.choice(['a', 'b', 'c'], 10 ** 6),
... 'column_3': np.random.choice(['a', 'b', 'c'], 10 ** 6)
... })
>>> df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000000 entries, 0 to 999999
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 column_1 1000000 non-null object
1 column_2 1000000 non-null object
2 column_3 1000000 non-null object
dtypes: object(3)
memory usage: 22.9+ MB
>>> df.info(memory_usage='deep')
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000000 entries, 0 to 999999
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 column_1 1000000 non-null object
1 column_2 1000000 non-null object
2 column_3 1000000 non-null object
dtypes: object(3)
memory usage: 165.9 MB
pandas.DataFrame.select_dtypes
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.select_dtypes.html
DataFrame.select_dtypes(include=None, exclude=None)
基于列数据类型选择数据框的子集。
参数：
include, exclude标量或类似列表
要包括/排除的数据类型或字符串的选择。这些参数中至少必须提供一个。
返回：
数据框
包括include中数据类型并排除exclude中数据类型的数据框子集。
引发：
ValueError
-
如果
include和exclude都为空 -
如果
include和exclude有重叠元素 -
如果传入任何一种字符串数据类型。
另请参见
DataFrame.dtypes
返回每列的数据类型的 Series。
注意
-
要选择所有数值类型，请使用
np.number或'number' -
要选择字符串，必须使用
object数据类型，但请注意，这将返回所有对象数据类型列 -
要选择日期时间，请使用
np.datetime64，'datetime'或'datetime64' -
要选择时间增量，请使用
np.timedelta64，'timedelta'或'timedelta64' -
要选择 Pandas 分类数据类型，请使用
'category' -
要选择 Pandas 带时区的日期时间数据类型，请使用
'datetimetz'或'datetime64[ns, tz]'
示例
>>> df = pd.DataFrame({'a': [1, 2] * 3,
... 'b': [True, False] * 3,
... 'c': [1.0, 2.0] * 3})
>>> df
a b c
0 1 True 1.0
1 2 False 2.0
2 1 True 1.0
3 2 False 2.0
4 1 True 1.0
5 2 False 2.0
>>> df.select_dtypes(include='bool')
b
0 True
1 False
2 True
3 False
4 True
5 False
>>> df.select_dtypes(include=['float64'])
c
0 1.0
1 2.0
2 1.0
3 2.0
4 1.0
5 2.0
>>> df.select_dtypes(exclude=['int64'])
b c
0 True 1.0
1 False 2.0
2 True 1.0
3 False 2.0
4 True 1.0
5 False 2.0
pandas.DataFrame.values
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.values.html
property DataFrame.values
返回 DataFrame 的 Numpy 表示。
警告
我们建议使用DataFrame.to_numpy()。
仅返回 DataFrame 中的值，轴标签将被移除。
返回：
numpy.ndarray
DataFrame 的值。
另请参阅
DataFrame.to_numpy
推荐使用此方法的替代方法。
DataFrame.index
检索索引标签。
DataFrame.columns
检索列名。
注意
dtype 将是一个较低的公共分母 dtype（隐式向上转换）；也就是说，如果 dtypes（甚至是数值类型）混合，将选择适应所有类型的那个。如果您不处理块，请谨慎使用此选项。
例如，如果 dtypes 是 float16 和 float32，则 dtype 将向上转换为 float32。如果 dtypes 是 int32 和 uint8，则 dtype 将向上转换为 int32。根据numpy.find_common_type()约定，混合 int64 和 uint64 将导致 float64 dtype。
示例
所有列都是相同类型（例如，int64）的 DataFrame 将导致相同类型的数组。
>>> df = pd.DataFrame({'age': [ 3, 29],
... 'height': [94, 170],
... 'weight': [31, 115]})
>>> df
age height weight
0 3 94 31
1 29 170 115
>>> df.dtypes
age int64
height int64
weight int64
dtype: object
>>> df.values
array([[ 3, 94, 31],
[ 29, 170, 115]])
混合类型列的 DataFrame（例如，str/object，int64，float32）将导致一个能容纳这些混合类型的最广泛类型的 ndarray（例如，object）。
>>> df2 = pd.DataFrame([('parrot', 24.0, 'second'),
... ('lion', 80.5, 1),
... ('monkey', np.nan, None)],
... columns=('name', 'max_speed', 'rank'))
>>> df2.dtypes
name object
max_speed float64
rank object
dtype: object
>>> df2.values
array([['parrot', 24.0, 'second'],
['lion', 80.5, 1],
['monkey', nan, None]], dtype=object)
pandas.DataFrame.axes
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.axes.html
property DataFrame.axes
返回表示 DataFrame 轴的列表。
它只有行轴标签和列轴标签作为其唯一成员。它们按顺序返回。
示例
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.axes
[RangeIndex(start=0, stop=2, step=1), Index(['col1', 'col2'],
dtype='object')]
pandas.DataFrame.ndim
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.ndim.html
property DataFrame.ndim
返回一个表示轴数 / 数组维度的整数。
如果是 Series，则返回 1。否则，如果是 DataFrame，则返回 2。
另请参阅
ndarray.ndim
数组维度的数量。
示例
>>> s = pd.Series({'a': 1, 'b': 2, 'c': 3})
>>> s.ndim
1
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.ndim
2
pandas.DataFrame.size
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.size.html
property DataFrame.size
返回一个表示此对象中元素数量的整数。
如果是 Series，则返回行数。否则，如果是 DataFrame，则返回行数乘以列数。
另请参阅
ndarray.size
数组中元素的数量。
示例
>>> s = pd.Series({'a': 1, 'b': 2, 'c': 3})
>>> s.size
3
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.size
4
pandas.DataFrame.shape
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.shape.html
property DataFrame.shape
返回表示 DataFrame 维度的元组。
另请参阅
ndarray.shape
数组维度的元组。
示例
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df.shape
(2, 2)
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4],
... 'col3': [5, 6]})
>>> df.shape
(2, 3)
pandas.DataFrame.memory_usage
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.memory_usage.html
DataFrame.memory_usage(index=True, deep=False)
返回每列的内存使用量（以字节为单位）。
内存使用量可以选择包括索引和对象 dtype 元素的贡献。
默认情况下，此值在 DataFrame.info 中显示。可以通过将pandas.options.display.memory_usage设置为 False 来抑制此值。
参数：
indexbool，默认为 True
指定是否在返回的 Series 中包括 DataFrame 索引的内存使用量。如果index=True，则索引的内存使用量是输出中的第一项。
deepbool，默认为 False
如果为 True，则通过询问对象 dtype 以获取系统级内存消耗并将其包含在返回值中，深入检查数据。
返回：
Series
其索引为原始列名，其值为每列的内存使用量（以字节为单位）的 Series。
另请参见
ndarray 元素消耗的总字节数。
Series.memory_usage
Series 消耗的字节数。
Categorical
用于具有许多重复值的字符串值的内存高效数组。
DataFrame.info
DataFrame 的简明摘要。
注意
查看常见问题解答以获取更多详细信息。
示例
>>> dtypes = ['int64', 'float64', 'complex128', 'object', 'bool']
>>> data = dict([(t, np.ones(shape=5000, dtype=int).astype(t))
... for t in dtypes])
>>> df = pd.DataFrame(data)
>>> df.head()
int64 float64 complex128 object bool
0 1 1.0 1.0+0.0j 1 True
1 1 1.0 1.0+0.0j 1 True
2 1 1.0 1.0+0.0j 1 True
3 1 1.0 1.0+0.0j 1 True
4 1 1.0 1.0+0.0j 1 True
>>> df.memory_usage()
Index 128
int64 40000
float64 40000
complex128 80000
object 40000
bool 5000
dtype: int64
>>> df.memory_usage(index=False)
int64 40000
float64 40000
complex128 80000
object 40000
bool 5000
dtype: int64
默认情况下忽略对象 dtype 列的内存占用量：
>>> df.memory_usage(deep=True)
Index 128
int64 40000
float64 40000
complex128 80000
object 180000
bool 5000
dtype: int64
使用分类数据类型（Categorical）可以高效存储具有许多重复值的对象 dtype 列。
>>> df['object'].astype('category').memory_usage(deep=True)
5244
pandas.DataFrame.empty
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.empty.html
property DataFrame.empty
指示 Series/DataFrame 是否为空。
如果 Series/DataFrame 完全为空（没有任何项），则返回 True，意味着任何轴的长度为 0。
返回：
布尔值
如果 Series/DataFrame 为空，则返回 True，否则返回 False。
参见
Series.dropna
返回不含空值的系列。
DataFrame.dropna
返回删除给定轴上标签的 DataFrame，其中（所有或任何）数据缺失。
注意事项
如果 Series/DataFrame 只包含 NaN，则仍不被视为空。请参见下面的示例。
示例
一个实际空的 DataFrame 示例。请注意索引是空的：
>>> df_empty = pd.DataFrame({'A' : []})
>>> df_empty
Empty DataFrame
Columns: [A]
Index: []
>>> df_empty.empty
True
如果我们的 DataFrame 中只有 NaN，则不被视为空！我们需要删除 NaN 来使 DataFrame 为空：
>>> df = pd.DataFrame({'A' : [np.nan]})
>>> df
A
0 NaN
>>> df.empty
False
>>> df.dropna().empty
True
>>> ser_empty = pd.Series({'A' : []})
>>> ser_empty
A []
dtype: object
>>> ser_empty.empty
False
>>> ser_empty = pd.Series()
>>> ser_empty.empty
True
pandas.DataFrame.set_flags
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.set_flags.html
DataFrame.set_flags(*, copy=False, allows_duplicate_labels=None)
返回一个具有更新标志的新对象。
参数：
copybool，默认为 False
指定是否应该对对象进行复制。
注意
在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在未来的 pandas 版本中被移除。
通过启用写时复制pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。
allows_duplicate_labelsbool，可选
返回的对象是否允许重复标签。
返回：
Series 或 DataFrame
与调用者相同类型。
另请参阅
DataFrame.attrs
应用于此数据集的全局元数据。
DataFrame.flags
应用于此对象的全局标志。
注意
此方法返回一个查看输入数据相同数据的新对象。修改输入或输出值将反映在另一个中。
该方法旨在用于方法链。
“Flags”与“metadata”不同。Flags 反映了 pandas 对象（Series 或 DataFrame）的属性。Metadata 指的是数据集的属性，应存储在DataFrame.attrs中。
示例
>>> df = pd.DataFrame({"A": [1, 2]})
>>> df.flags.allows_duplicate_labels
True
>>> df2 = df.set_flags(allows_duplicate_labels=False)
>>> df2.flags.allows_duplicate_labels
False
pandas.DataFrame.astype
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.astype.html
DataFrame.astype(dtype, copy=None, errors='raise')
将 pandas 对象转换为指定的数据类型dtype。
参数：
dtypestr，数据类型，Series 或列名 -> 数据类型的映射
使用字符串、numpy.dtype、pandas.ExtensionDtype 或 Python 类型将整个 pandas 对象转换为相同类型。或者使用映射，例如{col: dtype, …}，其中 col 是列标签，dtype 是 numpy.dtype 或 Python 类型，用于将一个或多个 DataFrame 的列转换为特定类型。
copybool，默认为 True
当copy=True时返回副本（设置copy=False时要非常小心，因为值的更改可能传播到其他 pandas 对象）。
注意
在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法将使用延迟复制机制来推迟复制并忽略 copy 关键字。在未来的 pandas 版本中，将删除 copy 关键字。
通过启用写时复制pd.options.mode.copy_on_write = True，您已经可以获得未来的行为和改进。
errors，默认为‘raise’
控制对于提供的数据类型的无效数据引发异常的行为。
-
raise：允许引发异常 -
ignore：忽略异常。出错时返回原始对象。
返回：
与调用者相同的类型
另请参阅
to_datetime
将参数转换为日期时间。
to_timedelta
将参数转换为时间间隔。
to_numeric
将参数转换为数值类型。
将 numpy 数组转换为指定类型。
注意
2.0.0 版本更改：使用astype从时区无关的数据类型转换为时区感知的数据类型将引发异常。请改用Series.dt.tz_localize()。
示例
创建一个 DataFrame：
>>> d = {'col1': [1, 2], 'col2': [3, 4]}
>>> df = pd.DataFrame(data=d)
>>> df.dtypes
col1 int64
col2 int64
dtype: object
将���有列转换为 int32：
>>> df.astype('int32').dtypes
col1 int32
col2 int32
dtype: object
使用字典将 col1 转换为 int32：
>>> df.astype({'col1': 'int32'}).dtypes
col1 int32
col2 int64
dtype: object
创建一个系列：
>>> ser = pd.Series([1, 2], dtype='int32')
>>> ser
0 1
1 2
dtype: int32
>>> ser.astype('int64')
0 1
1 2
dtype: int64
转换为分类类型：
>>> ser.astype('category')
0 1
1 2
dtype: category
Categories (2, int32): [1, 2]
使用自定义排序将其转换为有序分类类型：
>>> from pandas.api.types import CategoricalDtype
>>> cat_dtype = CategoricalDtype(
... categories=[2, 1], ordered=True)
>>> ser.astype(cat_dtype)
0 1
1 2
dtype: category
Categories (2, int64): [2 < 1]
创建一个日期系列：
>>> ser_date = pd.Series(pd.date_range('20200101', periods=3))
>>> ser_date
0 2020-01-01
1 2020-01-02
2 2020-01-03
dtype: datetime64[ns]
pandas.DataFrame.convert_dtypes
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.convert_dtypes.html
DataFrame.convert_dtypes(infer_objects=True, convert_string=True, convert_integer=True, convert_boolean=True, convert_floating=True, dtype_backend='numpy_nullable')
使用支持pd.NA的 dtype 将列转换为最佳可能的 dtype。
参数：
infer_objectsbool，默认为 True
是否应将对象 dtype 转换为最佳可能的类型。
convert_stringbool，默认为 True
是否应将对象 dtype 转换为StringDtype()。
convert_integerbool，默认为 True
是否可以将参数转换为整数扩展类型。
convert_booleanbool，默认为 True
是否应将对象 dtype 转换为BooleanDtypes()。
convert_floatingbool，默认为 True
是否可以将对象转换为浮点扩展类型。如果convert_integer也为 True，则如果浮点数可以被忠实地转换为整数，则优先选择整数 dtype。
dtype_backend，默认为‘numpy_nullable’
应用于结果DataFrame的后端数据类型（仍处于实验阶段）。行为如下：
-
"numpy_nullable": 返回由可空 dtype 支持的DataFrame（默认）。 -
"pyarrow": 返回由 pyarrow 支持的可空ArrowDtypeDataFrame。
版本 2.0 中新增。
返回：
Series 或 DataFrame
具有新 dtype 的输入对象的副本。
另请参见
infer_objects
推断对象的 dtype。
to_datetime
将参数转换为日期时间。
to_timedelta
将参数转换为时间间隔。
to_numeric
将参数转换为数值类型���
注意
默认情况下，convert_dtypes将尝试将 Series（或 DataFrame 中的每个 Series）转换为支持pd.NA的 dtype。通过使用选项convert_string、convert_integer、convert_boolean和convert_floating，可以分别关闭对StringDtype、整数扩展类型、BooleanDtype或浮点扩展类型的单独转换。
对于对象 dtype 的列，如果infer_objects为True，则使用正常 Series/DataFrame 构建期间的推断规则。然后，如果可能，转换为StringDtype、BooleanDtype或适当的整数或浮点扩展类型，否则保留为object。
如果 dtype 为整数，则转换为适当的整数扩展类型。
如果 dtype 为数值，并且由所有整数组成，则转换为适当的整数扩展类型。否则，转换为适当的浮点扩展类型。
将来，随着支持pd.NA的新数据类型的添加，此方法的结果将会改变以支持这些新数据类型。
例子
>>> df = pd.DataFrame(
... {
... "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),
... "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
... "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")),
... "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")),
... "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")),
... "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),
... }
... )
从具有默认数据类型的 DataFrame 开始。
>>> df
a b c d e f
0 1 x True h 10.0 NaN
1 2 y False i NaN 100.5
2 3 z NaN NaN 20.0 200.0
>>> df.dtypes
a int32
b object
c object
d object
e float64
f float64
dtype: object
将 DataFrame 转换为使用最佳可能的数据类型。
>>> dfn = df.convert_dtypes()
>>> dfn
a b c d e f
0 1 x True h 10 <NA>
1 2 y False i <NA> 100.5
2 3 z <NA> <NA> 20 200.0
>>> dfn.dtypes
a Int32
b string[python]
c boolean
d string[python]
e Int64
f Float64
dtype: object
从一系列字符串和由np.nan表示的缺失数据开始。
>>> s = pd.Series(["a", "b", np.nan])
>>> s
0 a
1 b
2 NaN
dtype: object
获得一个数据类型为StringDtype的 Series。
>>> s.convert_dtypes()
0 a
1 b
2 <NA>
dtype: string
pandas.DataFrame.infer_objects
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.infer_objects.html
DataFrame.infer_objects(copy=None)
尝试为对象列推断更好的 dtype。
尝试对对象类型列进行软转换，保持非对象和无法转换的列不变。推断规则与正常 Series/DataFrame 构建期间的规则相同。
参数：
copybool，默认为 True
是否为非对象或不可推断的列或 Series 进行复制。
注意
在 pandas 3.0 中，copy 关键字的行为将发生变化。写时复制将默认启用，这意味着所有带有 copy 关键字的方法都将使用延迟复制机制来推迟复制并忽略 copy 关键字。copy 关键字将在 pandas 的未来版本中被移除。
通过启用写时复制pd.options.mode.copy_on_write = True，您已经可以获取未来的行为和改进。
返回：
与输入对象相同的类型
另请参见
将参数转换为日期时间。
将参数转换为时间增量。
将参数转换为数值类型。
将参数转换为最佳可能的 dtype。
示例
>>> df = pd.DataFrame({"A": ["a", 1, 2, 3]})
>>> df = df.iloc[1:]
>>> df
A
1 1
2 2
3 3
>>> df.dtypes
A object
dtype: object
>>> df.infer_objects().dtypes
A int64
dtype: object
pandas.DataFrame.copy
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.copy.html
DataFrame.copy(deep=True)
拷贝此对象的索引和数据。
当deep=True（默认）时，将创建一个新对象，其中包含调用对象的数据和索引的副本。对副本的数据或索引的修改不会反映在原始对象中（见下面的注意事项）。
当deep=False时，将创建一个新对象，而不会拷贝调用对象的数据或索引（只会拷贝数据和索引的引用）。对原始数据的任何更改都会反映在浅拷贝中（反之亦然）。
注意：
如上所述，deep=False 的行为将在 pandas 3.0 中发生变化。Copy-on-Write 将默认启用，这意味着返回的“浅”拷贝仍然避免进行急切的拷贝，但对原始数据的更改将不再反映在浅拷贝中（���之亦然）。相反，它使用一种延迟（懒惰）拷贝机制，只有在对原始或浅拷贝进行任何更改时才会拷贝数据。
通过启用 copy on write pd.options.mode.copy_on_write = True，您可以获得未来的行为和改进。
参数：
deep 布尔值，默认为 True
进行深拷贝，包括数据和索引的拷贝。使用deep=False时，索引和数据都不会被拷贝。
返回：
Series 或 DataFrame
对象类型与调用者匹配。
注意事项
当deep=True时，数据会被拷贝，但实际的 Python 对象不会被递归地拷贝，只会拷贝对象的引用。这与标准库中的 copy.deepcopy 相反，后者会递归地拷贝对象数据（见下面的示例）。
当deep=True时，Index 对象会被拷贝，但基础的 numpy 数组由于性能原因不会被拷贝。由于 Index 是不可变的，基础数据可以安全共享，不需要拷贝。
由于 pandas 不是线程安全的，请在多线程环境中拷贝时查看注意事项。
当 pandas 配置中的 copy_on_write 设置为 True 时，即使deep=False，copy_on_write 配置也会生效。这意味着对拷贝数据的任何更改都会在写入时创建数据的新副本（反之亦然）。对原始变量或拷贝变量的更改不会反映在对方中。查看 Copy_on_Write 获取更多信息。
示例
>>> s = pd.Series([1, 2], index=["a", "b"])
>>> s
a 1
b 2
dtype: int64
>>> s_copy = s.copy()
>>> s_copy
a 1
b 2
dtype: int64
浅拷贝与默认（深拷贝）的区别：
>>> s = pd.Series([1, 2], index=["a", "b"])
>>> deep = s.copy()
>>> shallow = s.copy(deep=False)
浅拷贝与原始数据和索引共享。
>>> s is shallow
False
>>> s.values is shallow.values and s.index is shallow.index
True
深拷贝拥有自己的数据和索引的副本。
>>> s is deep
False
>>> s.values is deep.values or s.index is deep.index
False
对浅拷贝和原始数据共享的更新会同时反映在两者中（注意：对于 pandas >= 3.0 不再成立）；深拷贝保持不变。
>>> s.iloc[0] = 3
>>> shallow.iloc[1] = 4
>>> s
a 3
b 4
dtype: int64
>>> shallow
a 3
b 4
dtype: int64
>>> deep
a 1
b 2
dtype: int64
注意，在复制包含 Python 对象的对象时，深拷贝会复制数据，但不会递归地进行复制。更新嵌套的数据对象会反映在深拷贝中。
>>> s = pd.Series([[1, 2], [3, 4]])
>>> deep = s.copy()
>>> s[0][0] = 10
>>> s
0 [10, 2]
1 [3, 4]
dtype: object
>>> deep
0 [10, 2]
1 [3, 4]
dtype: object
写时复制设置为 true，当原始数据发生更改时，浅拷贝不会被修改：
>>> with pd.option_context("mode.copy_on_write", True):
... s = pd.Series([1, 2], index=["a", "b"])
... copy = s.copy(deep=False)
... s.iloc[0] = 100
... s
a 100
b 2
dtype: int64
>>> copy
a 1
b 2
dtype: int64
pandas.DataFrame.bool
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.bool.html
DataFrame.bool()
返回单个元素 Series 或 DataFrame 的布尔值。
自 2.1.0 版本起已弃用：bool 已被弃用，并将在 pandas 的未来版本中移除。对于 Series 使用 pandas.Series.item。
这必须是一个布尔标量值，要么为 True，要么为 False。如果 Series 或 DataFrame 不具有恰好 1 个元素，或者该元素不是布尔值（整数值 0 和 1 也会引发异常），则会引发 ValueError。
返回：
布尔
Series 或 DataFrame 中的值。
另请参阅
Series.astype
更改 Series 的数据类型，包括布尔类型。
DataFrame.astype
更改 DataFrame 的数据类型，包括布尔类型。
NumPy 布尔数据类型，由 pandas 用于布尔值。
示例
该方法仅适用于具有布尔值的单个元素对象：
>>> pd.Series([True]).bool()
True
>>> pd.Series([False]).bool()
False
>>> pd.DataFrame({'col': [True]}).bool()
True
>>> pd.DataFrame({'col': [False]}).bool()
False
这是一种备选方法，仅适用于具有布尔值的单个元素对象：
>>> pd.Series([True]).item()
True
>>> pd.Series([False]).item()
False
pandas.DataFrame.to_numpy
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_numpy.html
DataFrame.to_numpy(dtype=None, copy=False, na_value=_NoDefault.no_default)
将 DataFrame 转换为 NumPy 数组。
默认情况下，返回数组的数据类型将是 DataFrame 中所有类型的常见 NumPy 数据类型。例如，如果数据类型是float16和float32，结果数据类型将是float32。这可能需要复制数据并强制转换值，这可能是昂贵的。
参数：
dtypestr 或 numpy.dtype，可选
传递给numpy.asarray()的数据类型。
copybool，默认为 False
是否确保返回值不是另一个数组的视图。请注意，copy=False并不保证to_numpy()不复制。相反，copy=True确保进行复制，即使不是严格必要的。
na_value任意，可选
用于缺失值的值。默认值取决于 dtype 和 DataFrame 列的数据类型。
返回：
numpy.ndarray
另请参见
Series.to_numpy
Series 有类似的方法。
示例
>>> pd.DataFrame({"A": [1, 2], "B": [3, 4]}).to_numpy()
array([[1, 3],
[2, 4]])
对于异构数据，将必须使用最低公共类型。
>>> df = pd.DataFrame({"A": [1, 2], "B": [3.0, 4.5]})
>>> df.to_numpy()
array([[1\. , 3\. ],
[2\. , 4.5]])
对于数字和非数字类型的混合，输出数组将具有对象数据类型。
>>> df['C'] = pd.date_range('2000', periods=2)
>>> df.to_numpy()
array([[1, 3.0, Timestamp('2000-01-01 00:00:00')],
[2, 4.5, Timestamp('2000-01-02 00:00:00')]], dtype=object)
pandas.DataFrame.head
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.head.html
DataFrame.head(n=5)
返回前 n 行。
此函数根据位置返回对象的前 n 行。对于快速测试对象是否具有正确类型的数据很有用。
对于 n 的负值，此函数返回除最后|n|行之外的所有行，相当于df[:n]。
如果 n 大于行数，则此函数返回所有行。
参数：
nint，默认为 5
要选择的行数。
返回：
与调用者相同类型
调用对象的前 n 行。
另请参阅
DataFrame.tail
返回最后 n 行。
示例
>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
5 parrot
6 shark
7 whale
8 zebra
查看前 5 行
>>> df.head()
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
查看前 n 行（在本例中为 3 行）
>>> 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.at
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.at.html
property DataFrame.at
通过行/列标签对访问单个值。
与loc类似，两者都提供基于标签的查找。如果您只需要在 DataFrame 或 Series 中获取或设置单个值，请使用at。
引发：
KeyError
如果在 DataFrame 或 Series 中获取值时‘label’不存在。
ValueError
如果行/列标签对不是元组，或者对中的任何标签不是 DataFrame 的标量。如果标签类似于列表（不包括 命名元组）则为 Series。
另请参阅
DataFrame.at
通过标签的行/列对访问单个值。
DataFrame.iat
通过整数位置为行/列对访问单个值。
DataFrame.loc
通过标签访问一组行和列。
DataFrame.iloc
通过整数位置访问一组行和列。
Series.at
通过标签访问单个值。
Series.iat
通过整数位置访问单个值。
Series.loc
通过标签访问一组行。
Series.iloc
通过整数位置访问一组行。
注意
有关更多详细信息，请参见快速标量值获取和设置。
示例
>>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
... index=[4, 5, 6], columns=['A', 'B', 'C'])
>>> df
A B C
4 0 2 3
5 0 4 1
6 10 20 30
获取指定行/列对的值
>>> df.at[4, 'B']
2
设置指定行/列对的值
>>> df.at[4, 'B'] = 10
>>> df.at[4, 'B']
10
获取 Series 中的值
>>> df.loc[5].at['B']
4
pandas.DataFrame.iat
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.iat.html
property DataFrame.iat
通过整数位置访问行/列对应的单个值。
与iloc类似，两者都提供基于整数的查找。如果只需要在 DataFrame 或 Series 中获取或设置单个值，请使用iat。
引发：
索引错误
当整数位置超出范围时。
另请参阅
DataFrame.at
访问行/列标签对应的单个值。
DataFrame.loc
通过标签访问一组行和列。
DataFrame.iloc
通过整数位置访问一组行和列。
示例
>>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
... columns=['A', 'B', 'C'])
>>> df
A B C
0 0 2 3
1 0 4 1
2 10 20 30
获取指定行/列对应的值
>>> df.iat[1, 2]
1
设置指定行/列对应的值
>>> df.iat[1, 2] = 10
>>> df.iat[1, 2]
10
获取系列内的值
>>> df.loc[0].iat[1]
2
pandas.DataFrame.loc
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html
property DataFrame.loc
通过标签或布尔数组访问一组行和列。
.loc[]主要基于标签，但也可与布尔数组一起使用。
允许的输入为：
-
单个标签，例如
5或'a'，（请注意，5被解释为索引的标签，而never被解释为索引上的整数位置）。 -
标签列表或数组，例如
['a', 'b', 'c']。 -
具有标签的切片对象，例如
'a':'f'。警告
请注意，与通常的 Python 切片相反，起始和结束都包括在内
-
与被切片轴长度相同的布尔数组，例如
[True, False, True]。 -
可对齐的布尔 Series。键的索引将在掩码之前对齐。
-
可对齐的索引。返回选择的索引将是输入的索引。
-
具有一个参数（调用的 Series 或 DataFrame）的
callable函数，并返回用于索引的有效输出（上述之一）
请查看按标签选择了解更多。
引发：
键错误
如果找不到任何项。
索引错误
如果传递了索引键且其索引与框索引不对齐。
请参见
DataFrame.at
访问行/列标签对的单个值。
DataFrame.iloc
通过整数位置访问一组行和列。
DataFrame.xs
从 Series/DataFrame 返回横截面（行/列）。
Series.loc
使用标签访问值组。
示例
获取值
>>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
... index=['cobra', 'viper', 'sidewinder'],
... columns=['max_speed', 'shield'])
>>> df
max_speed shield
cobra 1 2
viper 4 5
sidewinder 7 8
单个标签。请注意，这会将行作为 Series 返回。
>>> df.loc['viper']
max_speed 4
shield 5
Name: viper, dtype: int64
标签列表。请注意，使用[[]]会返回一个数据框。
>>> df.loc[['viper', 'sidewinder']]
max_speed shield
viper 4 5
sidewinder 7 8
单个标签用于行和列
>>> df.loc['cobra', 'shield']
2
使用行标签和列的标签切片。如上所述，请注意切片的起始和结束都包括在内。
>>> df.loc['cobra':'viper', 'max_speed']
cobra 1
viper 4
Name: max_speed, dtype: int64
与行轴长度相同的布尔列表
>>> df.loc[[False, False, True]]
max_speed shield
sidewinder 7 8
可对齐的布尔 Series：
>>> df.loc[pd.Series([False, True, False],
... index=['viper', 'sidewinder', 'cobra'])]
max_speed shield
sidewinder 7 8
索引（与df.reindex相同的行为）
>>> df.loc[pd.Index(["cobra", "viper"], name="foo")]
max_speed shield
foo
cobra 1 2
viper 4 5
返回布尔 Series 的条件
>>> df.loc[df['shield'] > 6]
max_speed shield
sidewinder 7 8
返回指定列标签的布尔 Series 的条件
>>> df.loc[df['shield'] > 6, ['max_speed']]
max_speed
sidewinder 7
使用&进行多条件筛选，返回布尔 Series
>>> df.loc[(df['max_speed'] > 1) & (df['shield'] < 8)]
max_speed shield
viper 4 5
使用|进行多条件筛选，返回布尔 Series
>>> df.loc[(df['max_speed'] > 4) | (df['shield'] < 5)]
max_speed shield
cobra 1 2
sidewinder 7 8
请确保每个条件都用括号()括起来。有关更多详细信息和布尔索引解释，请参阅用户指南。
注意
如果您发现自己在.loc[]中使用了 3 个或更多条件，请考虑使用高级索引。
请参见下文有关在多级索引数据框上使用.loc[]的示例。
返回布尔 Series 的callable函数
>>> df.loc[lambda df: df['shield'] == 8]
max_speed shield
sidewinder 7 8
设置值
为匹配标签列表的所有项目设置值
>>> df.loc[['viper', 'sidewinder'], ['shield']] = 50
>>> df
max_speed shield
cobra 1 2
viper 4 50
sidewinder 7 50
为整行设置值
>>> df.loc['cobra'] = 10
>>> df
max_speed shield
cobra 10 10
viper 4 50
sidewinder 7 50
为整个列设置值
>>> df.loc[:, 'max_speed'] = 30
>>> df
max_speed shield
cobra 30 10
viper 30 50
sidewinder 30 50
为符合可调用条件的行设置值
>>> df.loc[df['shield'] > 35] = 0
>>> df
max_speed shield
cobra 30 10
viper 0 0
sidewinder 0 0
添加匹配位置的值
>>> df.loc["viper", "shield"] += 5
>>> df
max_speed shield
cobra 30 10
viper 0 5
sidewinder 0 0
使用Series或DataFrame进行设置会设置匹配索引标签的值，而不是索引位置。
>>> shuffled_df = df.loc[["viper", "cobra", "sidewinder"]]
>>> df.loc[:] += shuffled_df
>>> df
max_speed shield
cobra 60 20
viper 0 10
sidewinder 0 0
在具有整数标签的 DataFrame 上获取值
使用整数作为索引的另一个例子
>>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
... index=[7, 8, 9], columns=['max_speed', 'shield'])
>>> df
max_speed shield
7 1 2
8 4 5
9 7 8
使用整数标签对行进行切片。如上所述，请注意切片的起始点和终止点都包含在内。
>>> df.loc[7:9]
max_speed shield
7 1 2
8 4 5
9 7 8
使用 MultiIndex 获取值
使用具有 MultiIndex 的 DataFrame 的若干示例
>>> tuples = [
... ('cobra', 'mark i'), ('cobra', 'mark ii'),
... ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'),
... ('viper', 'mark ii'), ('viper', 'mark iii')
... ]
>>> index = pd.MultiIndex.from_tuples(tuples)
>>> values = [[12, 2], [0, 4], [10, 20],
... [1, 4], [7, 1], [16, 36]]
>>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index)
>>> df
max_speed shield
cobra mark i 12 2
mark ii 0 4
sidewinder mark i 10 20
mark ii 1 4
viper mark ii 7 1
mark iii 16 36
单个标签。请注意，这会返回具有单个索引的 DataFrame。
>>> df.loc['cobra']
max_speed shield
mark i 12 2
mark ii 0 4
单个索引元组。请注意，这会返回一个 Series。
>>> df.loc[('cobra', 'mark ii')]
max_speed 0
shield 4
Name: (cobra, mark ii), dtype: int64
单行和列的单个标签。类似于传递元组，这将返回一个 Series。
>>> df.loc['cobra', 'mark i']
max_speed 12
shield 2
Name: (cobra, mark i), dtype: int64
单个元组。注意使用[[]]返回一个 DataFrame。
>>> df.loc[[('cobra', 'mark ii')]]
max_speed shield
cobra mark ii 0 4
具有单个标签的索引元组
>>> df.loc[('cobra', 'mark i'), 'shield']
2
从索引元组到单个标签的切片
>>> df.loc[('cobra', 'mark i'):'viper']
max_speed shield
cobra mark i 12 2
mark ii 0 4
sidewinder mark i 10 20
mark ii 1 4
viper mark ii 7 1
mark iii 16 36
从索引元组到索引元组的切片
>>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')]
max_speed shield
cobra mark i 12 2
mark ii 0 4
sidewinder mark i 10 20
mark ii 1 4
viper mark ii 7 1
请参阅用户指南以获取更多高级索引的详细信息和解释。
pandas.DataFrame.iloc
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html
property DataFrame.iloc
纯粹基于整数位置的索引，用于按位置选择。
自版本 2.2.0 起弃用：从可调用函数返回元组已弃用。
.iloc[]主要基于整数位置（从轴的0到length-1），但也可以与布尔数组一起使用。
允许的输入有：
-
一个整数，例如
5。 -
一个整数列表或数组，例如
[4, 3, 0]。 -
一个带有整数的切片对象，例如
1:7。 -
一个布尔数组。
-
一个带有一个参数（调用的 Series 或 DataFrame）的
callable函数，并返回用于索引的有效输出（上述之一）。在方法链中很有用，当您没有对调用对象的引用，但希望基于某个值进行选择时。 -
一对行和列索引。元组元素包括上述输入之一，例如
(0, 1)。
如果请求的索引器超出范围，.iloc将引发IndexError，除了切片索引器允许超出范围的索引（这符合 python/numpy 的切片语义）。
在按位置选择中查看更多。
另请参阅
DataFrame.iat
快速整数位置标量访问器。
DataFrame.loc
纯粹基于标签位置的索引器，用于按标签选择。
Series.iloc
纯粹基于整数位置的索引，用于按位置选择。
示例
>>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
... {'a': 100, 'b': 200, 'c': 300, 'd': 400},
... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000}]
>>> df = pd.DataFrame(mydict)
>>> df
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
仅索引行
使用标量整数。
>>> type(df.iloc[0])
<class 'pandas.core.series.Series'>
>>> df.iloc[0]
a 1
b 2
c 3
d 4
Name: 0, dtype: int64
使用整数列表。
>>> df.iloc[[0]]
a b c d
0 1 2 3 4
>>> type(df.iloc[[0]])
<class 'pandas.core.frame.DataFrame'>
>>> df.iloc[[0, 1]]
a b c d
0 1 2 3 4
1 100 200 300 400
使用切片对象。
>>> df.iloc[:3]
a b c d
0 1 2 3 4
1 100 200 300 400
2 1000 2000 3000 4000
使用与索引相同长度的布尔掩码。
>>> df.iloc[[True, False, True]]
a b c d
0 1 2 3 4
2 1000 2000 3000 4000
使用可调用函数，在方法链中很有用。传递给lambda的 x 是正在被切片的 DataFrame。这将选择其索引标签为偶数的行。
>>> df.iloc[lambda x: x.index % 2 == 0]
a b c d
0 1 2 3 4
2 1000 2000 3000 4000
同时索引两个轴
您可以混合索引器类型以选择索引和列。使用:选择整个轴。
使用标量整数。
>>> df.iloc[0, 1]
2
使用整数列表。
>>> df.iloc[[0, 2], [1, 3]]
b d
0 2 4
2 2000 4000
使用切片对象。
>>> df.iloc[1:3, 0:3]
a b c
1 100 200 300
2 1000 2000 3000
使用与列匹配长度的布尔数组。
>>> df.iloc[:, [True, False, True, False]]
a c
0 1 3
1 100 300
2 1000 3000
使用期望 Series 或 DataFrame 的可调用函数。
>>> df.iloc[:, lambda df: [0, 2]]
a c
0 1 3
1 100 300
2 1000 3000
pandas.DataFrame.insert
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.insert.html
DataFrame.insert(loc, column, value, allow_duplicates=_NoDefault.no_default)
在指定位置将列插入 DataFrame。
如果列已经包含在 DataFrame 中，则引发 ValueError，除非 allow_duplicates 设置为 True。
参数：
loc 整数
插入索引。必须满足 0 <= loc <= len(columns)。
column 字符串、数字或可哈希对象
要插入列的标签。
value 标量、系列或类似数组
插入列的内容。
allow_duplicates 布尔型，可选，默认值 lib.no_default
允许创建重复的列标签。
另请参阅
Index.insert
通过索引插入新项目。
示例
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
>>> df
col1 col2
0 1 3
1 2 4
>>> df.insert(1, "newcol", [99, 99])
>>> df
col1 newcol col2
0 1 99 3
1 2 99 4
>>> df.insert(0, "col1", [100, 100], allow_duplicates=True)
>>> df
col1 col1 newcol col2
0 100 1 99 3
1 100 2 99 4
注意，如果值的类型为 Series，则 pandas 使用索引对齐：
>>> df.insert(0, "col0", pd.Series([5, 6], index=[1, 2]))
>>> df
col0 col1 col1 newcol col2
0 NaN 100 1 99 3
1 5.0 100 2 99 4
