python之pandas用法详解

pandas是基于numpy构建的，使得数据分析工作变得更快更简单的高级数据结构和操作工具。

一、pandas数据结构

两个主要的数据结构：Series和DataFrame。

1.1 Series

Series是一种类似于一维数组的对象，它由一维数组（各种numpy数据类型）以及一组与之相关的数据标签（即索引）组成，仅由一组数据即可产生最简单的Series.

Series的字符串表现形式为：索引在左边，值在右边。如果没有为数据指定索引，于是会自动创建一个0到N-1(N为数据的长度)的整数型索引。可以通过Series的values和index属性获取其数组表现形式和索引对象：

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

#**********************************Series*************************************
obj=Series([2,4,7,8,9,3])
"""obj=
0    2
1    4
2    7
3    8
4    9
5    3
dtype: int64
"""
obj.values    #return:array([2, 4, 7, 8, 9, 3], dtype=int64)
obj.index     #return: RangeIndex(start=0, stop=6, step=1)
#创建对数据点进行标记的索引
obj2=Series([2,4,7,8,9,3],index=['a','b','c','d','e','f'])
"""obj2=
a    2
b    4
c    7
d    8
e    9
f    3
dtype: int64
"""
obj2.index   #return:Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
#利用索引的方式选取Series的单个或一组值
obj2['c']   #return:7
obj2[['a','c','f']]
"""out:
a    2
c    7
f    3
dtype: int64
"""
#numpy数组运算（布尔型数组进行过滤、标量乘法、应用数学函数等）都会保留索引和值之间的链接
obj2[obj2>5]
obj2*2
np.exp(obj2)
"""
obj2[obj2>5]:      obj2*2:       np.exp(obj2):
c    7             a     4           a       7.389056
d    8             b     8           b      54.598150
e    9             c    14           c    1096.633158
dtype: int64       d    16           d    2980.957987
                   e    18           e    8103.083928
                   f     6           f      20.085537
                   dtype: int64      dtype: float64
"""
#可以将Series看成是一个有定长的有序字典，因为它是索引值到数据值的一个映射
#因此，一些字典函数也可以在这里使用：
'a' in obj2        #return:True
'h' in obj2        #return:False
2 in obj2.values   #return:True

#利用字典创建Series
dic={'l':1,'z':2,'h':3}
obj3=Series(dic)
"""obj3=
h    3
l    1
z    2
dtype: int64
"""
#若索引比字典的索引多，则与字典索引相匹配的则会被找到，并放置到相应的位置中
#而对应字找不到的索引，其结果则为NaN(即非数字，Not a Number，在pandas中，用于表示缺失或NA值)
ind=['l','z','h','a']
obj4=Series(dic,index=ind)
"""obj4=
l    1.0
z    2.0
h    3.0
a    NaN
dtype: float64
"""
#pandas中isnull和notnull函数用于检测缺失数据：
pd.isnull(obj4)    #等效于： obj4.isnull()
pd.notnull(obj4)
"""
pd.isnull(obj4):        pd.notnull(obj4)
l    False              l     True
z    False              z     True
h    False              h     True
a     True              a     False
dtype: bool             dtype: bool
"""
#算术运算中自动对齐不同索引的数据
obj3+obj4
"""out：
a    NaN
h    6.0
l    2.0
z    4.0
dtype: float64
"""
#Series对象本身及其索引都有一个name属性
obj4.name='myname'
obj4.index.name='letter'
"""obj4=
letter
l    1.0
z    2.0
h    3.0
a    NaN
Name: myname, dtype: float64
"""
#索引可以通过赋值的方式进行改变
obj4.index=['li','zi','hua','a']
"""obj4=
li     1.0
zi     2.0
hua    3.0
a      NaN
Name: myname, dtype: float64
"""

1.2 DataFrame

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（公用同一个索引）。跟其他类似的数据结构相比，DataFrame中面向行和面向列的操作基本是平衡的。其实，DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或者别的一维数据结构）。

其中，可以输入给DataFrame构造器的数据类型及相关说明：

#*******************************DataFrame*************************************
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
#构建DataFrame
#最常用的一种是直接传入一个由等长列表或numpy数组组成的字典：
data={'names':['Bob','Jane','Jack','Ann'],
       'sex':['M','F','M','F'],
       'age':[21,30,26,28]}
frame=DataFrame(data)
"""没有指定索引，会自动加上索引，且全部列会被有序排列
frame=
   age names sex
0   21   Bob   M
1   30  Jane   F
2   26  Jack   M
3   28   Ann   F
"""
#若指定列序列，则会按照指定顺序排列
frame=DataFrame(data,columns=['names','sex','age'])
"""frame=
  names sex  age
0   Bob   M   21
1  Jane   F   30
2  Jack   M   26
3   Ann   F   28
"""
#若传入列在数据中找不到，会返回NA值
frame1=DataFrame(data,columns=['names','sex','age','id'],index=['a','b','c','d'])
"""frame1=
  names sex  age   id
a   Bob   M   21  NaN
b  Jane   F   30  NaN
c  Jack   M   26  NaN
d   Ann   F   28  NaN
"""
#通过类似字典标记或属性的方式，可以获取Series（列数据）：
frame1['sex']
frame1.age
"""
frame1['sex']:                           frame1.age:
a    M                                    a      21
b    F                                    b      30
c    M                                    c      26
d    F                                    d      28
Name: sex, dtype: object                  Name: age, dtype: int64
"""
#行也可以通过位置或名称获取
#ix VS loc VS iloc
#loc——通过行标签索引行数据
frame1.loc('c')
#等效于
#iloc——通过行号获取行数据
frame1.iloc[2]
#ix--以上两种的混合，既可以用行号，也可以用行标签
frame1.ix[2]
frame1.ix['c']
"""result：
names    Jack
sex         M
age        26
id        NaN
Name: c, dtype: object
"""
#获取多行
#注意：使用行标签时，：两边是全包括，使用行号时是左闭右开
frame1.loc['b':'c']
frame1.iloc[2:4]
frame1.ix['b':'c']
frame1.ix[2:4]
"""result:
 names sex  age   id
c  Jack   M   26  NaN
d   Ann   F   28  NaN
"""
#利用ix、loc、iloc拓展获取列数据
#获取单列，如下所示，或将['sex']写成'sex'，将不显示columns名
frame1.ix[:,['sex']]   #等效于frame1['sex']
frame1.loc[:,['sex']] 
frame1.ix[:,[1]] 
"""
frame1.ix[:,['sex']]:      VS       frame1.ix[:,'sex'] :
  sex
a   M                               a    M
b   F                               b    F
c   M                               c    M
d   F                               d    F
"""
#获取多列
frame1.ix[:,'sex':]
frame1.loc[:,'sex':]
frame1.iloc[:,1:4]
"""result:
  sex  age   id
a   M   21  NaN
b   F   30  NaN
c   M   26  NaN
d   F   28  NaN
"""
#给列赋值,赋值是列表或数组时，长度必须相匹配
frame1['id']=np.arange(4)    
"""frame1=
  names sex  age  id
a   Bob   M   21   0
b  Jane   F   30   1
c  Jack   M   26   2
d   Ann   F   28   3
"""
#若赋值的是一个Series，将精确匹配DataFrame的索引，空位将补上缺失值
frame1['id']=Series([11,12],index=['a','c'])
"""frame1=
  names sex  age    id
a   Bob   M   21  11.0
b  Jane   F   30   NaN
c  Jack   M   26  12.0
d   Ann   F   28   NaN
"""
#为不存在的列赋一个新列
frame1['Female']=frame1.sex=='F'
"""frame1=
  names sex  age    id  Female
a   Bob   M   21  11.0   False
b  Jane   F   30   NaN    True
c  Jack   M   26  12.0   False
d   Ann   F   28   NaN    True
"""
#删除列数据
del frame1['Female']
"""frame1=
  names sex  age    id
a   Bob   M   21  11.0
b  Jane   F   30   NaN
c  Jack   M   26  12.0
d   Ann   F   28   NaN
"""
#嵌套字典(字典的字典)作为参数，传入DataFrame
#外层字典的键作为列（columns），内层键作为行索引(index)
pop={'Nevada':{2001:2.4,2002:2.9},'Ohio':{2000:1.5,2001:1.7,2002:3.6}}
frame2=DataFrame(pop)
"""frame2=
      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7
2002     2.9   3.6
"""
#对结果进行转置
frame2.T
"""result:
        2000  2001  2002
Nevada   NaN   2.4   2.9
Ohio     1.5   1.7   3.6
"""
#显示指定索引
DataFrame(pop,index=[2001,2002,2003])
"""result:
      Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2003     NaN   NaN
"""
#跟Series一样，values属性也会以二维ndarray的形式返回DataFrame中的数据
frame2.values     #result:array([[ nan,  1.5],[ 2.4,  1.7],[ 2.9,  3.6]])

二、基本功能

2.1  重新索引-------reindex：创建一个适合新索引的新对象

reindex函数的参数：

Series中reindex方法：

#Series中的reindex方法
obj=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
#rreindex会根据新索引重新排列，若索引值不存在，则引入缺省值
obj.reindex(['a','b','c','d','e'])
#还可设置缺省项的值
obj.reindex(['a','b','c','d','e'],fill_value=0)    #此时，上面结果中的NaN将变成0
"""
obj:            obj.reindex(['a','b','c','d','e']):
d    1.2             a    3.4
a    3.4             b    5.6
c   -7.8             c   -7.8
b    5.6             d    1.2
dtype: float64       e    NaN
                     dtype: float64
"""
#插值处理
#对于时间序列这样的有序序列，重新索引时需要做一些插值处理
obj1=Series(['yellow','pink','blue'],index=[0,2,4])
obj1.reindex(range(6),method='ffill')
"""obj1=
0    yellow
1    yellow
2      pink
3      pink
4      blue
5      blue
dtype: object
"""

DataFrame中reindex方法：

reindex可以修改（行）索引、列，或两个都修改。如果仅传入一个序列，则会重新索引行：

frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
"""frame=
   US  UK  CN
a   0   1   2
b   3   4   5
c   6   7   8
"""
frame1=frame.reindex(['a','b','c','e'])
#使用columns关键字即可重新索引列
states=['US','HK','CN']
frame.reindex(columns=states)
"""result:
   US  HK  CN
a   0 NaN   2
b   3 NaN   5
c   6 NaN   8
"""
#可以同时对行和列进行索引，但插值只能按照行（即轴0）应用
frame.reindex(index=['a','b','c','e'],method='ffill',columns=states)
"""
   US  HK  CN
a   0 NaN   2
b   3 NaN   5
c   6 NaN   8
e   6 NaN   8
"""
#利用ix索引功能，重新索引任务变得更加简洁
frame.ix[['a','b','c','e'],states]
"""
    US  HK   CN
a  0.0 NaN  2.0
b  3.0 NaN  5.0
c  6.0 NaN  8.0
e  NaN NaN  NaN
"""

2.2 丢弃指定轴上的项------drop方法

由于需要执行一些数据整理和集合逻辑，所以drop方法返回的是一个在指定轴上删除了指定值的新对象。

#对于Series对象
obj=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
obj.drop('c')               #返回的是新对象，obj没变
obj.drop(['a','d'])
"""
obj:            obj.drop('c'):               obj.drop(['a','d']):
d    1.2             d    1.2                      c   -7.8
a    3.4             a    3.4                      b    5.6
c   -7.8             b    5.6                      dtype: float64
b    5.6             dtype: float64
dtype: float64                        
"""
#对于DataFrame，可以删除任意轴上的索引值：
frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
frame.drop('a')   #默认axis=0
frame.drop(['US','UK'],axis=1)
"""
frame:              frame.drop('a'):        frame.drop(['US','UK'],axis=1):
   US  UK  CN          US  UK  CN                CN
a   0   1   2       b   3   4   5            a    2
b   3   4   5       c   6   7   8            b    5
c   6   7   8                                c    8
"""

2.3 算术运算和数据对齐

pandas最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是索引对的并集。

#对于Series对象
s1=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
s2=Series([1.1,2.2,3.3,4.4.,5.5,6.6],index=['a','b','c','d','e','f'])
s1+s2     #在不重叠的地方引入了NA值，且缺失值会在算术运算过程中传播
"""result:
a    4.5
b    7.8
c   -4.5
d    5.6
e    NaN
f    NaN
dtype: float64
"""

对于DataFrame对象，对齐操作会发生在列和行上，具体过程和Series一样。

2.4 DataFrame和Series之间的运算

跟Numpy数组一样，DataFrame和Series之间的算术运算也是有明确规定的，和不同形状的数组之间的运算类似，也具有广播效应。

默认情况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着行已知向下传播（行传播）：

frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
s=frame.ix['a']
frame-s
"""
frame:                 s:                     frame-s:
   US  UK  CN         US  0                      US  UK  CN
a   0   1   2         UK  1                   a   0   0   0
b   3   4   5         CN  2                   b   3   3   3
c   6   7   8                                 c   6   6   6
"""

如果你希望匹配行，且在列上广播（列传播），则必须使用算术运算方法：

frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
s1=frame['CN']
frame.sub(s1,axis=0)  #axis=0不能少，否则运算时，默认沿着行向下传播
"""
frame:                 s1:                     frame.sub(s1,axis=0)
   US  UK  CN            CN                      US  UK  CN
a   0   1   2         a   2                   a  -2  -1   0
b   3   4   5         b   5                   b  -2  -1   0
c   6   7   8         c   8                   c  -2  -1   0
"""
frame-s1   #或frame.sub(s1)
"""result:
   CN  UK  US   a   b   c
a NaN NaN NaN NaN NaN NaN
b NaN NaN NaN NaN NaN NaN
c NaN NaN NaN NaN NaN NaN
"""

算术方法：

2.5 函数应用和映射

numpy中ufuncs(元素级数组方法)也可以用于pandas对象，例：

np.exp(frame)
"""
           US           UK           CN
a    1.000000     2.718282     7.389056
b   20.085537    54.598150   148.413159
c  403.428793  1096.633158  2980.957987
"""

另一个常见的操作是，将函数应用到由各列或行所形成的一维数组上，DataFrame的apply方法即可实现该功能：

f=lambda x:x.max()-x.min()
frame.apply(f)           #函数应用到每列所形成一维数组
frame.apply(f,axis=1)    #函数应用到每行所形成一维数组
"""
frame:              
   US  UK  CN        frame.apply(f):         frame.apply(f,axis=1)
a   0   1   2        US    6                       a    2
b   3   4   5        UK    6                       b    2
c   6   7   8        CN    6                       c    2
"""

2.6 排序和排名

根据条件对数据集排序，这是一个内置运算，要对行或列索引进行排序（按字典排序），可使用sort_index方法，它将返回一个已排序好的新对象。

2.6.1 排序

#排序
obj=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
#索引排序
obj.sort_index()
#值排序
obj.sort_values()
"""
obj:             obj.sort_index():          obj.sort_values()：
d    1.2             a    3.4                   c   -7.8
a    3.4             b    5.6                   d    1.2
c   -7.8             c   -7.8                   a    3.4
b    5.6             d    1.2                   b    5.6
"""
frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
#索引排序，分轴0和轴1，若需要按照哪行排序，可利用by=''，锁定某行
frame.sort_index(axis=1)
#值排序
#axis=0代表对列操作，by='CN'代表对name为'CN'的列处理，ascending默认为True，代表升序排
frame.sort_values(by='CN',axis=0,ascending=False)
"""
frame:              frame.sort_index(axis=1):   frame.sort_values(by='CN',axis=0,ascending=False)：
   US  UK  CN          CN  UK  US                        US  UK  CN
a   0   1   2       a   2   1   0                     c   6   7   8
b   3   4   5       b   5   4   3                     b   3   4   5
c   6   7   8       c   8   7   6                     a   0   1   2   
"""
#在排序中，默认缺失值都会被放到最后
obj1=Series([4,np.nan,7,np.nan,-3,5])
"""result:
4   -3.0
0    4.0
5    5.0
2    7.0
1    NaN
3    NaN
dtype: float64
"""

2.6.2 排名

排名（ranking）跟排序关系密切，且它会增设一个排名值（从1开始，一直到数组中有效数据的数量）。它跟numpy.argsort产生的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系。默认情况下，rank是通过”为各组分配一个平均排名“的方式破坏平级关系的。

rank()函数中，用于破坏平级关系的method选项：

#排名：
obj=Series([7,-5,7,4,2,0,4])
obj.rank()
obj.rank(method='first')
"""
obj:           obj.rank():            obj.rank(method='first'):
0    7          0    6.5                  0    6.0
1   -5          1    1.0                  1    1.0
2    7          2    6.5                  2    7.0
3    4          3    4.5                  3    4.0
4    2          4    3.0                  4    3.0
5    0          5    2.0                  5    2.0
6    4          6    4.5                  6    5.0
"""
frame=DataFrame({'b':[3,2,4,1],'a':[7,5,2,9],'c':[3,9,6,2]})
frame.rank(axis=1)
"""
frame:                  frame.rank(axis=1):
   a  b  c                      a    b    c
0  7  3  3                 0  3.0  1.5  1.5
1  5  2  9                 1  2.0  1.0  3.0
2  2  4  6                 2  1.0  2.0  3.0
3  9  1  2                 3  3.0  1.0  2.0
"""

三、汇总和计算描述统计

pandas对象拥有一组常用的数学和统计方法。它们大部分都属于简约和汇总统计，用于从Series中提取单个值（如sum或mean）或从DataFrame的行或列中提取一个Series。更对应的numpy数组方法，它们都是基于没有缺失数据的假设而构建的。

3.1与描述统计相关的函数：

3.2 函数中常见的选项:

3.3部分代码示例：

#汇总和统计
df=DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],columns=['one','two'])
#计算每列的和，默认排除NaN
df.sum()
#计算每行的和，默认排除NaN
df.sum(axis=1)
#计算每行的和，设置skipna=False，NaN参与计算，结果仍为NaN
df.sum(axis=1,skipna=False)
"""
df:                    df.sum():       df.sum(axis=1):     df.sum(axis=1,skipna=False):
    one  two         one    9.25         0    1.40               0     NaN
0  1.40  NaN         two   -5.80         1    2.60               1    2.60
1  7.10 -4.5                             2    0.00               2     NaN
2   NaN  NaN                             3   -0.55               3   -0.55
3  0.75 -1.3
"""
obj=Series(['a','b','a','d']*4)
obj.describe()
"""
count     16
unique     3
top        a
freq       8
dtype: object
"""

3.4、唯一值、值计数以及成员资格

常见方法：（对于Series对象）

相关代码：

obj=Series(['a','d','a','b']*4)
unique=obj.unique()    #结果未排序 return:array(['a', 'd', 'b'], dtype=object)
obj.value_counts()     #结果按值频率降序排序
#等效于   pd.value_counts(obj,sort=True)
"""result:
a    8
d    4
b    4
dtype: int64
"""  
obj1=Series(['a','b','c','d'])
#判断矢量化集合的成员资格
obj1.isin(['b','d'])
"""
0    False
1     True
2    False
3     True
dtype: bool
"""

对于DataFrame对象，可以使用apply函数和以上函数联合使用。

frame=DataFrame({'b':[3,2,4,1],'a':[3,5,2,1],'c':[3,3,2,2]})
#fillna(0)将nan值的位置上填补0
frame.apply(pd.value_counts).fillna(0)
"""
     a    b    c
1  1.0  1.0  0.0
2  1.0  1.0  2.0
3  1.0  1.0  2.0
4  0.0  1.0  0.0
5  1.0  0.0  0.0
"""

四、处理缺失数据

缺失数据是大部分数据分析应用中都很常见。pandas的设计目标之一就是让缺失数据的处理任务尽量轻松。pandas使用浮点值（NaN）表示浮点和非浮点数据中的缺失数据。它只是一个便于被检测出来的标记而已。python中的内置none也会被当做NA处理。

NA的处理方法：