8.Pandas基本操作（2）

1.算术与数据对齐：

不同索引对象之间进行算术操作时，如果存在某个索引对不相同时，返回的结果是索引对的并集，在没有交集的位置会用NaN值来填充缺失值。

s1 = pd.Series([1,2,3,4],index=['a','b','c','d'])

s2 = pd.Series([5,6,7,8],index=['a','b','e','f'])

s1
Out[4]: 
a    1
b    2
c    3
d    4
dtype: int64

s2
Out[5]: 
a    5
b    6
e    7
f    8
dtype: int64

s1 + s2
Out[6]: 
a    6.0
b    8.0
c    NaN
d    NaN
e    NaN
f    NaN
dtype: float64

df1 = pd.DataFrame(np.arange(9).reshape((3,3)),columns=['a','b','c'],index=['行1','行2','行3'])

df1
Out[9]: 
    a  b  c
行1  0  1  2
行2  3  4  5
行3  6  7  8

df2 = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行4','行2','行3','行5'])

df2
Out[11]: 
    b   d   e
行4  0   1   2
行2  3   4   5
行3  6   7   8
行5  9  10  11

df1 + df2
Out[12]: 
     a     b   c   d   e
行1 NaN   NaN NaN NaN NaN
行2 NaN   7.0 NaN NaN NaN
行3 NaN  13.0 NaN NaN NaN
行4 NaN   NaN NaN NaN NaN
行5 NaN   NaN NaN NaN NaN

通过fill_value属性,进行算术运算时，相当于加两个数据集合并取并集，而不是像上面取交集。

df1 = pd.DataFrame(np.arange(9).reshape((3,3)),columns=['a','b','c'],index=['行1','行2','行3'])

df2 = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行4','行2','行3','行5'])

df1.add(df2,fill_value=0)
Out[18]: 
      a     b    c     d     e
行1  0.0   1.0  2.0   NaN   NaN
行2  3.0   7.0  5.0   4.0   5.0
行3  6.0  13.0  8.0   7.0   8.0
行4  NaN   0.0  NaN   1.0   2.0
行5  NaN   9.0  NaN  10.0  11.0

2.DataFrame和Series间的操作：

DataFrame和Series间的算术操作与Numpy中不同维度数组间的操作类似。
默认情况下，DataFrame和Series间的算术操作会将Series的索引与DataFrame的列进行匹配，并广播到各行。

dataframe = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行1','行2','行3','行4'])

dataframe
Out[6]: 
    b   d   e
行1  0   1   2
行2  3   4   5
行3  6   7   8
行4  9  10  11

series = dataframe.iloc[0]

series
Out[8]: 
b    0
d    1
e    2
Name: 列1, dtype: int32

dataframe - series
Out[9]: 
    b  d  e
行1  0  0  0
行2  3  3  3
行3  6  6  6
行4  9  9  9

如果一个索引值不在DataFrame的列中，也不在Series的索引中，则对象会重建索引并形成联合。

dataframe = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行1','行2','行3','行4'])

dataframe
Out[10]: 
    b   d   e
行1  0   1   2
行2  3   4   5
行3  6   7   8
行4  9  10  11

series_2 = pd.Series(range(3),index=['b','e','f'])

series_2
Out[11]: 
b    0
e    1
f    2
dtype: int64

dataframe + series_2
Out[12]: 
      b   d     e   f
行1  0.0 NaN   3.0 NaN
行2  3.0 NaN   6.0 NaN
行3  6.0 NaN   9.0 NaN
行4  9.0 NaN  12.0 NaN

也可以通过传递axis值用于在列上进行广播操作。

dataframe = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行1','行2','行3','行4'])

dataframe
Out[14]: 
    b   d   e
行1  0   1   2
行2  3   4   5
行3  6   7   8
行4  9  10  11

series_3 = dataframe['d']

series_3
Out[16]: 
行1     1
行2     4
行3     7
行4    10
Name: d, dtype: int32

dataframe.sub(series_3,axis=0)
Out[17]: 
    b  d  e
行1 -1  0  1
行2 -1  0  1
行3 -1  0  1

3.函数应用和映射：

Numpy的通用函数（逐元素数组方法）对Pandas对象也有效。

df = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行1','行2','行3','行4'])

df
Out[20]: 
    b   d   e
行1  0   1   2
行2  3   4   5
行3  6   7   8
行4  9  10  11

np.exp(df)
Out[21]: 
              b             d             e
行1     1.000000      2.718282      7.389056
行2    20.085537     54.598150    148.413159
行3   403.428793   1096.633158   2980.957987
行4  8103.083928  22026.465795  59874.141715

DataFrame的apply()方法可以实现将函数应用到一行或一列的一维数组上，通过指定axis值将函数作用于指定轴。

f = lambda x :x.max()-x.min()

df = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行1','行2','行3','行4'])

df
Out[27]: 
    b   d   e
行1  0   1   2
行2  3   4   5
行3  6   7   8
行4  9  10  11

df.apply(f)
Out[28]: 
b    9
d    9
e    9
dtype: int64

df.apply(f,axis='columns')
Out[29]: 
行1    2
行2    2
行3    2
行4    2
dtype: int64

df.apply(f,axis=0)
Out[30]: 
b    9
d    9
e    9
dtype: int64

df.apply(f,axis=1)
Out[31]: 
行1    2
行2    2
行3    2
行4    2
dtype: int64

传递的函数f可以返回带有多个值的Series。

df = pd.DataFrame(np.arange(12).reshape((4,3)),columns=['b','d','e'],index=['行1','行2','行3','行4'])

df
Out[34]: 
    b   d   e
行1  0   1   2
行2  3   4   5
行3  6   7   8
行4  9  10  11

def f(x):
    return pd.Series([x.min(),x.max()],index=['min','max'])


df.apply(f)
Out[35]: 
     b   d   e
min  0   1   2
max  9  10  11

4.排序：

使用sort_index()方法可以按行货列索引进行字典型排序，返回一个新的、排序好的对象。

• Series类型

使用sort_index()方法对索引进行排序。
使用sort_values()方法对值进行排序，如果有缺失值，默认排序在最后。

s = pd.Series(range(4),index=['d','b','a','c'])

s
Out[41]: 
d    0
b    1
a    2
c    3
dtype: int64

s.sort_index()
Out[42]: 
a    2
b    1
c    3
d    0
dtype: int64

# ascending=False参数指定排序按照降序排列
s.sort_values(ascending=False)
Out[43]: 
c    3
a    2
b    1
d    0
dtype: int64

s2 = pd.Series([5,np.nan,3,np.nan,7,2])

s2.sort_values()
Out[46]: 
5    2.0
2    3.0
0    5.0
4    7.0
1    NaN
3    NaN
dtype: float64

• DataFrame类型

sort_index()方法可以在指定轴上按索引进行排序。

df = pd.DataFrame(np.arange(8).reshape((2,4)),index=[3,1],columns=['d','b','a','c'])

df.sort_index()
Out[37]: 
   d  b  a  c
1  4  5  6  7
3  0  1  2  3

df.sort_index(axis=1)
Out[38]: 
   a  b  c  d
3  2  1  3  0
1  6  5  7  4

df.sort_index(axis=1,ascending=False)
Out[39]: 
   d  c  b  a
3  0  3  1  2
1  4  7  5  6

通过设置sort_values()方法的可选参数by使用一列或多列作为排序键。

df = pd.DataFrame({'b':[4,7,-3,2],'a':[2,5,3,1]})

df
Out[49]: 
   a  b
0  2  4
1  5  7
2  3 -3
3  1  2

df.sort_values(by='b')
Out[50]: 
   a  b
2  3 -3
3  1  2
0  2  4
1  5  7

df.sort_values(by=['a','b'])
Out[51]: 
   a  b
3  1  2
0  2  4
2  3 -3
1  5  7

5.含有重复标签的轴索引：

is_unique()属性用于判断标签是否唯一。

s = pd.Series(range(5),index=['a','a','b','b','c'])

s
Out[65]: 
a    0
a    1
b    2
b    3
c    4
dtype: int64

s.index.is_unique
Out[66]: False

df = pd.DataFrame({'c':[4,7,-3,2],'b':[-5,2,3,9],'a':[2,5,3,1]})

df
Out[68]: 
   a  b  c
0  2 -5  4
1  5  2  7
2  3  3 -3
3  1  9  2

df.index.is_unique
Out[69]: True

Reference：
《Python for Data Analysis:Data Wrangling with Pandas,Numpy,and IPython》