利用Python进行数据分析——pandas入门

• 基于NumPy建立的
• from pandas importSeries,DataFrame,import pandas as pd

一、两种数据结构

1.Series

类似于Python的字典，有索引和值

创建Series

#不指定索引，默认创建0-N
In [54]: obj = Series([1,2,3,4,5])

In [55]: obj
Out[55]:
0    1
1    2
2    3
3    4
4    5
dtype: int64
#指定索引
In [56]: obj1 = Series([1,2,3,4,5],index=['a','b','c','d','e'])

In [57]: obj1
Out[57]:
a    1
b    2
c    3
d    4
e    5
dtype: int64

#将Python中的字典转换为Series
In [63]: dic = {'a':1,'b':2,'c':3}

In [64]: obj2 = Series(dic)

In [65]: obj2
Out[65]:
a    1
b    2
c    3
dtype: int64

对Series进行数组运算（根据布尔型数组进行过滤、标量乘法、应用函数等）依旧会保留索引和值之间的对应关系。
对应index的值找不到就用NAN表示，且在算数运算中会自动补齐数据，不存在用NAN

2.DataFrame

DataFrame是一个表格型的数据结构，既有行索引也有列索引。

创建DataFrame

#传进去一个等长列表组成的字典
IIn [75]: data = {'name':['nadech','bob'],'age':[23,25],'sex':['male','female']}

In [76]: DataFrame(data)
Out[76]:
   age    name     sex
0   23  nadech    male
1   25     bob  female

#指定列的顺序
In [77]: DataFrame(data,columns=['sex','name','age'])
Out[77]:
      sex    name  age
0    male  nadech   23
1  female     bob   25
# 嵌套字典创建DataFrame

DataFrame的操作

#获取某一列
In [82]: frame['age']  /frame.age
Out[82]:
0    23
1    25
Name: age, dtype: int64

#赋值
In [86]: frame2
Out[86]:
   age     sex    name grade
0   23    male  nadech   NaN
1   25  female     bob   NaN

In [87]: frame2['grade']=12

In [88]: frame2
Out[88]:
   age     sex    name  grade
0   23    male  nadech     12
1   25  female     bob     12

Index对象

In [14]: index = frame.index

In [15]: index
Out[15]: RangeIndex(start=0, stop=3, step=1)
# index 对象不可修改
In [16]: index[0]=3
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

二、基本功能

1.Series和DataFrame的重新索引

#Series
In [25]: obj = Series(['nadech','aguilera','irenieee'],index=['a','b','c'])

In [26]: obj
Out[26]:
a      nadech
b    aguilera
c    irenieee
dtype: object

In [27]: obj.reindex(['c','b','a'])
Out[27]:
c    irenieee
b    aguilera
a      nadech
dtype: object


#####DataFrame
In [21]: frame
Out[21]:
   one  two  three
a    0    1      2
b    3    4      5
c    6    7      8
#直接传进去的列表是对行的重新索引
In [22]: frame.reindex(['c','b','a'])
Out[22]:
   one  two  three
c    6    7      8
b    3    4      5
a    0    1      2
#对列的重新索引需要参数columns
In [24]: frame.reindex(columns=['three','two','one'])
Out[24]:
   three  two  one
a      2    1    0
b      5    4    3
c      8    7    6

2.删除指定轴上的项

#Series
In [28]: obj.drop('c')
Out[28]:
a      nadech
b    aguilera
dtype: object

In [30]: obj.drop(['b','a'])
Out[30]:
c    irenieee
dtype: object

#####DataFrame

frame删除行索引直接删除，列索引删除需要指定axis=1

In [39]: frame
Out[39]:
   one  two  three
a    0    1      2
b    3    4      5
c    6    7      8

In [40]: frame.drop('a')
Out[40]:
   one  two  three
b    3    4      5
c    6    7      8

In [41]: frame.drop('one',axis=1)
Out[41]:
   two  three
a    1      2
b    4      5
c    7      8

3.索引、选取和过滤

Series索引
In [8]: obj
Out[8]:
a 0
b 1
c 2
d 3
dtype: int32

In [9]: obj['a']
Out[9]: 0

In [10]: obj[0]
Out[10]: 0

#注意利用标签切片和index 0-N是不同的
In [11]: obj[2:3]
Out[11]:
c    2
dtype: int32

In [12]: obj['c':'d']
Out[12]:
c    2
d    3
dtype: int32

DataFrame索引

#索取frame的列
In [24]: frame
Out[24]:
   one  two  three  four
a    0    1      2     3
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15

In [25]: frame['one']
Out[25]:
a     0
b     4
c     8
d    12
Name: one, dtype: int32

In [26]: frame[['one','two']]
Out[26]:
   one  two
a    0    1
b    4    5
c    8    9
d   12   13
#索取frame的行，标签索引
In [33]: frame.ix['a']
Out[33]:
one      0
two      1
three    2
four     3
Name: a, dtype: int32

In [31]: frame.ix[['a','b']]
Out[31]:
   one  two  three  four
a    0    1      2     3
b    4    5      6     7

#同时选取行和列
In [35]: frame.ix[['a','b'],['one','two']]
Out[35]:
   one  two
a    0    1
b    4    5

4.算数运算和数据对齐

#当存在不同的索引对计算时，会产生并集，和NAN，通过fill_value 可以传入参数

• add()
• sub()
• div()
• mul()

5.Series和DataFrame的运算

#series的索引会匹配到dataframe的列，然后向下广播
In [46]: frame
Out[46]:
   one  two  three  four
a    0    1      2     3
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15

In [47]: obj = frame.ix['a']

In [48]: obj
Out[48]:
one      0
two      1
three    2
four     3
Name: a, dtype: int32

In [49]: frame - obj
Out[49]:
   one  two  three  four
a    0    0      0     0
b    4    4      4     4
c    8    8      8     8
d   12   12     12    12

#可以指定series匹配到dataframe的列（即index）然后向右广播，即沿着列广播
In [51]: frame
Out[51]:
   one  two  three  four
a    0    1      2     3
b    4    5      6     7
c    8    9     10    11
d   12   13     14    15

In [52]: obj2 = Series(np.arange(4),index=['a','b','c','d'])

In [53]: obj2
Out[53]:
a    0
b    1
c    2
d    3
dtype: int32

In [54]: frame.sub(obj2,axis=0)   #dataframe的行用0、列用1
Out[54]:
   one  two  three  four
a    0    1      2     3
b    3    4      5     6
c    6    7      8     9
d    9   10     11    12

5.排序

#按轴上的索引排序

#Series
    In [6]: obj
    Out[6]:
    a    0
    c    1
    b    2
    d    3
    In [8]: obj.sort_index()
    Out[8]:
    a    0
    b    2
    c    1
    d    3
    dtype: int32
    #DataFrame
    frame.sort_index()
    frame.sort_index(axis=1)

6.obj.index.is_unique可以用来判断index是否唯一

三、汇总和计算描述统计

描述和汇总统计

• count 非Na值的数量
• describe 针对Series或各DataFrame列计算汇总统计
• min/max 最下最大值 都是每列中的最值
• aigmin/argmax 最小、大值的索引位置
• idxmin/idxmax 能获取到最小值和最大值的索引值
• quantile 计算样本的分位数
• sum() 计算每列的和
• mean()计算每列的均值
• median 计算每列的算数中位数
• mad() 根据平均值计算平均绝对离差
• var 计算每列的方差
• std 计算每列的标准差
• skew 样本值的偏度（三阶矩)
• kurt 样本值的峰度（四阶矩）
• cumsum 样本值的累计和
• cummin/cummax 累计最大值和累计最小值
• cumprod 累计积
• diff 计算一阶差分
• pct_change 计算百分数变化

Series的唯一值、值的count数、

• obj.unique() 返回唯一值数组
• obj.value_counts() 计算各个值出现的次数
• pd.value_counts(obj.values) 这个也可以用来计算count数，是顶层的方法
• isin([]) 判断Series各个值是否包含于传入的值序列中

四、处理缺失数据

NAN处理方法

• dropna 删除空值
• fillna 给空值赋值
• isnull 判断是否有空值存在
• notnull

DataFrame.drop()复杂情况

In [49]: fram1
Out[49]:
     0    1    2
0  1.0  6.5  3.0
1  1.0  NaN  NaN
2  NaN  NaN  NaN
3  NaN  6.5  3.0

In [50]: cleaned = fram1.dropna()

In [51]: cleaned
Out[51]:
     0    1    2
0  1.0  6.5  3.0

In [52]: fram1.dropna(how='all')
Out[52]:
     0    1    2
0  1.0  6.5  3.0
1  1.0  NaN  NaN
3  NaN  6.5  3.0

#如上形式丢弃列的空值，传入axis=1

填充缺失值

obj.fillna()暴力填充
fram.fillna({1:0.1,2:0.2}) 对dataframe可以指定列填充对应的缺失值
#传入method，可以给每列填充一个上一个非空的数字，并且可以通过limit限制每列填充的个数
implace =True 会产生新的对象

In [57]: df
Out[57]:
          0         1         2
0 -0.018286  0.246567  1.115108
1  0.722105  0.984472 -1.709935
2  1.477394       NaN  1.362234
3  0.077912       NaN  0.414627
4  0.530048       NaN       NaN
5  0.294424       NaN       NaN

In [58]: df.fillna(method='ffill')
Out[58]:
          0         1         2
0 -0.018286  0.246567  1.115108
1  0.722105  0.984472 -1.709935
2  1.477394  0.984472  1.362234
3  0.077912  0.984472  0.414627
4  0.530048  0.984472  0.414627
5  0.294424  0.984472  0.414627

In [59]: df.fillna(method='ffill',limit=2)
Out[59]:
          0         1         2
0 -0.018286  0.246567  1.115108
1  0.722105  0.984472 -1.709935
2  1.477394  0.984472  1.362234
3  0.077912  0.984472  0.414627
4  0.530048       NaN  0.414627
5  0.294424       NaN  0.414627

五、层次化索引

DataFrame和层次化索引可以互相转换
frame.stack()  /unstack()