Pandas-2-2-中文文档-二十-
Pandas 2.2 中文文档（二十）
pandas.DataFrame.__iter__
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.__iter__.html
DataFrame.__iter__()
遍历信息轴。
返回：
迭代器
信息轴作为迭代器。
示例
>>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
>>> for x in df:
... print(x)
A
B
pandas.DataFrame.items
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.items.html
DataFrame.items()
遍历（列名，Series）对。
遍历 DataFrame 列，返回一个包含列名和内容的 Series 的元组。
产生：
标签对象
正在遍历的 DataFrame 的列名。
内容Series
属于每个标签的列条目，作为 Series。
另请参阅
DataFrame.iterrows
遍历 DataFrame 行，作为（索引，Series）对。
DataFrame.itertuples
遍历 DataFrame 行，作为命名元组的值。
示例
>>> df = pd.DataFrame({'species': ['bear', 'bear', 'marsupial'],
... 'population': [1864, 22000, 80000]},
... index=['panda', 'polar', 'koala'])
>>> df
species population
panda bear 1864
polar bear 22000
koala marsupial 80000
>>> for label, content in df.items():
... print(f'label: {label}')
... print(f'content: {content}', sep='\n')
...
label: species
content:
panda bear
polar bear
koala marsupial
Name: species, dtype: object
label: population
content:
panda 1864
polar 22000
koala 80000
Name: population, dtype: int64
pandas.DataFrame.keys
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.keys.html
DataFrame.keys()
获取“信息轴”（详见索引）。
这是 Series 的索引，DataFrame 的列。
返回：
索引
信息轴。
示例
>>> d = pd.DataFrame(data={'A': [1, 2, 3], 'B': [0, 4, 8]},
... index=['a', 'b', 'c'])
>>> d
A B
a 1 0
b 2 4
c 3 8
>>> d.keys()
Index(['A', 'B'], dtype='object')
pandas.DataFrame.iterrows
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.iterrows.html
DataFrame.iterrows()
遍历 DataFrame 行，返回值为（索引，Series）对。
产生：
索引标签或标签元组
行的索引。对于多重索引，是一个元组。
数据Series
行的数据作为一个 Series。
另请参阅
遍历 DataFrame 行，返回值为值的命名元组。
遍历（列名，Series）对。
注意事项
-
因为
iterrows为每行返回一个 Series，它不会在行之间保留数据类型（对于 DataFrame，数据类型在列之间保留）。为了在遍历行时保留数据类型，最好使用
itertuples()返回值为命名元组的方法，通常比iterrows更快。 -
在迭代过程中，您不应该
修改正在迭代的内容。这并不保证在所有情况下都有效。根据数据类型，迭代器返回的是副本而不是视图，对其进行写入将不会产生任何效果。
示例
>>> df = pd.DataFrame([[1, 1.5]], columns=['int', 'float'])
>>> row = next(df.iterrows())[1]
>>> row
int 1.0
float 1.5
Name: 0, dtype: float64
>>> print(row['int'].dtype)
float64
>>> print(df['int'].dtype)
int64
pandas.DataFrame.itertuples
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.itertuples.html
DataFrame.itertuples(index=True, name='Pandas')
以命名元组的形式迭代 DataFrame 行。
参数：
indexbool，默认为 True
如果为 True，则将索引作为元组的第一个元素返回。
namestr 或 None，默认为“Pandas”
返回的命名元组的名称，或者为 None 以返回常规元组。
返回：
iterator
一个对象，用于在 DataFrame 中的每一行上迭代命名元组，第一个字段可能是索引，后续字段是列值。
另请参阅
DataFrame.iterrows
以(index, Series)对的形式迭代 DataFrame 行。
DataFrame.items
以(列名，Series)对的形式迭代。
注意
如果列名无效的 Python 标识符、重复或以下划线开头，则列名将重命名为位置名称。
示例
>>> df = pd.DataFrame({'num_legs': [4, 2], 'num_wings': [0, 2]},
... index=['dog', 'hawk'])
>>> df
num_legs num_wings
dog 4 0
hawk 2 2
>>> for row in df.itertuples():
... print(row)
...
Pandas(Index='dog', num_legs=4, num_wings=0)
Pandas(Index='hawk', num_legs=2, num_wings=2)
通过将 index 参数设置为 False，我们可以将索引作为元组的第一个元素移除：
>>> for row in df.itertuples(index=False):
... print(row)
...
Pandas(num_legs=4, num_wings=0)
Pandas(num_legs=2, num_wings=2)
通过设置 name 参数，我们可以为生成的命名元组设置自定义名称：
>>> for row in df.itertuples(name='Animal'):
... print(row)
...
Animal(Index='dog', num_legs=4, num_wings=0)
Animal(Index='hawk', num_legs=2, num_wings=2)
pandas.DataFrame.pop
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.pop.html
DataFrame.pop(item)
返回项目并从数据框中删除。如果未找到，则引发 KeyError。
参数：
项目标签
要弹出的列的标签。
返回：
系列
示例
>>> df = pd.DataFrame([('falcon', 'bird', 389.0),
... ('parrot', 'bird', 24.0),
... ('lion', 'mammal', 80.5),
... ('monkey', 'mammal', np.nan)],
... columns=('name', 'class', 'max_speed'))
>>> df
name class max_speed
0 falcon bird 389.0
1 parrot bird 24.0
2 lion mammal 80.5
3 monkey mammal NaN
>>> df.pop('class')
0 bird
1 bird
2 mammal
3 mammal
Name: class, dtype: object
>>> df
name max_speed
0 falcon 389.0
1 parrot 24.0
2 lion 80.5
3 monkey NaN
pandas.DataFrame.tail
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.tail.html
DataFrame.tail(n=5)
返回最后 n 行。
此函数基于位置从对象中返回最后 n 行。 在排序或追加行后，例如快速验证数据非常有用。
对于负值的 n，此函数返回除前|n|行外的所有行，相当于df[|n|:]。
如果 n 大于行数，则此函数返回所有行。
参数：
nint，默认为 5
要选择的行数。
返回：
调用者类型
调用者对象的最后 n 行。
另请参阅
DataFrame.head
调用者对象的前 n 行。
示例
>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})
>>> df
animal
0 alligator
1 bee
2 falcon
3 lion
4 monkey
5 parrot
6 shark
7 whale
8 zebra
查看最后 5 行
>>> df.tail()
animal
4 monkey
5 parrot
6 shark
7 whale
8 zebra
查看最后 n 行（在此情况下为三行）
>>> df.tail(3)
animal
6 shark
7 whale
8 zebra
对于负值的 n
>>> df.tail(-3)
animal
3 lion
4 monkey
5 parrot
6 shark
7 whale
8 zebra
pandas.DataFrame.xs
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.xs.html
DataFrame.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.DataFrame.get
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.get.html
DataFrame.get(key, default=None)
获取给定键的对象中的项目（例如：DataFrame 列）。
如果未找到，则返回默认值。
参数：
key对象
返回：
与对象中包含的项目相同的类型
示例
>>> df = pd.DataFrame(
... [
... [24.3, 75.7, "high"],
... [31, 87.8, "high"],
... [22, 71.6, "medium"],
... [35, 95, "medium"],
... ],
... columns=["temp_celsius", "temp_fahrenheit", "windspeed"],
... index=pd.date_range(start="2014-02-12", end="2014-02-15", freq="D"),
... )
>>> df
temp_celsius temp_fahrenheit windspeed
2014-02-12 24.3 75.7 high
2014-02-13 31.0 87.8 high
2014-02-14 22.0 71.6 medium
2014-02-15 35.0 95.0 medium
>>> df.get(["temp_celsius", "windspeed"])
temp_celsius windspeed
2014-02-12 24.3 high
2014-02-13 31.0 high
2014-02-14 22.0 medium
2014-02-15 35.0 medium
>>> ser = df['windspeed']
>>> ser.get('2014-02-13')
'high'
如果未找到键，则将使用默认值。
>>> df.get(["temp_celsius", "temp_kelvin"], default="default_value")
'default_value'
>>> ser.get('2014-02-10', '[unknown]')
'[unknown]'
pandas.DataFrame.isin
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.isin.html
DataFrame.isin(values)
DataFrame 中的每个元素是否包含在 values 中。
参数：
values 可迭代的，Series，DataFrame 或字典
结果只有在所有标签都匹配时才为 true。如果 values 是 Series，则为其索引。如果 values 是字典，则键必须是列名，且必须匹配。如果 values 是 DataFrame，则索引和列标签都必须匹配。
返回值：
DataFrame
布尔型的 DataFrame，显示 DataFrame 中的每个元素是否包含在 values 中。
另请参阅
DataFrame.eq
DataFrame 的相等性测试。
Series.isin
等效于 Series 上的方法。
Series.str.contains
检查模式或正则表达式是否包含在 Series 或索引的字符串中。
示例
>>> df = pd.DataFrame({'num_legs': [2, 4], 'num_wings': [2, 0]},
... index=['falcon', 'dog'])
>>> df
num_legs num_wings
falcon 2 2
dog 4 0
当 values 是列表时，检查 DataFrame 中的每个值是否存在于列表中（哪些动物有 0 或 2 条腿或翅膀）
>>> df.isin([0, 2])
num_legs num_wings
falcon True True
dog False True
要检查 DataFrame 中是否不存在 values，请使用 ~ 运算符：
>>> ~df.isin([0, 2])
num_legs num_wings
falcon False False
dog True False
当 values 是字典时，我们可以分别传递值以检查每一列：
>>> df.isin({'num_wings': [0, 3]})
num_legs num_wings
falcon False False
dog False True
当 values 是 Series 或 DataFrame 时，索引和列必须匹配。请注意，根据其他腿的数量，‘falcon’ 不匹配。
>>> other = pd.DataFrame({'num_legs': [8, 3], 'num_wings': [0, 2]},
... index=['spider', 'falcon'])
>>> df.isin(other)
num_legs num_wings
falcon False True
dog False False
pandas.DataFrame.where
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.where.html
DataFrame.where(cond, other=nan, *, inplace=False, axis=None, level=None)
替换条件为 False 的值。
参数：
cond 布尔 Series/DataFrame、类似数组或可调用对象
当 cond 为 True 时，保留原始值。当为 False 时，用 other 对应的值替换。如果 cond 是可调用的，则在 Series/DataFrame 上进行计算，应返回布尔 Series/DataFrame 或数组。该可调用对象不得更改输入的 Series/DataFrame（尽管 pandas 不会检查）。
other 标量、Series/DataFrame 或可调用对象
如果 cond 为 False，则用 other 对应的值替换。如果 other 是可调用的，则在 Series/DataFrame 上进行计算，应返回标量或 Series/DataFrame。该可调用对象不得更改输入的 Series/DataFrame（尽管 pandas 不会检查）。如果未指定，则条目将用对应的 NULL 值填充（对于 numpy dtypes 是 np.nan，对于扩展 dtypes 是 pd.NA）。
inplace 布尔值，默认为 False
是否在数据上原地执行操作。
axis 整数，默认为 None
如有必要，对齐轴。对于 Series，此参数未使用，默认为 0。
level 整数，默认为 None
如有必要，对齐级别。
返回：
与调用者相同的类型，如果 inplace=True 则为 None。
另请参见
DataFrame.mask()
返回一个与 self 相同形状的对象。
注意事项
where 方法是 if-then 习语的一种应用。对于调用 DataFrame 中的每个元素，如果 cond 为 True 则使用该元素；否则使用 DataFrame other 对应的元素。如果 other 的轴与 cond 的轴不对齐，未对齐的索引位置将填充为 False。
DataFrame.where() 的签名与 numpy.where() 不同。大致上，df1.where(m, df2) 等价于 np.where(m, df1, df2)。
更多详细信息和示例请参阅 indexing 中的 where 文档。
对象的 dtype 优先。如果可以无损转换，则填充值将转换为对象的 dtype。
示例
>>> s = pd.Series(range(5))
>>> s.where(s > 0)
0 NaN
1 1.0
2 2.0
3 3.0
4 4.0
dtype: float64
>>> s.mask(s > 0)
0 0.0
1 NaN
2 NaN
3 NaN
4 NaN
dtype: float64
>>> s = pd.Series(range(5))
>>> t = pd.Series([True, False])
>>> s.where(t, 99)
0 0
1 99
2 99
3 99
4 99
dtype: int64
>>> s.mask(t, 99)
0 99
1 1
2 99
3 99
4 99
dtype: int64
>>> s.where(s > 1, 10)
0 10
1 10
2 2
3 3
4 4
dtype: int64
>>> s.mask(s > 1, 10)
0 0
1 1
2 10
3 10
4 10
dtype: int64
>>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])
>>> df
A B
0 0 1
1 2 3
2 4 5
3 6 7
4 8 9
>>> m = df % 3 == 0
>>> df.where(m, -df)
A B
0 0 -1
1 -2 3
2 -4 -5
3 6 -7
4 -8 9
>>> df.where(m, -df) == np.where(m, df, -df)
A B
0 True True
1 True True
2 True True
3 True True
4 True True
>>> df.where(m, -df) == df.mask(~m, -df)
A B
0 True True
1 True True
2 True True
3 True True
4 True True
pandas.DataFrame.mask
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.mask.html
DataFrame.mask(cond, other=_NoDefault.no_default, *, inplace=False, axis=None, level=None)
替换条件为 True 的值。
参数：
condbool Series/DataFrame、类数组或可调用对象
当 cond 为 False 时，保留原始值。当为 True 时，用其他对应值替换。如果 cond 是可调用对象，则在 Series/DataFrame 上计算，应返回布尔 Series/DataFrame 或数组。可调用对象不得更改输入 Series/DataFrame（尽管 pandas 不会检查）。
other 标量、Series/DataFrame 或可调用对象
将 cond 为 True 的条目替换为其他对应值。如果 other 是可调用对象，则在 Series/DataFrame 上计算，应返回标量或 Series/DataFrame。可调用对象不得更改输入 Series/DataFrame（尽管 pandas 不会检查）。如果未指定，条目将填充为相应的 NULL 值（对于 numpy dtypes 为 np.nan，对于扩展 dtypes 为 pd.NA）。
inplace 布尔值，默认为 False
是否在数据上就地执行操作。
axisint，默认为 None
如果需要，对齐轴。对于 Series，此参数未使用，默认为 0。
levelint，默认为 None
如果需要，对齐级别。
返回：
与调用者相同类型，如果 inplace=True 则为 None。
另请参见
DataFrame.where()
返回与 self 相同形状的对象。
注意
mask 方法是 if-then 惯用法的应用。对于调用 DataFrame 中的每个元素，如果 cond 为 False，则使用该元素；否则使用 DataFrame other 中的对应元素。如果 other 的轴与 cond Series/DataFrame 的轴不对齐，则不对齐的索引位置将填充为 True。
DataFrame.where() 的签名与 numpy.where() 不同。大致上，df1.where(m, df2) 等同于 np.where(m, df1, df2)。
有关更多详细信息和示例，请参阅 indexing 中的 mask 文档。
对象的 dtype 优先。如果可以无损地完成，填充值将转换为对象的 dtype。
示例
>>> s = pd.Series(range(5))
>>> s.where(s > 0)
0 NaN
1 1.0
2 2.0
3 3.0
4 4.0
dtype: float64
>>> s.mask(s > 0)
0 0.0
1 NaN
2 NaN
3 NaN
4 NaN
dtype: float64
>>> s = pd.Series(range(5))
>>> t = pd.Series([True, False])
>>> s.where(t, 99)
0 0
1 99
2 99
3 99
4 99
dtype: int64
>>> s.mask(t, 99)
0 99
1 1
2 99
3 99
4 99
dtype: int64
>>> s.where(s > 1, 10)
0 10
1 10
2 2
3 3
4 4
dtype: int64
>>> s.mask(s > 1, 10)
0 0
1 1
2 10
3 10
4 10
dtype: int64
>>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])
>>> df
A B
0 0 1
1 2 3
2 4 5
3 6 7
4 8 9
>>> m = df % 3 == 0
>>> df.where(m, -df)
A B
0 0 -1
1 -2 3
2 -4 -5
3 6 -7
4 -8 9
>>> df.where(m, -df) == np.where(m, df, -df)
A B
0 True True
1 True True
2 True True
3 True True
4 True True
>>> df.where(m, -df) == df.mask(~m, -df)
A B
0 True True
1 True True
2 True True
3 True True
4 True True
pandas.DataFrame.query
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.query.html
DataFrame.query(expr, *, inplace=False, **kwargs)
使用布尔表达式查询 DataFrame 的列。
参数：
exprstr
要评估的查询字符串。
您可以通过在变量前加上‘@’字符来引用环境中的变量，例如@a + b。
您可以通过用反引号括起来来引用不是有效 Python 变量名的列名。因此，包含空格或标点符号（除了下划线）或以数字开头的列名必须用反引号括起来。 （例如，名为“Area（cm²）”的列将被引用为Area（cm²））。不能使用 Python 关键字（如“list”、“for”、“import”等）作为列名。
例如，如果您的列之一称为a a，并且您想将其与b求和，您的查询应为``a a + b。
inplacebool
是否修改 DataFrame 而不是创建新的 DataFrame。
**kwargs
有关DataFrame.query()接受的关键字参数的完整详细信息，请参阅eval()的文档。
返回值：
DataFrame 或 None
由提供的查询表达式生成的 DataFrame 或如果inplace=True则为 None。
另请参见
评估描述 DataFrame 列操作的字符串。
评估描述 DataFrame 列操作的字符串。
注意事项
该表达式的评估结果首先传递给DataFrame.loc，如果由于多维键（例如 DataFrame）而失败，则结果将传递给DataFrame.__getitem__()。
该方法使用顶层eval()函数来评估传递的查询。
默认情况下，query()方法使用略微修改的 Python 语法。例如，&和|（按位）运算符具有其布尔表亲and和or的优先级。这是在语法上有效的 Python，但语义不同。
通过传递关键字参数parser='python'可以更改表达式的语义。这强制执行与 Python 空间中的评估相同的语义。同样，您可以传递engine='python'以使用 Python 本身作为后端来评估表达式。与使用numexpr作为引擎相比，这不是推荐的，因为效率低下。
DataFrame.index 和 DataFrame.columns 属性默认放置在 DataFrame 实例的查询命名空间中，这使您可以将帧的索引和列都视为帧中的列。标识符 index 用于帧索引；您还可以使用索引的名称来在查询中标识它。请注意，Python 关键字不能用作标识符。
有关更多详细信息和示例，请参阅 索引 中的 query 文档。
反引号引用的变量
反引号引用的变量被解析为字面的 Python 代码，并在内部转换为 Python 有效的标识符。这可能会导致以下问题。
在解析过程中，反引号引用的字符串中的一些不允许的字符将被替换为允许作为 Python 标识符的字符串。这些字符包括 Python 中的所有运算符、空格字符、问号、感叹号、美元符号和欧元符号。对于其他超出 ASCII 范围（U+0001..U+007F）的字符以及在 PEP 3131 中未进一步指定的字符，查询解析器将引发错误。这不包括空格字符不同于空格字符，但也包括井号（因为它用于注释）和反引号本身（反引号也不能被转义）。
在特殊情况下，用引号围绕反引号的情况可能会让解析器混淆。例如，it's` > `that's 会引发错误，因为它形成了一个带有反引号的引号字符串（'s > that'`）。
还可以参考 Python 关于词法分析的文档（docs.python.org/3/reference/lexical_analysis.html），结合 pandas.core.computation.parsing 中的源代码。
示例
>>> df = pd.DataFrame({'A': range(1, 6),
... 'B': range(10, 0, -2),
... 'C C': range(10, 5, -1)})
>>> df
A B C C
0 1 10 10
1 2 8 9
2 3 6 8
3 4 4 7
4 5 2 6
>>> df.query('A > B')
A B C C
4 5 2 6
前面的表达式等同于
>>> df[df.A > df.B]
A B C C
4 5 2 6
对于列名中带有空格的列，可以使用反引号引用。
>>> df.query('B == `C C`')
A B C C
0 1 10 10
前面的表达式等同于
>>> df[df.B == df['C C']]
A B C C
0 1 10 10
pandas.DataFrame.__add__
pandas.pydata.org/docs/reference/api/pandas.DataFrame.__add__.html
DataFrame.__add__(other)
获取 DataFrame 和其他对象的按列加法。
等同于 DataFrame.add(other)。
参数：
other 标量、序列、Series、字典或 DataFrame
要添加到 DataFrame 的对象。
返回值：
DataFrame
将 other 添加到 DataFrame 的结果。
另请参阅
DataFrame.add
添加一个 DataFrame 和另一个对象，可以选择按索引或按列进行添加。
示例
>>> df = pd.DataFrame({'height': [1.5, 2.6], 'weight': [500, 800]},
... index=['elk', 'moose'])
>>> df
height weight
elk 1.5 500
moose 2.6 800
添加标量会影响所有行和列。
>>> df[['height', 'weight']] + 1.5
height weight
elk 3.0 501.5
moose 4.1 801.5
列表的每个元素按顺序添加到 DataFrame 的列中。
>>> df[['height', 'weight']] + [0.5, 1.5]
height weight
elk 2.0 501.5
moose 3.1 801.5
字典的键根据列名对齐到 DataFrame；字典中的每个值都会添加到相应的列中。
>>> df[['height', 'weight']] + {'height': 0.5, 'weight': 1.5}
height weight
elk 2.0 501.5
moose 3.1 801.5
当其他对象是Series时，其他对象的索引与 DataFrame 的列对齐。
>>> s1 = pd.Series([0.5, 1.5], index=['weight', 'height'])
>>> df[['height', 'weight']] + s1
height weight
elk 3.0 500.5
moose 4.1 800.5
即使其他对象的索引与 DataFrame 的索引相同，Series 也不会重新定位。如果需要按索引对齐，请使用 axis=’index’ 的 DataFrame.add()。
>>> s2 = pd.Series([0.5, 1.5], index=['elk', 'moose'])
>>> df[['height', 'weight']] + s2
elk height moose weight
elk NaN NaN NaN NaN
moose NaN NaN NaN NaN
>>> df[['height', 'weight']].add(s2, axis='index')
height weight
elk 2.0 500.5
moose 4.1 801.5
当其他对象是DataFrame时，列名和索引都会对齐。
>>> other = pd.DataFrame({'height': [0.2, 0.4, 0.6]},
... index=['elk', 'moose', 'deer'])
>>> df[['height', 'weight']] + other
height weight
deer NaN NaN
elk 1.7 NaN
moose 3.0 NaN
pandas.DataFrame.add
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.add.html
DataFrame.add(other, axis='columns', level=None, fill_value=None)
获取数据帧和其他元素的加法，逐元素（二元操作符加）。
等同于 dataframe + other，但支持在输入的其中一个数据中替换缺失数据的填充值。具有反向版本 radd。
灵活的包装器中的一种（add、sub、mul、div、floordiv、mod、pow）以算术运算符为：+、-、*、/、//、%、**。
参数：
other 标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis {0 或 ‘index’，1 或 ‘columns’}
是否按索引比较（0 或 ‘index’）或列（1 或 ‘columns’）进行比较。对于 Series 输入，匹配 Series 索引的轴。
level 整数或标签
在一个级别上广播，与传递的 MultiIndex 级别上的索引值匹配。
fill_value 浮点数或 None，默认为 None
在计算之前，使用此值填充现有的缺失（NaN）值，以及任何需要成功 DataFrame 对齐的新元素。如果两个对应的 DataFrame 位置都缺少数据，则结果将缺失。
返回：
DataFrame
算术操作的结果。
参见
DataFrame.add
添加数据帧。
减去数据帧。
乘以数据帧。
除以数据帧（浮点除法）。
除以数据帧（浮点除法）。
除以数据帧（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注意事项
不匹配的索引将被联合在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量的操作符版本，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用操作符版本减去列表和 Series 的轴。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
使用轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用操作符版本乘以不同形状的 DataFrame。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以多重索引。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.sub
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.sub.html
DataFrame.sub(other, axis='columns', level=None, fill_value=None)
获取 dataframe 和 other 的减法，逐元素进行（二元操作符 sub）。
等同于 dataframe - other，但支持用填充值替换输入中的缺失数据。有反向版本，rsub。
在灵活的包装器（add、sub、mul、div、floordiv、mod、pow）中进行算术运算：+、-、*、/、//、%、**。
参数：
other标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或 ‘index’）或列（1 或 ‘columns’）进行比较。对于 Series 输入，要匹配 Series 索引的轴。
levelint 或标签
在传递的 MultiIndex 级别上进行广播，匹配索引值。
fill_valuefloat 或 None，默认为 None
在进行计算之前，使用此值填充现有的缺失（NaN）值以及任何新的元素，以确保成功对齐 DataFrame。如果两个对应的 DataFrame 位置的数据都缺失，则结果也将缺失。
返回：
DataFrame
算术运算的结果。
另请参见
添加 DataFrames。
DataFrame.sub
DataFrames 相减。
将 DataFrames 相乘。
除以 DataFrames（浮点数除法）。
除以 DataFrames（浮点数除法）。
除以 DataFrames（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注释
不匹配的索引将被合并。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量，并返回相同的结果的操作符版本。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本与常数相除。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
沿轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
将字典按轴相乘。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用操作符版本将不同形状的 DataFrame 相乘。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.mul
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.mul.html
DataFrame.mul(other, axis='columns', level=None, fill_value=None)
获取数据框和其他元素的乘法，逐元素（二进制运算符 mul）。
等同于dataframe * other，但支持用一个 fill_value 替换一个输入中缺失数据的支持。具有反向版本 rmul。
在灵活的包装器中（add，sub，mul，div，floordiv，mod，pow）到算术运算符：+，-，*，/，//，%，**。
参数：
other标量，序列，系列，字典或数据框
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于系列输入，要匹配系列索引的轴。
level整数或标签
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_value浮点数或无，默认为无
填充现有缺失（NaN）值，并为成功的数据框对齐所需的任何新元素，使用此值进行计算。如果两个对应的数据框位置的数据都缺失，则结果将缺失。
返回：
DataFrame
算术操作的结果。
参见
DataFrame.add
添加数据框。
DataFrame.sub
减去数据框。
DataFrame.mul
乘以数据框。
DataFrame.div
划分数据框（浮点除法）。
DataFrame.truediv
划分数据框（浮点除法）。
DataFrame.floordiv
划分数据框（整数除法）。
DataFrame.mod
计算模数（除法后的余数）。
DataFrame.pow
计算指数幂。
注意事项
不匹配的索引将被合并在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量与运算符版本，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
通过反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
通过轴减去列表和系列与运算符版本。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
沿轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
乘以具有运算符版本的不同形状的数据框。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.div
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.div.html
DataFrame.div(other, axis='columns', level=None, fill_value=None)
获取数据框和其他数据的浮点除法，逐元素进行（二元操作符 truediv）。
等同于dataframe / other，但支持用填充值替换一个输入中的缺失数据。具有反向版本 rtruediv。
在算术运算符的灵活封装中（add，sub，mul，div，floordiv，mod，pow）：+，-，*，/，//，%，**。
参数：
other标量，序列，Series，字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于 Series 输入，要匹配 Series 索引的轴。
level整数或标签
在一个级别上进行广播，匹配传递的 MultiIndex 级别上的 Index 值。
fill_value浮点数或 None，默认为 None
在计算之前，用此值填充现有的缺失（NaN）值，并且填充任何新的元素以成功地对齐 DataFrame。如果两个对应 DataFrame 位置的数据都丢失，则结果将丢失。
返回：
DataFrame
算术运算的结果。
另请参阅
DataFrame.add
添加数据框。
DataFrame.sub
减去数据框。
DataFrame.mul
乘以数据框。
DataFrame.div
划分数据框（浮点除法）。
DataFrame.truediv
划分数据框（浮点除法）。
DataFrame.floordiv
划分数据框（整数除法）。
DataFrame.mod
计算模数（除法后的余数）。
DataFrame.pow
计算指数幂。
注释
不匹配的索引将被合并在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量，使用操作符版本返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用操作符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
乘以轴的字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用操作符版本乘以不同形状的数据框。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别划分多索引。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.truediv
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.truediv.html
DataFrame.truediv(other, axis='columns', level=None, fill_value=None)
获取数据帧和其他数据的浮点除法，逐元素进行（二元运算符 truediv）。
等同于 dataframe / other，但支持在输入中的一个缺失数据的位置替换 fill_value。具有反向版本 rtruediv。
在灵活的包装器中（add、sub、mul、div、floordiv、mod、pow）进行算术运算符的操作：+、-、*、/、//、%、**。
参数：
other标量、序列、系列、字典或数据帧
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或 'index'）或列（1 或 'columns'）进行比较。对于系列输入，要匹配系列索引的轴。
level整数或标签
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_valuefloat 或 None，默认为 None
在计算之前，使用此值填充现有缺失（NaN）值和任何新元素，以确保数据帧对齐成功。如果两个对应数据帧位置的数据都缺失，则结果将缺失。
返回：
数据帧
算术操作的结果。
另请参见
DataFrame.add
添加数据帧。
DataFrame.sub
减去数据帧。
DataFrame.mul
乘以数据帧。
DataFrame.div
数据帧除法（浮点除法）。
DataFrame.truediv
数据帧除法（浮点除法）。
DataFrame.floordiv
数据帧除法（整数除法）。
DataFrame.mod
计算模数（除法后的余数）。
DataFrame.pow
计算指数幂。
注意
不匹配的索引将被合并。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用运算符版本添加一个标量，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本按常数除以。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用运算符版本按轴减去列表和系列。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
按轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用运算符版本乘以不同形状的数据帧。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.floordiv
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.floordiv.html
DataFrame.floordiv(other, axis='columns', level=None, fill_value=None)
获取 DataFrame 和其他数据的整数除法，逐元素（二进制运算符 floordiv）。
等同于 dataframe // other，但支持在输入的一个中替换缺失数据的 fill_value。反向版本是 rfloordiv。
在灵活的包装器（add、sub、mul、div、floordiv、mod、pow）中进行算术运算：+、-、*、/、//、%、**。
参数：
other标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于 Series 输入，要匹配 Series 索引的轴。
levelint 或 标签
在一个级别上广播，匹配通过 MultiIndex 级别传递的 Index 值。
fill_valuefloat 或 None，默认为 None
在计算之前，使用此值填充现有的缺失值（NaN），以及任何需要成功对齐 DataFrame 的新元素。如果相应 DataFrame 位置中的数据都丢失，则结果将丢失。
返回：
DataFrame
算术运算的结果。
另请参阅
添加 DataFrame。
减去 DataFrame。
乘以 DataFrame。
划分 DataFrame（浮点除法）。
划分 DataFrame（浮点除法）。
划分 DataFrame（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注意事项
不匹配的索引将被并集在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用运算符版本添加一个标量，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用运算符版本将列表和 Series 按轴相减。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
沿轴相乘字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用运算符版本将不同形状的 DataFrame 相乘。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别划分 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.mod
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.mod.html
DataFrame.mod(other, axis='columns', level=None, fill_value=None)
获取 dataframe 和其他的模数，逐元素（二进制运算符 mod）。
等同于 dataframe % other，但支持在输入的一个中替换缺失数据的 fill_value。使用反向版本，rmod。
在灵活的包装器中（add、sub、mul、div、floordiv、mod、pow）对算术运算符进行操作：+、-、*、/、//、%、**。
参数：
other 标量，序列，Series，字典或 DataFrame
任何单个或多个元素的数据结构，或类似列表的对象。
axis
是否按索引（0 或 ‘index’）或列（1 或 ‘columns’）进行比较。对于 Series 输入，要匹配 Series 索引的轴。
levelint 或 标签
广播跨级别，在传递的 MultiIndex 级别上匹配索引值。
fill_valuefloat 或 None，默认 None
在计算之前，使用此值填充现有的缺失值（NaN），以及成功 DataFrame 对齐所需的任何新元素。如果在对应的 DataFrame 位置上的数据都缺失，则结果将是缺失的。
返回：
DataFrame
算术运算的结果。
另请参阅
DataFrame.add
添加 DataFrames。
DataFrame.sub
减去 DataFrames。
DataFrame.mul
乘以 DataFrames。
DataFrame.div
划分 DataFrames（浮点数除法）。
DataFrame.truediv
划分 DataFrames（浮点数除法）。
DataFrame.floordiv
划分 DataFrames（整数除法）。
DataFrame.mod
计算模数（除法后的余数）。
DataFrame.pow
计算指数幂。
注释
不匹配的索引将合并在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量，使用操作符版本返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本按常数划分。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用操作符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
乘以轴的字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用操作符版本乘以不同形状的 DataFrame。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别（level）划分 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.pow
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.pow.html
DataFrame.pow(other, axis='columns', level=None, fill_value=None)
获取 DataFrame 和其他元素的指数幂，逐元素进行（二进制操作符 pow）。
等同于 dataframe ** other，但支持用 fill_value 替换一个输入中的缺失数据。带有反向版本，rpow。
在灵活的算术运算符包装器（add、sub、mul、div、floordiv、mod、pow）中：+、-、*、/、//、%、**。
参数：
other标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或 ‘index’）或列（1 或 ‘columns’）进行比较。对于 Series 输入，要匹配 Series 索引。
level整数或标签
在通过的 MultiIndex 级别上广播，与索引值匹配。
fill_valuefloat 或 None，默认为 None
在进行 DataFrame 对齐之前，使用此值填充现有缺失（NaN）值以及任何需要的新元素。如果对应 DataFrame 位置中的数据都丢失，则结果将丢失。
返回：
DataFrame
算术运算的结果。
另请参阅
DataFrame.add
添加 DataFrames。
DataFrame.sub
减去 DataFrames。
DataFrame.mul
将 DataFrames 相乘。
DataFrame.div
除 DataFrames（浮点除法）。
DataFrame.truediv
除 DataFrames（浮点除法）。
DataFrame.floordiv
除 DataFrames（整数除法）。
DataFrame.mod
计算模数（除法后的余数）。
DataFrame.pow
计算指数幂。
注意事项
不匹配的索引将被并集在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用操作符版本添加标量，返回相同结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本以常数除。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
用操作符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
将字典乘以轴。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
用操作符版本将不同形状的 DataFrame 相乘。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.dot
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.dot.html
DataFrame.dot(other)
计算 DataFrame 与 other 之间的矩阵乘积。
此方法计算 DataFrame 与另一个 Series、DataFrame 或 numpy 数组的值之间的矩阵乘积。
也可以使用 self @ other 调用。
参数：
otherSeries、DataFrame 或类似数组
与之计算矩阵乘积的其他对象。
返回：
Series 或 DataFrame
如果 other 是一个 Series，则返回 self 和 other 之间的矩阵乘积作为 Series。如果 other 是 DataFrame 或 numpy.array，则返回 self 和 other 的矩阵乘积作为 DataFrame 或 np.array。
另请参阅
Series.dot
用于 Series 的类似方法。
注意
DataFrame 和 other 的维度必须兼容才能进行矩阵乘法计算。此外，DataFrame 的列名称和 other 的索引必须包含相同的值，因为它们将在乘法之前对齐。
Series 的 dot 方法计算内积，而不是这里的矩阵乘积。
示例
这里我们将 DataFrame 与 Series 相乘。
>>> df = pd.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]])
>>> s = pd.Series([1, 1, 2, 1])
>>> df.dot(s)
0 -4
1 5
dtype: int64
这里我们将 DataFrame 与另一个 DataFrame 相乘。
>>> other = pd.DataFrame([[0, 1], [1, 2], [-1, -1], [2, 0]])
>>> df.dot(other)
0 1
0 1 4
1 2 2
注意 dot 方法给出与 @ 相同的结果
>>> df @ other
0 1
0 1 4
1 2 2
点方法也适用于 other 是 np.array 的情况。
>>> arr = np.array([[0, 1], [1, 2], [-1, -1], [2, 0]])
>>> df.dot(arr)
0 1
0 1 4
1 2 2
注意对象的洗牌不会改变结果。
>>> s2 = s.reindex([1, 0, 2, 3])
>>> df.dot(s2)
0 -4
1 5
dtype: int64
pandas.DataFrame.radd
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.radd.html
DataFrame.radd(other, axis='columns', level=None, fill_value=None)
获取数据框和其他元素的加法，逐元素进行（二进制运算符 radd）。
等同于other + dataframe，但支持在输入中的一个缺失数据的情况下替换 fill_value。使用反向版本，添加。
在灵活的包装器（add、sub、mul、div、floordiv、mod、pow）中进行算术运算：+、-、*、/、//、%、**。
参数：
其他标量、序列、Series、字典或 DataFrame。
任何单个或多个元素数据结构，或类似列表的对象。
轴
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于 Series 输入，要匹配 Series 索引的轴。
级别整数或标签。
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_value浮点数或 None，默认为 None。
在计算之前，用这个值填充现有的缺失（NaN）值，以及任何需要成功数据框对齐的新元素。如果对应的数据框位置中的数据都缺失，则结果将缺失。
返回：
DataFrame
算术操作的结果。
参见
添加数据框。
减去数据框。
乘以数据框。
划分数据框（浮点除法）。
划分数据框（浮点除法）。
划分数据框（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注意
不匹配的索引将被联合在一起。
示例。
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个返回相同结果的操作符版本的标量。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
用操作符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
乘以轴的字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
用操作符版本减去不同形状的数据框。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rsub
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rsub.html
DataFrame.rsub(other, axis='columns', level=None, fill_value=None)
以逐元素方式获取数据框和其他数据框的减法（二进制运算符 rsub）。
等同于other - dataframe，但支持在其中一个输入中替换缺失数据的填充值。有反向版本，sub。
在算术运算符的灵活包装器（add、sub、mul、div、floordiv、mod、pow）中：+、-、*、/、//、%、**。
参数：
other标量、序列、系列、字典或数据框
任何单个或多个元素的数据结构，或类似列表的对象。
axis
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于系列输入，要匹配的轴是系列索引。
level整数或标签
在通过传递的多重索引级别上广播，匹配索引值。
fill_value浮点数或 None，默认为 None
在计算之前，用这个值填充现有的缺失（NaN）值，以及任何需要的新元素，以成功地对齐数据框。如果两个对应的数据框位置的数据都缺失了，结果将是缺失的。
返回：
数据框
算术运算的结果。
另请参阅
添加数据框。
减去数据框。
乘以数据框。
除以数据框（浮点除法）。
除以数据框（浮点除法）。
除以数据框（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注释
不匹配的索引将被并入一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量与运算符版本，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
使用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用运算符版本按轴减去列表和系列。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
按轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用运算符版本将形状不同的数据框相乘。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以多重索引。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rmul
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rmul.html
DataFrame.rmul(other, axis='columns', level=None, fill_value=None)
获取 DataFrame 和其他元素的乘法，逐元素进行（二进制运算符 rmul）。
等同于other * dataframe，但支持在输入的其中一个数据中替换缺失数据的填充值。具有反向版本的乘法。
在算术运算符（+，-，，/，//，%，**）的灵活包装器（add，sub，mul，div，floordiv，mod，pow）中之一：+，-，，/，//，%，**。
参数：
other标量，序列，Series，字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
轴
是否按索引比较（0 或'index'）或列（1 或'columns'）。对于 Series 输入，要匹配的轴上的 Series 索引。
级别整数或标签
广播跨级别，在传递的 MultiIndex 级别上匹配索引值。
fill_value浮点数或 None，默认为 None
在进行 DataFrame 对齐之前，用此值填充现有缺失（NaN）值以及任何需要成功 DataFrame 对齐的新元素。如果对应的 DataFrame 位置的数据都缺失，则结果将缺失。
返回：
DataFrame
算术运算的结果。
另请参阅
DataFrame.add
添加 DataFrame。
DataFrame.sub
减去 DataFrame。
DataFrame.mul
乘以 DataFrame。
DataFrame.div
划分 DataFrame（浮点除法）。
DataFrame.truediv
划分 DataFrame（浮点除法）。
DataFrame.floordiv
划分 DataFrame（整数除法）。
DataFrame.mod
计算模（除法后的余数）。
DataFrame.pow
计算指数幂。
注意事项
不匹配的索引将合并在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用返回相同结果的运算符版本添加标量。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
通过反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用运算符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
将字典按轴乘以。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
使用运算符版本乘以形状不同的 DataFrame。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别划分一个多级索引。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rdiv
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rdiv.html
DataFrame.rdiv(other, axis='columns', level=None, fill_value=None)
获取 DataFrame 和其他数据的浮点数除法，逐元素（二进制运算符 rtruediv）。
等同于other / dataframe，但支持用一个输入中的缺失数据的 fill_value 替换。使用反向版本，truediv。
在灵活的包装器中（add、sub、mul、div、floordiv、mod、pow）到算术运算符：+、-、*、/、//、%、**。
参数：
other标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于 Series 输入，与 Series 索引匹配的轴。
level整数或标签
在传递的 MultiIndex 级别上广播，匹配索引值跨级。
fill_value浮点数或 None，默认为 None
在进行 DataFrame 对齐之前，填充现有缺失值（NaN）和任何新需要的元素，使其成功对齐 DataFrame 的值。如果对应的 DataFrame 位置中的数据都缺失，则结果将缺失。
返回：
DataFrame
算术运算的结果。
另请参见
添加 DataFrames。
减去 DataFrames。
对 DataFrame 进行乘法运算。
对 DataFrame 进行除法运算（浮点数除法）。
对 DataFrame 进行除法运算（浮点数除法）。
对 DataFrame 进行除法运算（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注意
不匹配的索引将被联合在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用运算符版本添加一个标量，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用运算符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
按轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
用运算符版本乘以不同形状的 DataFrame。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rtruediv
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rtruediv.html
DataFrame.rtruediv(other, axis='columns', level=None, fill_value=None)
获取 DataFrame 和其他的浮点除法，逐元素（二进制运算符 rtruediv）。
等同于 other / dataframe，但支持用填充值替换输入中的缺失数据。有逆向版本，truediv。
在柔性包装器（add、sub、mul、div、floordiv、mod、pow）中之间执行算术运算符：+、-、*、/、//、%、**。
参数：
other标量、序列、Series、字典或 DataFrame
任何单个或多个元素的数据结构，或类似列表的对象。
轴
是否按索引比较（0 或 'index'）还是按列比较（1 或 'columns'）。对于 Series 输入，要匹配 Series 索引的轴。
级别int 或标签
在一个级别上广播，匹配传递的 MultiIndex 级别上的索引值。
fill_valuefloat 或 None，默认为 None
在进行 DataFrame 对齐之前，填充现有缺失（NaN）值，并在计算成功的 DataFrame 对齐所需的任何新元素。如果两个对应的 DataFrame 位置中的数据都缺失，则结果将缺失。
返回：
DataFrame
算术操作的结果。
另请参阅
DataFrame.add
将 DataFrame 相加。
DataFrame.sub
将 DataFrame 相减。
DataFrame.mul
将 DataFrame 相乘。
DataFrame.div
除以 DataFrame（浮点除法）。
DataFrame.truediv
除以 DataFrame（浮点除法）。
DataFrame.floordiv
除以 DataFrame（整数除法）。
DataFrame.mod
计算取模（除法后的余数）。
DataFrame.pow
计算指数幂。
注释
不匹配的索引将被联合在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用操作符版本添加标量，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
用逆向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
使用操作符版本按轴减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
将字典与轴相乘。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
将不同形状的 DataFrame 与运算符版本相乘。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rfloordiv
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rfloordiv.html
DataFrame.rfloordiv(other, axis='columns', level=None, fill_value=None)
获取数据帧和其他的整数除法，逐元素进行（二进制操作 rfloordiv）。
等同于 other // dataframe，但支持用 fill_value 替换输入中的一个缺失数据。使用反向版本，floordiv。
在算术运算符的灵活包装器中（add、sub、mul、div、floordiv、mod、pow）：+、-、*、/、//、%、**。
参数：
other标量，序列，系列，字典或数据帧
任何单个或多个元素的数据结构，或类似列表的对象。
axis
是否按索引比较（0 或 ‘index’）或列（1 或 ‘columns’）。对于系列输入，要匹配系列索引的轴。
level整数或标签
在一个级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。
fill_value浮点数或无，默认为 None
在计算之前，使用此值填充现有的缺失值（NaN），以及为了成功的数据帧对齐所需的任何新元素。如果两个对应的数据帧位置都缺少数据，则结果将缺失。
返回：
数据帧
算术操作的结果。
另请参阅
DataFrame.add
添加数据帧。
DataFrame.sub
减去数据帧。
DataFrame.mul
乘以数据帧。
DataFrame.div
除以数据帧（浮点除法）。
DataFrame.truediv
除以数据帧（浮点除法）。
DataFrame.floordiv
除以数据帧（整数除法）。
DataFrame.mod
计算模数（除法后的余数）。
DataFrame.pow
计算指数幂。
注释
不匹配的索引将被合并在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
使用运算符版本添加标量，返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
用运算符版本按轴减去列表和系列。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
乘以字典按轴。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
用运算符版本乘以不同形状的数据帧。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别划分 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rmod
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rmod.html
DataFrame.rmod(other, axis='columns', level=None, fill_value=None)
以元素方式获取数据框和其他数据的模（二元运算符 rmod）。
等效于other % dataframe，但支持在输入中的一个缺失数据时替换填充值的支持。使用反向版本 mod。
在对算术运算符的灵活包装（add、sub、mul、div、floordiv、mod、pow）中：+、-、*、/、//、%、**。
参数：
other标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis
是否按索引（0 或‘index’）或列（1 或‘columns’）进行比较。对于 Series 输入，轴以匹配 Series 索引。
level整数或标签
在一个级别上广播，匹配传递的 MultiIndex 级别上的 Index 值。
fill_value浮点数或无，默认为无
在计算之前，用这个值填充现有的缺失（NaN）值，以及成功 DataFrame 对齐所需的任何新元素。如果对应的 DataFrame 位置都缺少数据，结果将是缺失的。
返回：
DataFrame
算术操作的结果。
另请参阅
添加数据框。
减去数据框。
乘以数据框。
划分数据框（浮点数除法）。
划分数据框（浮点数除法）。
划分数据框（整数除法）。
计算模（除法后的余数）。
计算指数幂。
注释
不匹配的索引将被并集在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个返回相同结果的标量和运算符版本。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
用反向版本除以常数。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
通过轴用运算符版本减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
用轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
用运算符版本乘以不同形状的数据框。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.rpow
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.rpow.html
DataFrame.rpow(other, axis='columns', level=None, fill_value=None)
获取数据框和其他的指数幂，逐元素（二进制运算符 rpow）。
等同于other ** dataframe，但支持用填充值替换其中一个输入中的缺失数据。具有反向版本，pow。
在灵活的包装器（add、sub、mul、div、floordiv、mod、pow）中进行算术运算：+、-、*、/、//、%、**。
参数：
其他标量、序列、Series、字典或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
轴
是否按索引（0 或'index'）或列（1 或'columns'）进行比较。对于 Series 输���，要匹配 Series 索引。
级别整数或标签
在一个级别上广播，匹配传递的 MultiIndex 级别上的 Index 值。
fill_value浮点数或 None，默认为 None
在计算之前，用此值填充现有缺失（NaN）值，以及成功对齐数据框所需的任何新元素。如果两个对应的数据框位置的数据都丢失，则结果将丢失。
返回：
数据框
算术操作的结果。
另请参阅
添加数据框。
减去数据框。
乘以数据框。
划分数据框（浮点除法）。
划分数据框（浮点除法）。
划分数据框（整数除法）。
计算模数（除法后的余数）。
计算指数幂。
注意
不匹配的索引将被合并在一起。
示例
>>> df = pd.DataFrame({'angles': [0, 3, 4],
... 'degrees': [360, 180, 360]},
... index=['circle', 'triangle', 'rectangle'])
>>> df
angles degrees
circle 0 360
triangle 3 180
rectangle 4 360
添加一个标量，使用运算符版本返回相同的结果。
>>> df + 1
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
>>> df.add(1)
angles degrees
circle 1 361
triangle 4 181
rectangle 5 361
通过常数除以反向版本。
>>> df.div(10)
angles degrees
circle 0.0 36.0
triangle 0.3 18.0
rectangle 0.4 36.0
>>> df.rdiv(10)
angles degrees
circle inf 0.027778
triangle 3.333333 0.055556
rectangle 2.500000 0.027778
通过轴用运算符版本减去列表和 Series。
>>> df - [1, 2]
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub([1, 2], axis='columns')
angles degrees
circle -1 358
triangle 2 178
rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
... axis='index')
angles degrees
circle -1 359
triangle 2 179
rectangle 3 359
通过轴乘以字典。
>>> df.mul({'angles': 0, 'degrees': 2})
angles degrees
circle 0 720
triangle 0 360
rectangle 0 720
>>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
angles degrees
circle 0 0
triangle 6 360
rectangle 12 1080
用运算符版本乘以不同形状的数据框。
>>> other = pd.DataFrame({'angles': [0, 3, 4]},
... index=['circle', 'triangle', 'rectangle'])
>>> other
angles
circle 0
triangle 3
rectangle 4
>>> df * other
angles degrees
circle 0 NaN
triangle 9 NaN
rectangle 16 NaN
>>> df.mul(other, fill_value=0)
angles degrees
circle 0 0.0
triangle 9 0.0
rectangle 16 0.0
按级别除以 MultiIndex。
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
... 'degrees': [360, 180, 360, 360, 540, 720]},
... index=[['A', 'A', 'A', 'B', 'B', 'B'],
... ['circle', 'triangle', 'rectangle',
... 'square', 'pentagon', 'hexagon']])
>>> df_multindex
angles degrees
A circle 0 360
triangle 3 180
rectangle 4 360
B square 4 360
pentagon 5 540
hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0)
angles degrees
A circle NaN 1.0
triangle 1.0 1.0
rectangle 1.0 1.0
B square 0.0 0.0
pentagon 0.0 0.0
hexagon 0.0 0.0
pandas.DataFrame.lt
原文：
pandas.pydata.org/docs/reference/api/pandas.DataFrame.lt.html
DataFrame.lt(other, axis='columns', level=None)
获取 DataFrame 和其他对象逐元素的小于比较结果（二进制运算符 lt）。
与比较运算符的灵活封装（eq、ne、le、lt、ge、gt）。
等同于 ==、!=、<=、<、>=、>，支持选择轴（行或列）和级别进行比较。
参数：
other标量、序列、Series 或 DataFrame
任何单个或多个元素数据结构，或类似列表的对象。
axis，默认为 ‘columns’
是否按索引（0 或 ‘index’）或列（1 或 ‘columns’）进行比较。
level整数或标签
在一个级别上进行广播，匹配传递的 MultiIndex 级别上的索引值。
返回：
布尔值的 DataFrame
比较的结果。
另请参阅
逐元素比较 DataFrame 是否相等。
逐元素比较 DataFrame 是否不等。
逐元素比较 DataFrame 是否小于或等于另一个 DataFrame。
DataFrame.lt
逐元素比较 DataFrame 是否严格小于。
逐元素比较 DataFrame 是否大于或等于另一个 DataFrame。
逐元素比较 DataFrame 是否严格大于。
注意
不匹配的索引将被合并在一起。NaN 值被视为不同（即 NaN != NaN）。
示例
>>> df = pd.DataFrame({'cost': [250, 150, 100],
... 'revenue': [100, 250, 300]},
... index=['A', 'B', 'C'])
>>> df
cost revenue
A 250 100
B 150 250
C 100 300
使用标量进行比较，可以使用运算符或方法：
>>> df == 100
cost revenue
A False True
B False False
C True False
>>> df.eq(100)
cost revenue
A False True
B False False
C True False
当其他是一个 Series 时，DataFrame 的列与其他的索引对齐并进行广播：
>>> df != pd.Series([100, 250], index=["cost", "revenue"])
cost revenue
A True True
B True False
C False True
使用该方法来控制广播轴：
>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index')
cost revenue
A True False
B True True
C True True
D True True
当与任意序列进行比较时，列数必须与其他元素的数量相匹配：
>>> df == [250, 100]
cost revenue
A True True
B False False
C False False
使用该方法来控制轴：
>>> df.eq([250, 250, 100], axis='index')
cost revenue
A True False
B False True
C True False
与不同形状的 DataFrame 进行比较。
>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]},
... index=['A', 'B', 'C', 'D'])
>>> other
revenue
A 300
B 250
C 100
D 150
>>> df.gt(other)
cost revenue
A False False
B False False
C False True
D False False
与 MultiIndex 按级别进行比较。
>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220],
... 'revenue': [100, 250, 300, 200, 175, 225]},
... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'],
... ['A', 'B', 'C', 'A', 'B', 'C']])
>>> df_multindex
cost revenue
Q1 A 250 100
B 150 250
C 100 300
Q2 A 150 200
B 300 175
C 220 225
>>> df.le(df_multindex, level=1)
cost revenue
Q1 A True True
B True True
C True True
Q2 A False True
B True False
C True False
