「目录」
6.1 => Pandas的数据结构
6.2 => Pandas的基本功能
--------> reindex重新索引
--------> drop丢弃数据
--------> 索引和选取
--------> 算术运算
6.3 => 数学和统计方法
pandas的算术运算
pandas创始人说，pandas最重要的一个功能是可以对不同索引的对象进行算术运算。
在将对象（Series或DataFrame）相加时，如果存在不同的索引，结果的索引就是这些索引的并集。
没看懂的话，下面看几个例子：
对于Series
In [1]: import pandas as pd
In [2]: s1 = pd.Series([1, 2, 3, 4], index=['a', 'c', 'd', 'e'])
In [3]: s2 = pd.Series([5, 6, 7, 8], index=['a', 'c', 'e', 'f', 'g'])
In [4]: s1
Out[4]:
a 1
c 2
d 3
e 4
dtype: int64
In [5]: s2
Out[5]:
a 5
c 6
e 7
f 8
g 9
dtype: int64复制
这里s1和s2的索引有部分不一样，将他们相加就会：
In [7]: s1 + s2
Out[7]:
a 6.0
c 8.0
d NaN
e 11.0
f NaN
g NaN
dtype: float64复制
❝NaN是Not a Number的意思
❞
自动的数据对齐操作会在不重叠的索引处引入NA值。
对于DataFrame
In [10]: import numpy as np
In [11]: df1 = pd.DataFrame(np.arange(9).reshape((3, 3)), index = ['Shanghai', 'Beijing', 'Chengdu'], columns = ['a', 'b', 'c'] )
In [12]: df2 = pd.DataFrame(np.arange(12).reshape((4, 3)), index = ['Shanghai', 'Beijing', 'Shenzhen', 'Chengdu'], columns = ['b', 'c', 'd'])
In [13]: df1
Out[13]:
a b c
Shanghai 0 1 2
Beijing 3 4 5
Chengdu 6 7 8
In [14]: df2
Out[14]:
b c d
Shanghai 0 1 2
Beijing 3 4 5
Shenzhen 6 7 8
Chengdu 9 10 11复制
将df1和df2相加后会返回一个新的DataFrame，索引和列为原来两个DataFrame的并集：
In [20]: df1 + df2
Out[20]:
a b c d
Beijing NaN 7.0 9.0 NaN
Chengdu NaN 16.0 18.0 NaN
Shanghai NaN 1.0 3.0 NaN
Shenzhen NaN NaN NaN NaN复制
填充值
我们可以看到在对不同索引的对象进行算术运算时，如果某个对象中找不到对应位置的值（NaN），可以填充一个值。
以上面为例，可以使用df1的add方法，传入df2以及一个fill_value参数：
In [5]: df1.add(df2, fill_value=0)
Out[5]:
a b c d
Beijing 3.0 7.0 9.0 5.0
Chengdu 6.0 16.0 18.0 11.0
Shanghai 0.0 1.0 3.0 2.0
Shenzhen NaN 6.0 7.0 8.0复制
你看上面df1的（Beijing, a）项找不到df2的（Beijing, a）项时，用填充值（fill_value=0）代替了，所以结果不再是NaN，而是3+0=3。
翻转参数
flip参数，除了下面例子的div和rdiv，还有add和radd等，用法看例子就懂了：
In [8]: 1 / df1
Out[8]:
a b c
Shanghai inf 1.000000 0.500
Beijing 0.333333 0.250000 0.200
Chengdu 0.166667 0.142857 0.125
In [9]: df1.rdiv(1)
Out[9]:
a b c
Shanghai inf 1.000000 0.500
Beijing 0.333333 0.250000 0.200
Chengdu 0.166667 0.142857 0.125复制
❝inf代表infinity，无穷的意思
❞
DataFrame和Series之间的运算
默认情况，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列索引，然后一行一行向下传播（broadcast):
In [10]: frame = pd.DataFrame(np.arange(12).reshape(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])
In [11]: series = frame.iloc[0]
In [12]: frame
Out[12]:
b d e
Utah 0 1 2
Ohio 3 4 5
Texas 6 7 8
Oregon 9 10 11
In [13]: series
Out[13]:
b 0
d 1
e 2
Name: Utah, dtype: int32
In [14]: frame - series
Out[14]:
b d e
Utah 0 0 0
Ohio 3 3 3
Texas 6 6 6
Oregon 9 9 9复制
当某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象的索引会形成并集，像下面这样：
In [15]: series2 = pd.Series(range(3), index=['b', 'e', 'f'])
In [16]: series2
Out[16]:
b 0
e 1
f 2
dtype: int64
In [18]: frame + series2
Out[18]:
b d e f
Utah 0.0 NaN 3.0 NaN
Ohio 3.0 NaN 6.0 NaN
Texas 6.0 NaN 9.0 NaN
Oregon 9.0 NaN 12.0 NaN复制
如果我们要沿着列传播，要使用算术运算方法，传入参数axis='index'或者axis=0代表我们要匹配index的轴，然后一列一列进行算术运算：
In [19]: series3 = frame['d']
In [20]: series3
Out[20]:
Utah 1
Ohio 4
Texas 7
Oregon 10
Name: d, dtype: int32
In [21]: frame.sub(series3, axis='index')
Out[21]:
b d e
Utah -1 0 1
Ohio -1 0 1
Texas -1 0 1
Oregon -1 0 1复制
往期回顾
stay hungry, stay foolish.
记得点在看啦
