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
"""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的处理方法：
