山东大学Python（10）——Pandas

#%%
# 使用 jupyter notebook 编写
"""
本章知识目录：
pandas的数据结构介绍
    1.Series数据结构
    2.DataFrame数据结构
基本功能
    3.索引对象
    4.重新索引
    5.丢弃指定轴上的项
    6.索引、选取和过滤 
    7.算术运算和数据对齐
    8.在算术方法中填充值
    9.DataFrame和Series之间的运算
    10.排序和排名 
    11.带有重复值的轴索引
处理缺失数据
    12.滤除缺失数据
    13.填充缺失数据
"""

"""
考试：
结构（Series、DataFrame），仔细看，多练，最重要
运算
创建、删除、引用、索引
排名（重要）
dateframe的函数：
    缺失值的处理
    其他就不用看了
"""
from pandas import Series, DataFrame
import pandas as pd

#%%

"""
Series数据结构：
    1.它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。
    2.Series的字符串表现形式为：索引在左边，值在右边。由于没有为数据指定索引，
    于是会自动创建一个0到N-1 (N为数据的长度）的整数型索引。
    可以通过Series的 values和index属性获取其数组表示形式和索引对象
    3.与普通NumPy数组相比，可以通过索引的方式选取Series中的单个或一组值
    4.还可以将Series看成是一个定长的有序字典，因为它是索引值到数据值的一个映射。
    它可以用在许多原本需要字典参数的函数中
"""
obj1 = Series([9, 8, 7, 6, 5, 4])
print(obj1)
print(obj1.values)
print(obj1.index)
print("======")
obj2 = Series([9, 8, 7, 5], index=['a', 'b', 'c', 'd']) # 创建有指定索引的Series
print(obj2)
print("======")
print(obj2[2]) # 通过索引访问数据，通过指定的索引和默认的索引都行
print(obj2['c'])
obj2['c'] = 100 # 更改值
print(obj2)
print("======")
print(obj2[['a', 'd', 'c']]) # 穿进去一个列表，访问数据
#print(obj[('a', 'd', 'c')]) # 元组是不行的，会报错Keyerror
print("======")
print(obj2[obj2>= 8])
print('b' in obj2) # 类似于字典，索引可以判断True
print(8 in obj2) # 值是没有用的为False，至少在这一点上与字典相同

#%%

"""
    5.如果数据被存放在一个Python字典中，也可以直接通过这个字典来创建Series
    6.如果只传入一个字典，则结果Series中的索引就是原字典的键（有序排列）
    7.在pandas中使用 NaN表示缺失（missing) 或NA值。
    pandas的isnull和notnull函数可用于检测缺失数据
    8.对于许多应用而言，Series域重要的一个功能是：它在算术运算中会自动对齐不同索引的数据
"""
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = Series(sdata)
print(obj3)
states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = Series(sdata, index=states)
print(obj4) # Nan:not a number
"""
sdata跟states索引相匹配的那3个值会被找出来并放到相应的位置上，
但由于“California”所对应的sdata值找不到，所以其结果就为NaN 
(即“非数字” (not a number))
"""
print("======")
print(pd.isnull(obj4)) # 是否为缺失值，是位True，否为False
print(pd.notnull(obj4)) # 不空为True，空为False
print(obj4.isnull()) # 除了上面的方式以外，这种也是可以的
print(obj4.notnull()) # 效果都是相同的
print("======")
print(obj3+obj4) # 自动对齐不同索引的数据

#%%

"""
    9.Series对象本身及其索引都有一个name属性，该属性跟pandas其他的关键功能关系非常密切
    10.Series的索引可以通过赋值的方式就地修改
"""
obj4.name = "population"
obj4.index.name = 'state'
print(obj4)
print("======")
obj4.index = ['I', 'love', 'you', '!'] # 通过赋值的方式修改索引
print(obj4)

#%%

"""
DataFrame数据结构：
     DataFrame是一个表格型的数据结构，它含有一组有序的列，
     每列可以是不同的值类 型（数值、字符串、布尔值等）。
     DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典
     （共用同一个索引）
     1.构建DataFrame的办法有很多，
     最常用的一种是直接传入一个由等长列表或NumPy数组组成的字典
     2.如果指定了列序列，则DataFrame的列就会按照指定顺序迸行排列
     跟Series一样，如果传入的列在数据中找不到，就会产生NA值
     3.通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series
"""
data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
      'year':[2000, 2001, 2002, 2001, 2002],
      'pop':[1.5, 1.7, 3.6, 2.4, 2.9]}
frame = DataFrame(data)
print(frame) # 通过传入一个列表组成的字典
print(DataFrame(data, columns=['year', 'state', 'pop'])) # 指定列序列
print(DataFrame(data, columns=['month', 'state', 'pop'])) # 这个序列中的month的数据在data中是不存在，被赋上了NaN
print(DataFrame(data, columns=['year', 'state', 'pop'], 
                index=['one', 'two', 'three', 'four', 'five']))
# 上面这个index如果和数据的行数不匹配会报错的ValueError，多了或少了都不行
print("======")
print(frame.columns) # DataFrame的一个属性，列索引
print("++++++")
print(frame['state']) # 通过类似字典的方式，打出一列的Series内容
#print(frame[0]) # 报错KeyError，这个与Series不一样了，至少Series不会报错
print(frame.year) # 除了上面的使用方式，这样也可以

#%%

"""
    4.注意，返冋的Series拥有原DataFrame相同的索引，
    且其name属性也已经被相应地设置 好了。
    行也可以通过位置或名称的方式进行获取，比如用索引字段ix 
    5.下面这个PPT中没有，不过我觉得也很不错的一个创建DataFrame的方式
    即 字典套字典（后面才看到，这个讲了，PPT26页）
    6.列可以通过赋值的方式进行修改。
    例如，可以给那个空的“debt”列赋上一个标量值或一组值
    7.将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度相匹配。
    如果赋值的是一个Series，就会精确匹配DataFrame的索引，
    所有的空位都将被填上缺失值
"""
newdata = {'lang':{'first':'python', 'second':5000}, # 外层索引是列索引
           'price':{'first':'java', 'second':2000}} # 内层索引是行索引
newframe = DataFrame(newdata)
print(newframe)
print("======")
print(newframe.ix['first']) # 获取行索引
print("======")
import numpy as np
newframe['price'] = np.arange(2)
print(newframe)
newframe['price'] = 9 # 赋上一个值，就是把这一列都设置为同一值
print(newframe) 
newframe['price'] = [8, 4] # 赋上一组值，通过列表也可以
print(newframe)
newframe['price'] = (3, 6) # 元组都特么行
print(newframe)
print("++++++")
frame.index = ['one', 'two', 'three', 'four', 'five']
val = Series([-1.2, -1.5, -1.7], index=[ 'two', 'four', 'three'])
frame['pop'] = val # Series之val的长度必须与DataFrame之frame匹配
print(frame)

#%%

"""
    8.为不存在的列赋值会创建出一个新列。关键字del用于删除列
    9.转置frame_name.T
    
"""
print(frame)
frame['bool'] = frame.state == 'Ohio' # 这句话，我感觉有一丝丝牛逼
print(frame) # 上面是创建新列
del frame['bool']
#del frame.year # 这样会报错AttributeError，不过之前print(frame.year)是没问题的
print(frame)
print("======")
print(frame.T) # 行列索引互换，内部的相对顺序没变
print("------")
print(frame)

#%%

"""
    10.如果设置了DataFrame的index和columns的name属性，则这些信息也会被显示出来
    11.跟Series一样，values属性也会以二维ndarray的形式返回DataFrame中的数据
"""
frame.index.name = 'numbers' # 还是很漂亮的
frame.columns.name = 'info'
print(frame)
print("======")
print(frame.values) # 以二维ndarray形式返回数据

#%%

"""
索引对象：
    1.pandas的索引对象负责管理轴标签和其他元数据（比如轴名称等）。
    构建Series或DataFrame时，
    所用到的任何数组或其他序列的标签都会被转换成一个Index
    2.Index对象是不可修改的（immutable)，因此用户不能对其进行修改
    3.不可修改性非常重要，因为这样才能使Index对象在多个数据结构之间安全共享
"""    
obj = Series(range(3), index=['a', 'b', 'c']) # 指的是这个index参数，任何数组和序列都可以
print(obj)
index = obj.index
print(index)
print(index[1:])
#index[1] = 'd' # 会报错TypeError，这也说明了index = obj.index使得它们两个公用一块内存
# 来看一下我们的猜想是否正确
print(id(index)) # 果然相同
print(id(obj.index)) # 猜想正确，但这也很容易说明，=，说明index是别名，地址当然一样
print("======")
index = pd.Index(np.arange(3)) # 这个函数能创建index
obj2 = Series([1.5, -2.5, 0], index=index)
print(obj2.index is index)

#%%

"""
index的方法和属性：
    append  连接另一个Index对象，产生一个新的Index
    diff	计算差集，并得到一个Index
    intersection	计算交集
    union	计算并集
    isin	计算一个指示各值是否都包含在参数集合中的布尔型数组
    delete	删除索引i处的元素，并得到新的Index
    drop	删除传入的值，并得到新的Index
    insert	将元素插入到索引i处，并得到新的Index
    is_monotonic	当各元素均大于等于前一个元素时，返回True
    is.unique	当Index没有重复值时，返回True
    unique	计算Index中唯一值的数组
"""

#%%

"""
重新索引：
    1.pandas对象的一个重要方法是reindex，
    其作用是创建一个适应新索引的新对象
    2.调用该Series的reindex将会根据新索引进行重排。
    如果某个索引值当前不存在，就引入缺失值
    3.对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。
    method选项即可 达到此目的，例如，使用ffill可以实现前向值填充
"""
obj = Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
print(obj)
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
print(obj2)
print("======")
print(obj) # obj还是原来的obj，没有变化
print(obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value=0)) # fill_value填充值
print("======")
obj3 = Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])
print(obj3)
print(obj3.reindex(range(6), method='pad')) # 用前面的来填充
# 下面会给出参数，ffill和pad是等价的，bfill和backfill是等价的

#%%

"""
    4.reindex的（插值）method选项
        参数	                 说明
    ffill或pad	        前向填充（或搬运）值
    bfill或backfill	    后向填充（或搬运）值
    5.对于DataFrame，reindex可以修改（行）索引、列，或两个都修改。
    如果仅传入一个序列，则会重新索引行
    
"""
frame = DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'],columns=[ 'Ohio', 'Texas', 'California'])
print(frame)
frame2 = frame.reindex(['a', 'b', 'c', 'd'])
print(frame2) # 一个序列，索引行

#%%

"""
丢弃指定轴上的项：
    1.丢弃某条轴上的一个或多个项很简单，只要有一个索引数组或列表即可。
    由于需要执行一些数据整理和集合逻辑，
    所以drop方法返回的是一个在指定轴上删除了指定值的新对象
    2.对于DataFrame，可以刪除任意轴上的索引值
"""
obj = Series(np.arange(5,), index=['a', 'b', 'c', 'd', 'e'])
new_obj = obj.drop('c')
print(new_obj)
print(obj) # obj依然没变
print("======")
print(obj.drop(['a', 'c']))
data = DataFrame(np.arange(16).reshape((4, 4)),
    index=['Ohio', 'Colorado', 'Utah', 'New York'],
    columns=['one', 'two', 'three', 'four'])
print(data)
print(data.drop(['Colorado', 'Ohio'], axis=0)) # axis的默认值为0
print(data.drop('two', axis=1))
print(data.drop(['Colorado', 'Ohio']).drop('two', axis=1))
print(data.drop(['two', 'four'], axis=1))

#%%

"""
索引、选取和过滤：
    1. Series索引（obj[...]）的工作方式类似于NumPy数组的索引，
    只不过Series的索引值不只是整数。
"""
obj = Series(np.arange(4,), index=['a', 'b', 'c', 'd'])
print(obj['b'])
print(obj[1]) # 这个我之前提到了
print(obj[1:10]) # 我这个切片范围都飞出去了，没报错
print("======")
print(obj[[1, 3]])
print(obj[obj < 2])

#%%

"""
    2.利用标签的切片运算与普通的Python切片运算不同，
    当使用非整数作为切片索引时,其末端是包含的（inclusive)
    3.对DataFrame进行索引其实就是获取一个或多个列
        这种索引方式有几个特殊的情况。首先通过切片或布尔型数组选取行（下面）
        另一种用法是通过布尔型DataFrame进行索引
"""
print(obj)
print(obj[1:2]) # 只含一项
print(obj['b':'c']) # 包含两项
print(data)
print( data['two'])
print(data[['three', 'one']])
print("======")
print(data[:2]) # 切片切的是行
print(data[data['three'] > 5])
print("======")
print(data<5) # 每一个量都进行了判断

#%%

"""
    4.为了在DataFrame的行上进行标签索引，引入了专门的索引字段ix。
    它可以通过NumPy式的标记法以及轴标签从DataFrame中选取行和列的子集。
    这也是一种重新索引的简单手段
    5.
        类型	                  说明
    obj[val]	     选取DataFrame的单个列或一组列。在一些特殊
                              情况下会比较便利：布尔型数组（过滤行）、切
                              片（行切片）、布尔型DataFrame (根据条件
                              设置值）。
    obj.ix[val]	     选取DataFrame的单个行或一组行。
    obj.ix[:, val]        选取单个列或列子集。
    obj.ix[val1, val2]  同时选取行和列。
    reindex 方法         将一个或多个轴匹配到新索引。
    xs方法                  根据标签选取单行或单列，并返回一个Series。
    icol、irow方法       根据整数位置选取单列或单行，并返回一个
                               Series。
    get.value, set_value方法    根据行标签和列标签选取单个值。
"""
print(data.ix['Colorado', ['two', 'three']])
print(data.ix[['Colorado', 'Utah'],[3, 0, 1]])
print(data.ix[2])

#%%

"""
算术运算和数据对齐：
    1.pandas最重要的一个功能是，它可以对不同索引的对象进行算术运算。
    在将对象相加时， 如果存在不同的索引对，则结果的索引就是该索引对的并集。
"""
s1 = Series([7.3, -2.5, 3.4, 1.5],index=['a', 'c', 'd', 'e'])
s2 = Series([-2.1, 3.6, -1.5, 4, 3.1], index=['a', 'c', 'e', 'f', 'g'])
print(s1)
print(s2)
print(s1+s2)

#%%

"""
    2.对于DataFrame,对齐操作会同时发生在行和列上
"""
df1 = DataFrame(np.arange(9,).reshape((3, 3)), columns=list('bcd'),
        index=['Ohio', 'Texas', 'Colorado'])
df2 = DataFrame(np.arange(12,).reshape((4, 3)), columns=list('bde'), 
        index=['Utah', 'Ohio', 'Texas', 'Oregon'])
print(df1)
print(df2)
print(df1+df2)

#%%

"""
在算术方法中填充值：
    
"""
df1 = DataFrame(np.arange(12).reshape((3, 4)), columns=list('abcd'))
df2 = DataFrame(np.arange(20.).reshape((4, 5)), columns=list('abcde'))
print(df1)
print(df2)
print(df1 + df2)
# 将它们相加时，没有重叠的位置就会产生NA值.
# 使用df1的add方法，传入df2以及一个fill_value参数
print(df1.add(df2, fill_value=0)) 
# df2.add(df1, fill_value=0)等效
# 与此类似，在对Series或DataFrame重新索引时，也可以指定一个填充值
print(df1.reindex(columns=df2.columns, fill_value=0))
"""
灵活的算术方法
 add             用于加法(+ )的方法
 sub             用于减法(-）的方法
 div              用于除法(/)的方法
 mul             用于乘法(*)的方法 
"""

#%%

"""
DataFrame和Series之间的运算：
    跟NumPy数组一样，DataFrame和Series之间算术运算也是有明确规定的。
    1.广播。默认情况下，
    DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，
    然后沿着行一直向下广播
    2.如果某个索引值在DataFrame的列或Series的索引中找不到，
    则参与运算的两个对象就会被重新索引以形成并集
"""
frame = DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                  index=['Utah', 'Ohio', 'Texas', 'Oregon'])
print(frame)
series = frame.ix[0]
print(series)
print(frame-series) # 这就是广播
print("======")
series2 = Series(range(3), index=['b', 'e', 'f'])
print(series2)
print(frame+series2)

#%% 

"""
排序和排名：
    1.根据条件对数据集排序(sorting)也是一种重要的内置运算。
    要对行或列索引进行排序 (按字典顺序），可使用sort_index方法，
    它将返回一个已排序的新对象
"""
obj = Series(range(4), index=['d', 'a',  'b', 'c'])
print(obj)
print(obj.sort_index()) # 按字典顺序排序
print(obj)

#%%

"""
    2.对于DataFrame，则可以根据任意一个轴上的索引进行排序
    3.数据默认是按升序排序的，但也可以降序排序:

"""
frame = DataFrame(np.arange(12).reshape((3, 4)), 
    index=['three', 'two','five'], columns=['d','a','b','c'])
print(frame.sort_index()) # 根据行索引排序
print(frame.sort_index(axis=1)) # 根据列索引排序
print(frame.sort_index(axis=1, ascending=False)) # 默认为升序，这里为降序

#%%

"""
    4.若要按值对Series进行排序，可使用其order方法
"""
obj = Series([4, 7, -3, 2])
#obj.order() # PPT上的这个函数，我运行会报错
#AttributeError: 'Series' object has no attribute 'order'
# 但好在还有Series_name.sort_values()
print(obj.sort_values()) # 按值排序，效果与PPT一样
obj = Series([4, np.nan, 1, np.nan, -3, 2])
print(obj.sort_values()) # 在排序时，缺失值默认都会被放到Series的末尾，效果与PPT一样

#%%

"""
    5.在DataFrame上，可能希望根据一个或多个列中的值进行排序。
    将一个或多个列的名字传递给by选项即可达到该目的
    6.要根据多个列进行排序，传入名称的列表即可
"""
frame = DataFrame({'b': [4,7,-3,2], 'a':[0, 1, 0, 1]})
print(frame)
print(frame.sort_index(by='b')) # 按照'b'列，字典顺序，升序排序
frame = DataFrame({'b': [4,7,-3,2], 'a':[0, 1, 100, 1]})
print(frame.sort_index(by=['a', 'b'])) # 也就是说这个多个列的排序，按给出by中的顺序进行

#%%

"""
    7.排名（ranking)跟排序关系密切，且它会增设一个排名值
    （从1开始，一直到数组中有效数据的数量）。
    它跟numpy.argsort产生的间接排序索引差不多，
    只不过它可以根据某种规则破坏平级关系。
    Series和DataFrame的rank方法:默认情况下，
    rank是通过“为各组分配一个平均排名”的方式破坏平级关系的
    8.Series.rank(axis=0,method='average',
	numeric_only=None,na_option='keep',
	ascending=True/非零值,pct=False)
	
    method有四个取值，average默认，在想等分组中，为各个值平均排名、
    min使用整个分组的最小排名、max使用整个分组的最大排名、
    first按值在原始数据中的出现顺序分配排名
    
    axis:{0 or 'index',1 or 'columns'} default 0
    DataFrame可以在行或列上计算排名
"""
obj = Series([7,-5,7,4,2,0,4])
print(obj)
print(obj.rank()) 
print("======")
# 正如前面说的，它会增设一个排名值，从1开始
# index=0代表的是obj第一个数7,7在obj中排名第6和第七，取平均值6.5
# index=1代表obj第二个数-5.-5在obj中排名第1，取值1
# index=3为4在obj中为第4和第5，取平均值4.5
print(obj.rank(method='first'))
print(obj.rank(ascending=False, method='max')) # 按降序进行排名
print("======")
frame = DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1], 'c':[-2, 5, 8, -2.5]})
print(frame)
print(frame.rank(axis=1))

#%%

"""
带有重复值的轴索引：
    1.索引的is_unique属性验证是否是唯一的
    2.对于带有重复值的索引，数据选取的行为将会有些不同。
    如果某个索引对应多个值，则返回一个Series;而对应单个值的，
    则返回一个标量值
    对DataFrame的行进行索引时也是如此
"""
obj = Series(range(5), index=['a','a','b','b','c'])
print(obj)
print(obj.is_unique) # 这个是True，它判断的是值是否唯一
print(obj.index.is_unique) # 这个是False
#print(obj.values.is_unique) # 这样会报错
#AttributeError: 'numpy.ndarray' object has no attribute 'is_unique'
print(obj['a']) # Series
print(obj['c']) # 标量值
print("======")
df = DataFrame(np.random.randn(5, 3), index=['a','a','b','b','c'])
print(df)
print(df.ix['b']) # DataFrame
print(df.ix['c']) # Series

#%%

"""
处理缺失数据：
    1.pandas使用浮点值NaN(Not a Number)表示浮点和非浮点数组中的缺失数据。
    它只是一个便于被检测出来的标记而已
    2.Python内置的None值也会被当做NaN处理
    3.
        方法	                     说明
    dropna	         根据各标签的值中是否存在缺失数据对轴标
                     签进行过滤，可通过阈值调节对缺失值的容
                     忍度
    fillna	         用指定值或插值方法（如ffill或bfill)填充缺
                     失数据
    isnull 	         返回一个含有布尔值的对象，这些布尔值表
                     示哪些值是缺失值/NA，该对象的类型与源
                     类型一样
    notnull	         isnull的否定式

"""
string_data=Series(['aardvark','artichoke',np.nan,'avocado'])
print(string_data)

#%%

"""
滤除缺失数据；
    1.过滤掉缺失数据的办法有很多种。纯手工操作永远都是一个办法，
    但dropna可能会更实用一些。对于一个Series，
    dropna返回一个仅含非空数据和索引值的Series
    2.也可以通过布尔型索引达到过滤掉缺失数据的目的
"""
from numpy import nan as NA
data = Series([1, NA, 3.5, NA, 7])
print(data)
print(data.dropna())
print(data[data.notnull()]) # 通过布尔索引过滤缺失值


#%%

"""
    3.对于DataFrame对象，dropna默认丢弃任何含有缺失值的行
    4.传入how=‘all’将只丢弃全为NA的那些行
    5.滤除DataFramc行的问题涉及时间序列数据。
    假设只想留下一部分观测数据， 可以用thresh参数实现此目的
"""
data = DataFrame([[1., 6.5, 3.],[1., NA,NA],
        [NA, NA, NA], [NA, 6.5, 3.1]])
cleaned = data.dropna()
print(data)
print(cleaned)
print("======")
print(data.dropna(how='all')) # axis=1可以控制，删列
print("======")
df = DataFrame(np.random.randn(7, 3))
df.ix[:4, 1] = NA; df.ix[:2, 2] = NA
print(df)
print(df.dropna(thresh=3)) # 保留至少有thresh个非NaN数据的行
# 这里thresh=3，所以行中要求至少有3个非NaN数据，只有第5和6行
# 试一下，thresh=2和1
print(df.dropna(thresh=2))
print(df.dropna(thresh=1))

#%%

"""
填充缺失数据：
    1.若不想滤除缺失数据（有可能会丢弃跟它有关的其他数据），
    而是希望通过其他方式填补那些“空洞”。对于大多数情况而言，
    fillna方法是最主要的函数。
    通过一个常数调用fillna就会将缺失值替换为那个常数值
    2.若是通过一个字典调用fillna,就可以实现对不同的列填充不同的值
"""
print(df.fillna(0))
print(df.fillna({1:	0.5, 3: -1}))

#%%

"""
    3.fillna默认会返回新对象，但也可以对现有对象进行就地修改    
"""
print(df)
_ = df.fillna(0, inplace=True)
print(df)

#%%

"""
    4.对reindex有效的那些插值方法也可用于fillna
    5.可以利用fillna实现许多别的功能。比如可以传入Series的平均值或中位数
    6.fillna的参数：
        参数	                  说明
    value	      用于填充缺失值的标量值或字典对象
    method    插值方式。如果函数调用时未指定其他参数
                   的话，默认为“ffill”
    axis	       待填充的轴，默认axis=0
    inplace     修改调用者对象而不产生副本	
    limit	       (对于前向和后向填充)可以连续填充的最
                   大数量
"""
df = DataFrame(np.random.randn(6, 3))
df.ix[2:,1] = NA
df.ix[4:,2] = NA
print(df)   
print(df.fillna(method='ffill'))
print(df.fillna(method='ffill', limit=2)) #
data = Series([1., NA, 3.5, NA, 7])
print(data.fillna(data.mean()))