Pandas中常见的数据处理功能(reindexing, drop, selection, sorting, mapping/apply..等)

Pandas有Seriers和DataFrame两大数据结构， Seriers 处理一唯数据， 每个数据有一个对应指针index。DataFrame 处理二维数据，每个数据有一个对应的index和一个对应的column。

关于Seriers和DataFrame更详细的内容请参考：

Seriers: Python数据处理库pandas中的Series数据结构简介\​​​​​​

DataFrame: Python数据处理库pandas中的DataFrame数据结构简介 

本文主要介绍 Pandas处理数据时常用到的一些基本功能， 更详细内容可以去看panda的online文档。

Reindexing 

Series

对指针重新索引， 如果新定义的指针没有对应数据，会用NaN自动补足. 

In [2]: obj = pd.Series([5.2, 2.1, -4.5, 2.65], index=['c', 'a', 'd', 'b'])

In [3]: obj
Out[3]: 
c    5.20
a    2.10
d   -4.50
b    2.65
dtype: float64


In [6]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'f'])

In [7]: obj2
Out[7]: 
a    2.10
b    2.65
c    5.20
d   -4.50
f     NaN
dtype: float64

DataFrame

可以分别按行 或 列 reindex

In [27]: frame = pd.DataFrame(np.random.randint(10, size=(3, 3)),
    ...:                      index=['d', 'b', 'a'],
    ...:                      columns=['three', 'four', 'one'])
    ...: 

In [28]: frame
Out[28]: 
   three  four  one
d      7     9    7
b      6     8    5
a      4     1    8

#default是按 行 reindex
In [29]: frame2 = frame.reindex(['a', 'b', 'c', 'd'])

In [30]: frame2
Out[30]: 
   three  four  one
a    4.0   1.0  8.0
b    6.0   8.0  5.0
c    NaN   NaN  NaN
d    7.0   9.0  7.0

#指定按列 reindex
In [31]: frame3 = frame.reindex(columns=['one', 'two', 'three', 'four'])

In [32]: frame3
Out[32]: 
   one  two  three  four
d    7  NaN      7     9
b    5  NaN      6     8
a    8  NaN      4     1

也可以用loc方法来reindex， 但是用loc方法 不会创造NaN数据出来。 

In [33]: frame.loc[['a', 'b', 'd'], ['one', 'three', 'four']]
Out[33]: 
   one  three  four
a    8      4     1
b    5      6     8
d    7      7     9

Dropping 

剔除某行某列数据， 这种方法默认会返回一个新的数据set. 

Series

In [34]: obj
Out[34]: 
c    5.20
a    2.10
d   -4.50
b    2.65
dtype: float64

In [35]: obj.drop('a')
Out[35]: 
c    5.20
d   -4.50
b    2.65
dtype: float64

In [36]: obj.drop(['a', 'c'])
Out[36]: 
d   -4.50
b    2.65
dtype: float64

DataFrame

In [40]: frame
Out[40]: 
   three  four  one
d      7     9    7
b      6     8    5
a      4     1    8

In [41]: frame.drop(['a', 'd'])
Out[41]: 
   three  four  one
b      6     8    5

#通过指定axis =1 或者axis='columns'来drop列
In [42]: frame.drop('one', axis=1)
Out[42]: 
   three  four
d      7     9
b      6     8
a      4     1

In [43]: frame.drop('one', axis='columns')
Out[43]: 
   three  four
d      7     9
b      6     8
a      4     1

Indexing 

Series

第一种方法： 通过类似于Numpy array的索引：

In [44]: obj
Out[44]: 
c    5.20
a    2.10
d   -4.50
b    2.65
dtype: float64

In [45]: obj['a']
Out[45]: 2.1

In [46]: obj[1]
Out[46]: 2.1

In [47]: obj[2:4]
Out[47]: 
d   -4.50
b    2.65
dtype: float64

In [48]: obj[['a', 'b']]
Out[48]: 
a    2.10
b    2.65
dtype: float64

In [49]: obj[[1, 3]]
Out[49]: 
a    2.10
b    2.65
dtype: float64

In [50]: obj[obj<0]
Out[50]: 
d   -4.5
dtype: float64

第二种方法： 通过loc/ iloc方法来索引。loc 是按index的名称来索引， iloc是按照index的所在位置来索引。

In [51]: obj.loc[['a', 'b']]
Out[51]: 
a    2.10
b    2.65
dtype: float64

如果index是整数integer的话， 用loc索引或者用第一种方法[]索引， 会把这个整数当成index，如下。

In [55]: obj1 = pd.Series([1, 2, 3], index=[2, 0, 1])

In [59]: obj1[[0, 1, 2]]
Out[59]: 
0    2
1    3
2    1
dtype: int64

In [60]: obj1.loc[[0, 1, 2]]
Out[60]: 
0    2
1    3
2    1
dtype: int64

在这种情况下， 若想通过位置来索引的话， 需要用iloc方法。

In [61]: obj1.iloc[[0, 1, 2]]
Out[61]: 
2    1
0    2
1    3
dtype: int64

注意：用第一种方法或者用loc方法时，如果index是整数，会把这个数当作索引指标， 这个时候就不能通过位置来索引了， 如：

In [67]: ser = pd.Series(np.arange(4))

In [68]: ser[-1]
KeyError: -1

 这里的索引指标是按照ser的index 0, 1, 2, 3 来的， -1没有在这index里面所以会有keyerror. 如果index不是整数的话， 没有问题， 因为他会把传入的数字当成位置指引，而非index指引：

In [69]: ser1 = pd.Series(np.arange(4), index=['a', 'b', 'c', 'd'])

In [70]: ser1[-1]
Out[70]: 3

DataFrame

第一种方法:

In [62]: frame
Out[62]: 
   three  four  one
d      7     9    7
b      6     8    5
a      4     1    8

In [63]: frame['three']
Out[63]: 
d    7
b    6
a    4
Name: three, dtype: int64

In [64]: frame[['three', 'one']]
Out[64]: 
   three  one
d      7    7
b      6    5
a      4    8

第二种方法：loc方法

In [65]: frame.loc['a', ['one', 'three']]
Out[65]: 
one      8
three    4
Name: a, dtype: int64

In [66]: frame.iloc[2, [2, 0]]
Out[66]: 
one      8
three    4
Name: a, dtype: int64

方程apply

In [82]: frame
Out[82]: 
   three  four  one
d      7     9    7
b      6     8    5
a      4     1    8

In [83]: f = lambda x: x.max() + x.min()

按行
In [84]: frame.apply(f)
Out[84]: 
three    11
four     10
one      13
dtype: int64

按列
In [85]: frame.apply(f, axis='columns')
Out[85]: 
d    16
b    13
a     9
dtype: int64

如果是element-wise 运算的话需要用applymap 而非apply 

In [82]: frame
Out[82]: 
   three  four  one
d      7     9    7
b      6     8    5
a      4     1    8

In [89]: f1 = lambda x: x+ 10

In [90]: frame.applymap(f1)
Out[90]: 
   three  four  one
d     17    19   17
b     16    18   15
a     14    11   18

Sorting 

按照某个指标排序， 比如指标排序， 或按内容排序。

Series

In [91]: obj
Out[91]: 
c    5.20
a    2.10
d   -4.50
b    2.65
dtype: float64

按指针排序
In [92]: obj.sort_index()
Out[92]: 
a    2.10
b    2.65
c    5.20
d   -4.50
dtype: float64

按内容排序
In [93]: obj.sort_values()
Out[93]: 
d   -4.50
a    2.10
b    2.65
c    5.20
dtype: float64

DataFrame

In [94]: frame
Out[94]: 
   three  four  one
d      7     9    7
b      6     8    5
a      4     1    8

按行index排序
In [95]: frame.sort_index()
Out[95]: 
   three  four  one
a      4     1    8
b      6     8    5
d      7     9    7

按列index排序
In [96]: frame.sort_index(axis=1)
Out[96]: 
   four  one  three
d     9    7      7
b     8    5      6
a     1    8      4

按降序排序
In [97]: frame.sort_index(axis=1, ascending=False)
Out[97]: 
   three  one  four
d      7    7     9
b      6    5     8
a      4    8     1

按指定列的内容排序
In [99]: frame.sort_values(by='one')
Out[99]: 
   three  four  one
b      6     8    5
d      7     9    7
a      4     1    8

参考自： Python for Data Analysis, 2nd Edition by Wes McKinney