Pandas 2.2 中文文件（二十）
原文：
pandas.pydata.org/docs/
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.itertuples
遍歷 DataFrame 行，返回值為值的命名元組。
DataFrame.items
遍歷（列名，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。
另請參見
eval
評估描述 DataFrame 列操作的字串。
DataFrame.eval
評估描述 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
新增資料幀。
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
使用運算子版本乘以不同形狀的 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
算術運算的結果。
另請參見
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.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.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.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
算術操作的結果。
參見
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
按級別除以 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）值，以及任何需要的新元素，以成功地對齊資料框。如果兩個對應的資料框位置的資料都缺失了，結果將是缺失的。
返回：
資料框
算術運算的結果。
另請參閱
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
按級別除以多重索引。
>>> 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
算術運算的結果。
另請參見
DataFrame.add
新增 DataFrames。
DataFrame.sub
減去 DataFrames。
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.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
算術操作的結果。
另請參閱
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
按級別除以 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）值，以及成功對齊資料框所需的任何新元素。如果兩個對應的資料框位置的資料都丟失，則結果將丟失。
返回：
資料框
算術操作的結果。
另請參閱
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
按級別除以 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.eq
逐元素比較 DataFrame 是否相等。
DataFrame.ne
逐元素比較 DataFrame 是否不等。
DataFrame.le
逐元素比較 DataFrame 是否小於或等於另一個 DataFrame。
DataFrame.lt
逐元素比較 DataFrame 是否嚴格小於。
DataFrame.ge
逐元素比較 DataFrame 是否大於或等於另一個 DataFrame。
DataFrame.gt
逐元素比較 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