Python -- pandas

标签（空格分隔）： Python

---

数据结构

#首先引入需要使用的模块from pandas import Series, DataFrameimport pandas as pd

Series

Series类似于一维数组的对象，由一组数据以及一组与之相关的数据标签组成。传入一个数组，将会创建一个0-N-1的整数型索引。

In[]: obj = Series([2,3,4,-3])In[]: obj.valuesIn[]: obj.indexIn[]: obj = Series([2,3,4,-3], index=['d', 'b', 'a', 'c']) # 为键值指定索引In[]: obj['a'] #取出相应索引位置的值In[]: obj[obj > 0]In[]: obj * 2In[]: np.exp(obj)In[]: 'b' in objIn[]: sdata = {'Ohio' : 35000, 'Texas' : 71000, 'Oregen' : 16000, 'Utath' : 5000} # 创建一个词典In[]: obj2 = Series(sdata) # 用字典创建SeriesIn[]: 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.indexIn[]: 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 = indexIn[]: 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'] # 1In[]: obj[1] # 1In[]: obj[2:4] # c 2 d 3In[]: obj[['a', 'c']] # 0 2In[]: obj[obj < 2] # a 0 b 1In[]: 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]: s1Out[64]: a    7.3c   -2.5d    3.4e    1.5dtype: float64In [65]: s2Out[65]: a   -2.1c    3.6e   -1.5f    4.0g    3.1dtype: float64In [66]: s1 + s2Out[66]: a    5.2c    1.1d    NaNe    0.0f    NaNg    NaNdtype: float64In [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]: df1Out[69]:             b    c    dOhio      0.0  1.0  2.0Texas     3.0  4.0  5.0Colorado  6.0  7.0  8.0In [70]: df2Out[70]:           b     d     eUtah    0.0   1.0   2.0Ohio    3.0   4.0   5.0Texas   6.0   7.0   8.0Oregon  9.0  10.0  11.0In [71]: df1 + df2Out[71]:             b   c     d   eColorado  NaN NaN   NaN NaNOhio      3.0 NaN   6.0 NaNOregon    NaN NaN   NaN NaNTexas     9.0 NaN  12.0 NaNUtah      NaN NaN   NaN NaNIn[]: 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         emin -2.789435 -0.110705 -1.101437max  0.653851  1.258250  1.592027In[]: format = lambda x: '%2.f' % xIn[]: frame.applymap(format) # for DataFrameIn[]: 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]: frameOut[110]:        d  a  b  cthree  0  1  2  3one    4  5  6  7In [111]: frame.sort_index()Out[111]:        d  a  b  cone    4  5  6  7three  0  1  2  3In[]: 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]: frameOut[120]:    a  b0  0  41  1  72  0 -33  1  2In [121]: frame.sort_index(by='b')Out[121]:    a  b2  0 -33  1  20  0  41  1  7

汇总和计算描述统计

约简方法的选项：

选项 说明 axis 约简的轴。DataFrame的行用0，列用1 skipna 排除缺失值，默认为True level 如果轴是层次化索引的，则根据level分组约简

相关系数与协方差

import pandas.io.data as weball_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 NAIn[]: df.ix[:4, 4] = NA; df.ix[:2, 2] = NAIn[]: df.fillna(0) # 将所有的nan值替换为0In[]: 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]: dataOut[36]: a  1   -0.335981   2   -1.771950   3    0.847548b  1    1.806644   2   -0.550041   3    0.409235c  1    1.429005   2    1.111154d  2   -0.769956   3    1.675767dtype: float64In [37]: data.indexOut[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.335981b    1.806644c    1.429005# 用unstack将多层索引Series映射到一个DataFrame中In [51]: data.unstack()Out[51]:           1         2         3a -0.335981 -1.771950  0.847548b  1.806644 -0.550041  0.409235c  1.429005  1.111154       NaNd       NaN -0.769956  1.675767#用stack()将DataFrame重新索引到一个Series中In [52]: data.unstack().stack()Out[52]: a  1   -0.335981   2   -1.771950   3    0.847548b  1    1.806644   2   -0.550041   3    0.409235c  1    1.429005   2    1.111154d  2   -0.769956   3    1.675767In [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]: dfOut[54]:      Ohio     Colorado    Green Red    Greena 1     0   1        2  2     3   4        5b 1     6   7        8  2     9  10       11In [55]: df.index.names = ['key1', 'key2']In [56]: dfOut[56]:            Ohio     Colorado          Green Red    Greenkey1 key2                   a    1        0   1        2     2        3   4        5b    1        6   7        8     2        9  10       11# 重新分级排序In [63]: df.swaplevel('key1', 'key2')Out[63]: state      Ohio     Coloradocolor     Green Red    Greenkey2 key1                   1    a        0   1        22    a        3   4        51    b        6   7        82    b        9  10       11