「目录」

• 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