Python -- pandas
标签（空格分隔）： Python
数据结构
#首先引入需要使用的模块
from pandas import Series, DataFrame
import pandas as pd
Series
Series类似于一维数组的对象，由一组数据以及一组与之相关的数据标签组成。传入一个数组，将会创建一个0-N-1的整数型索引。
In[]: obj = Series([2,3,4,-3])
In[]: obj.values
In[]: obj.index
In[]: obj = Series([2,3,4,-3], index=['d', 'b', 'a', 'c']) # 为键值指定索引
In[]: obj['a'] #取出相应索引位置的值
In[]: obj[obj > 0]
In[]: obj * 2
In[]: np.exp(obj)
In[]: 'b' in obj
In[]: sdata = {'Ohio' : 35000, 'Texas' : 71000, 'Oregen' : 16000, 'Utath' : 5000} # 创建一个词典
In[]: obj2 = Series(sdata) # 用字典创建Series
In[]: states = ['California', 'Oregen', 'Utath', 'Ohio', 'Texas']
In[]: obj3 = Series(sdata, index = states) # 缺失值用NA表示
In[]: pd.isnull(obj3) # 检测缺失值
In[]: obj.isnull()
In[]: obj3.name = 'population' # 指定表的名字
In[]: obj3.index.name = 'state' # 指定列的名字
DataFrame
DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型。既有行索引，又有列索引。DataFrame中面向行的和面向列的操作基本是平衡的，它的数据是由一个或多个二维块存放的。
In[]: data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'], 'year' : [2000, 2001, 2002, 2001, 2002], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
In[]: frame = DataFrame(data)
In[]: DataFrame(data, clolumns = ['state', 'pop', 'year']) # DataFrame的列按照指定的顺序排序
In[]: frame2 = DataFrame(data, columns = ['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five']) # 如果指定的列在原数据中找不到，则用NA填充
In[]: frame2['eastern'] = frame2.state == 'Ohio'
In[]: del frame2['earstern']
In[]: pop = {'Nevada' : {2001:2.4, 2002:2.9}, 'Ohio' : {2000:1.5, 2002:3.6}} # 用嵌套字典创建DataFrame，外层字典的键作为列，内层键作为行索引
In[]: frame3 = DataFrame(pop)
索引对象
pandas的索引对象负责管理轴标签和其他元数据。index对象是不可以修改(immutable)的。
In[]: obj = Series(range(3), index = ['a', 'b', 'c'])
In[]: index = obj.index
In[]: index[1:]
In[]: index[1] = 'f' # 测试一下能不能修改
In[]: index = pd.Index(np.arange(3))
In[]: obj = Series([1.5, -2.5, 0], index = index)
In[]: obj.index = index
In[]: index is obj.index # True
pandas中主要的index对象：
| 类 | 说明 |
|---|---|
| Index | 最泛化的Index对象，将轴标签表示为一个有Python对象组成的Numpy数组 |
| Int64Index | 针对整数的特殊Index |
| MultiIndex | “层次化”索引对象，表示单个轴上的多层索引。可以看做由元组组成的数组 |
| DatetimeIndex | 存储纳秒级的时间戳 |
| PeriodIndex | 针对Period数据的特殊Index |
index的方法和属性：
| 方法 | 说明 |
|---|---|
| append | 连接另一个Index对象，产生一个新的Index |
| diff | 计算差集，并得到一个Index |
| intersection | 计算交集 |
| union | 计算并集 |
| isin | 计算一个指示各值是否都包含在参数集合中的布尔型数值 |
| delete | 删除索引i处的元素，并得到新的Index |
| drop | 删除传入的值，并得到新的Index |
| insert | 将元素插入到索引i处，并得到新的Index |
| is_monottonic | 当各元素均大于等于前一个元素时，返回True |
| is_unique | 当Index没有重复值时，返回True |
| unique | 计算Index中唯一值的数组 |
重新检索：
In[]: obj = Series([4.5, 7.2, -5.3, 3.6], index = ['d', 'b', 'a', 'c'])
In[]: obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'], fill_value = 0) # 不存在的index用o填充
In[]: obj3 = Series(['blue', 'purple', 'yellow'], index = [0,2,4])
In[]: obj3.reindex(range(6), method = 'ffill')
reindex的插值的method选项：
| 参数 | 说明 |
|---|---|
| ffill 或 pad | 前向填充 |
| bfill 或 backfill | 后向填充 |
reindex函数的参数：
| 参数 | 说明 |
|---|---|
| index | 用作索引的新索引。 |
| method | 插值（填充方式） |
| fill_value | 在重新检索的过程中，需要引入缺失值时使用的替代值 |
| limit | 前向或后向填充时的最大填充量 |
| level | 在MultiIndex的指定级别上匹配简单索引，否则选取其子集 |
| copy | 默认为True |
-
丢弃指定轴上的数据：
Sereis中的drop()操作
In[]: obj = Series(np.arange(5), index=['a', 'b', 'c', 'd', 'e'])
In[]: new_obj = obj.drop('a')
In[]: obj.drop(['a', 'b'])DataFrame中的drop()操作
In[]: data = DataFrame(np.arange(16).reshape((4, 4)), index = ['a', 'b', 'c', 'd'], columns = ['one', 'two', 'three', 'four'])
In[]: data.drop(['a', 'b'])
In[]: data.drop(['one', 'four'], axis = 1)
索引、选取和过滤
Series索引（obj[...]）的工作方式与Numpy中的数组索引类似，只不过Series的索引值不只是整数。
# Sereis中的索引和切片操作
In[]: obj = Series(np.arange(4), index=['a','b','c','d'])
In[]: obj['b'] # 1
In[]: obj[1] # 1
In[]: obj[2:4] # c 2 d 3
In[]: obj[['a', 'c']] # 0 2
In[]: obj[obj < 2] # a 0 b 1
In[]: obj['b':'c'] # b 1 c 2(该切片是包含末端的！！)
In[]: obj['b':'c'] = 5 # 将索引为b->c的设置为5
# DataFrame中的索引和切片操作
In[]: data = DataFrame(np.arange(16).reshape(4, 4), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['1', '2', '3', '4'])
In[]: data.ix['Colorado', ['2', '3']] # **使用ix进行行索引**
In[]: data.ix[data.3 > 5, :3]
DataFrame的索引选项：
| 类型 | 说明 |
|---|---|
| obj[val] | 选取DataFrame的单个列或一组列。 |
| obj.ix[val] | 选取DataFrame的单个行或一组行。 |
| obj.ix[:, val] | 选取单个列或列子集 |
| obj.ix[val1, val2] | 同时选取行和列 |
| reindex方法 | 将一个或多个轴匹配到新索引 |
| xs方法 | 根据标签选取单行或单列，并返回一个Series |
| icol, irow方法 | 根据整数位置选取单列或单行，并返回一个Series |
| get_value, set_value方法 | 根据行标签和列标签选取单个值 |
算术运算和数据对齐
In [62]: s1 = Series([7.3,-2.5,3.4,1.5], index=['a', 'c', 'd', 'e'])
In [63]: s2 = Series([-2.1, 3.6,-1.5,4,3.1], index=['a', 'c', 'e', 'f', 'g'])
In [64]: s1
Out[64]:
a 7.3
c -2.5
d 3.4
e 1.5
dtype: float64
In [65]: s2
Out[65]:
a -2.1
c 3.6
e -1.5
f 4.0
g 3.1
dtype: float64
In [66]: s1 + s2
Out[66]:
a 5.2
c 1.1
d NaN
e 0.0
f NaN
g NaN
dtype: float64
In [67]: df1 = DataFrame(np.arange(9.).reshape((3,3)), columns=list('bcd'), index=['Ohio', 'Texas', 'Colorado'])
In [68]: df2 = DataFrame(np.arange(12.).reshape((4,3)), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])
In [69]: df1
Out[69]:
b c d
Ohio 0.0 1.0 2.0
Texas 3.0 4.0 5.0
Colorado 6.0 7.0 8.0
In [70]: df2
Out[70]:
b d e
Utah 0.0 1.0 2.0
Ohio 3.0 4.0 5.0
Texas 6.0 7.0 8.0
Oregon 9.0 10.0 11.0
In [71]: df1 + df2
Out[71]:
b c d e
Colorado NaN NaN NaN NaN
Ohio 3.0 NaN 6.0 NaN
Oregon NaN NaN NaN NaN
Texas 9.0 NaN 12.0 NaN
Utah NaN NaN NaN NaN
In[]: df1.add(df2, fill_value=0) # 两个矩阵相加，没有值的位置填入0补充
In[]: df1.reindex(columns = df2.columns, fill_value=0)
In[]: f = lambda x: x.max() - x.min()
In[]: frame.apply(f)
In [98]: def f(x):
...: return Series([x.min(), x.max()], index=['min', 'max'])
...:
In [99]: frame.apply(f)
Out[99]:
b d e
min -2.789435 -0.110705 -1.101437
max 0.653851 1.258250 1.592027
In[]: format = lambda x: '%2.f' % x
In[]: frame.applymap(format) # for DataFrame
In[]: frame['b'].map(format) # for Series
排序和排名
根据条件对数据集排序，要对行或列索引进行排序，使用index_sort方法进行排序。
In[]: obj = Series(range(4), index=['b', 'a', 'c', 'd'])
In[]: obj.sort_index()
In [109]: frame = DataFrame(np.arange(8).reshape((2, 4)), index=['three','one'], columns=list('
...: dabc'))
In [110]: frame
Out[110]:
d a b c
three 0 1 2 3
one 4 5 6 7
In [111]: frame.sort_index()
Out[111]:
d a b c
one 4 5 6 7
three 0 1 2 3
In[]: frame.sort_index(axis=1, ascending=False)
In[]: obj = Series([4,7,-3,2])
In[]: obj.order() # 任何缺失值会被方法哦Series末尾
In [119]: frame = DataFrame({'b':[4,7,-3,2], 'a':[0,1,0,1]})
In [120]: frame
Out[120]:
a b
0 0 4
1 1 7
2 0 -3
3 1 2
In [121]: frame.sort_index(by='b')
Out[121]:
a b
2 0 -3
3 1 2
0 0 4
1 1 7
汇总和计算描述统计
约简方法的选项：
| 选项 | 说明 |
|---|---|
| axis | 约简的轴。DataFrame的行用0，列用1 |
| skipna | 排除缺失值，默认为True |
| level | 如果轴是层次化索引的，则根据level分组约简 |
相关系数与协方差
import pandas.io.data as web
all_data = {}
for ticker in ['AAPL', 'IBM', 'MSFT', 'GOOG']: all_data[ticker] = web.getd_data_yahoo(ticker, '1/1/2000', '1/1/2010')
price = DataFrame({tic:data['Adj Close'] for tic, data in all_data.iteritems()})
volume = DataFrame({tic:data['Volume'] for tic, data in all_data.iteritems()})
In[]: returns = price.pct_change()
In[]: returns.tail()
In[]: returns.MSFT.corr(returns.IBM) # 计算Series的相关系数
In[]: returns.MSFT.cov(returns.IBM) # 计算Series的协方差
In[]: returns.corr() # 计算DataFrame的相关系数
In[]: returns.cov() # 计算DataFrame的协方差
唯一值、值计数及成员资格
In[]: obj = Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
In[]: unique = obj.unique()
In[]: obj.value_counts()
处理缺失数据
| 方法 | 说明 |
|---|---|
| dropna | 根据标签中的值中是否存在缺失数据对轴标签进行过滤，可通过阈值调节对缺失值的容忍度 |
| fillna | 用指定值或插值方法ffill或bfill填充缺失数据 |
| isnull | 返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值 |
| notnull | isnull的否定式 |
In[]: df = DataFrame(np.random.randn(3, 7))
In[]: from numpy import nan as NA
In[]: df.ix[:4, 4] = NA; df.ix[:2, 2] = NA
In[]: df.fillna(0) # 将所有的nan值替换为0
In[]: df.fillna({1:0.5, 3:-1})
In[]: df.fillna(method = 'ffill', limit=2)
In[]: data = Series([1., NA, 7., NA, 3.5])
In[]: data.ffill(data.mean()) # 用数组的均值填充（很有用哦）
fillna函数的参数
|参数|说明|
|:--😐:--😐
|value|用于填充缺失值的标量值或字典对象|
|method|表明插值方式。默认为“ffill -- 前向填充”|
|axis|待填充的轴，默认为axis = 0|
|inplace|修改调用者对象而不产生副本|
|limit|（对于前向和后向填充）可以连续填充的最大数量|
层次化索引（hierarchical indexing）
它使我们能够在一个轴上拥有多个索引级别。
In [35]: data = Series(np.random.randn(10), index=[['a','a','a','b','b','b','c','c','d','d'],[1
...: ,2,3,1,2,3,1,2,2,3]])
In [36]: data
Out[36]:
a 1 -0.335981
2 -1.771950
3 0.847548
b 1 1.806644
2 -0.550041
3 0.409235
c 1 1.429005
2 1.111154
d 2 -0.769956
3 1.675767
dtype: float64
In [37]: data.index
Out[37]:
MultiIndex(levels=[[u'a', u'b', u'c', u'd'], [1, 2, 3]],
labels=[[0, 0, 0, 1, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 1, 2, 0, 1, 1, 2]])
In[]: data['a']
In[]: data.ix[['a', 'c']]
In[]: data['b': 'd']
In [50]: data[:, 1] # 对内层进行索引，显示
Out[50]:
a -0.335981
b 1.806644
c 1.429005
# 用unstack将多层索引Series映射到一个DataFrame中
In [51]: data.unstack()
Out[51]:
1 2 3
a -0.335981 -1.771950 0.847548
b 1.806644 -0.550041 0.409235
c 1.429005 1.111154 NaN
d NaN -0.769956 1.675767
#用stack()将DataFrame重新索引到一个Series中
In [52]: data.unstack().stack()
Out[52]:
a 1 -0.335981
2 -1.771950
3 0.847548
b 1 1.806644
2 -0.550041
3 0.409235
c 1 1.429005
2 1.111154
d 2 -0.769956
3 1.675767
In [53]: df = DataFrame(np.arange(12).reshape(4,3), index = [['a','a','b','b'],[1,2,1,2]], colu
...: mns = [['Ohio','Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
In [54]: df
Out[54]:
Ohio Colorado
Green Red Green
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11
In [55]: df.index.names = ['key1', 'key2']
In [56]: df
Out[56]:
Ohio Colorado
Green Red Green
key1 key2
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11
# 重新分级排序
In [63]: df.swaplevel('key1', 'key2')
Out[63]:
state Ohio Colorado
color Green Red Green
key2 key1
1 a 0 1 2
2 a 3 4 5
1 b 6 7 8
2 b 9 10 11
