Pandas python
原文：
https://github.com/catalystfrank/Python4DataScience.CH
和大熊猫们(Pandas)一起游戏吧！
Pandas是Python的一个用于数据分析的库： http://pandas.pydata.org
API速查：http://pandas.pydata.org/pandas-docs/stable/api.html
基于NumPy,SciPy的功能，在其上补充了大量的数据操作（Data Manipulation）功能。
统计、分组、排序、透视表自由转换，如果你已经很熟悉结构化数据库（RDBMS）与Excel的功能，就会知道Pandas有过之而无不及！
0. 上手玩：Why Pandas?
普通的程序员看到一份数据会怎么做？
In [1]:
import codecs
import requests
import numpy as np
import scipy as sp
import scipy.stats as spstat
import pandas as pd
import datetime
import json
In [2]:
r = requests.get("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data")
with codecs.open('S1EP3_Iris.txt','w',encoding='utf-8') as f:
f.write(r.text)
In [3]:
with codecs.open('S1EP3_Iris.txt','r',encoding='utf-8') as f:
lines = f.readlines()
for idx,line in enumerate(lines):
print line,
if idx==10:
break
5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
5.4,3.9,1.7,0.4,Iris-setosa
4.6,3.4,1.4,0.3,Iris-setosa
5.0,3.4,1.5,0.2,Iris-setosa
4.4,2.9,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.4,3.7,1.5,0.2,Iris-setosa
Pandas的意义就在于
快速的识别结构化数据
In [19]:
import pandas as pd
irisdata = pd.read_csv('S1EP3_Iris.txt',header = None, encoding='utf-8')
#irisdata
快速的操作元数据
In [22]:
cnames = ['sepal_length','sepal_width','petal_length','petal_width','class']
irisdata.columns = cnames
#irisdata
快速过滤
In [11]:
#irisdata[irisdata['petal_width']==irisdata.petal_width.max()]
irisdata[irisdata['sepal_length']==irisdata.sepal_length.max()]
Out[11]:
| sepal_length | sepal_width | petal_length | petal_width | class | |
|---|---|---|---|---|---|
| 131 | 7.9 | 3.8 | 6.4 | 2 | Iris-virginica |
快速切片
In [23]:
#irisdata.iloc[::30,:2]
irisdata.iloc[::40,0:3]
Out[23]:
| sepal_length | sepal_width | petal_length | |
|---|---|---|---|
| 0 | 5.1 | 3.5 | 1.4 |
| 40 | 5.0 | 3.5 | 1.3 |
| 80 | 5.5 | 2.4 | 3.8 |
| 120 | 6.9 | 3.2 | 5.7 |
快速统计
In [31]:
#print irisdata['class'].value_counts()
for x in xrange(4):
s = irisdata.iloc[:,x]
print '{0:<12}'.format(s.name.upper()), " Statistics: ", \
'{0:>5} {1:>5} {2:>5} {3:>5}'.format(s.max(), s.min(), round(s.mean(),2),round(s.std(),2))
SEPAL_LENGTH Statistics: 7.9 4.3 5.84 0.83
SEPAL_WIDTH Statistics: 4.4 2.0 3.05 0.43
PETAL_LENGTH Statistics: 6.9 1.0 3.76 1.76
PETAL_WIDTH Statistics: 2.5 0.1 1.2 0.76
快速“MapReduce”
In [9]:
slogs = lambda x:sp.log(x)*x
entpy = lambda x:sp.exp((slogs(x.sum())-x.map(slogs).sum())/x.sum())
irisdata.groupby('class').agg(entpy)
Out[9]:
| sepal_length | sepal_width | petal_length | petal_width | |
|---|---|---|---|---|
| class | ||||
| Iris-setosa | 49.878745 | 49.695242 | 49.654909 | 45.810069 |
| Iris-versicolor | 49.815081 | 49.680665 | 49.694505 | 49.452305 |
| Iris-virginica | 49.772059 | 49.714500 | 49.761700 | 49.545918 |
1. 欢迎来到大熊猫世界
Pandas的重要数据类型
- DataFrame(二维表)
- Series(一维序列)
- Index(行索引，行级元数据)
1.1 Series：pandas的长枪(数据表中的一列或一行,观测向量,一维数组...)
数据世界中对于任意一个个体的全面观测，或者对于任意一组个体某一属性的观测，全部可以抽象为Series的概念。
用值构建一个Series：
由默认index和values组成。
In [10]:
Series1 = pd.Series(np.random.randn(4))
print Series1,type(Series1)
print Series1.index
print Series1.values
0 -0.909672
1 1.739425
2 -1.163028
3 0.408693
dtype: float64 <class 'pandas.core.series.Series'>
Int64Index([0, 1, 2, 3], dtype='int64')
[-0.90967166 1.73942495 -1.1630284 0.40869312]
Series支持过滤的原理就如同NumPy：
In [11]:
print Series1>0
print Series1[Series1>0]
0 False
1 True
2 False
3 True
dtype: bool
1 1.739425
3 0.408693
dtype: float64
当然也支持Broadcasting：
In [12]:
print Series1*2
print Series1+5
0 -1.819343
1 3.478850
2 -2.326057
3 0.817386
dtype: float64
0 4.090328
1 6.739425
2 3.836972
3 5.408693
dtype: float64
以及Universal Function：
In [13]:
print np.exp(Series1)
#NumPy Universal Function
f_np = np.frompyfunc(lambda x:np.exp(x*2+5),1,1)
print f_np(Series1)
0 0.402656
1 5.694068
2 0.312538
3 1.504850
dtype: float64
0 24.06255
1 4811.913
2 14.49702
3 336.0924
dtype: object
在序列上就使用行标，而不是创建一个2列的数据表，能够轻松辨别哪里是数据，哪里是元数据：
In [14]:
Series2 = pd.Series(Series1.values,index=['norm_'+unicode(i) for i in xrange(4)])
print Series2,type(Series2)
print Series2.index
print type(Series2.index)
print Series2.values
norm_0 -0.909672
norm_1 1.739425
norm_2 -1.163028
norm_3 0.408693
dtype: float64 <class 'pandas.core.series.Series'>
Index([u'norm_0', u'norm_1', u'norm_2', u'norm_3'], dtype='object')
<class 'pandas.core.index.Index'>
[-0.90967166 1.73942495 -1.1630284 0.40869312]
虽然行是有顺序的，但是仍然能够通过行级的index来访问到数据：
（当然也不尽然像Ordered Dict，因为行索引甚至可以重复，不推荐重复的行索引不代表不能用）
In [15]:
print Series2[['norm_0','norm_3']]
norm_0 -0.909672
norm_3 0.408693
dtype: float64
In [16]:
print 'norm_0' in Series2
print 'norm_6' in Series2
True
False
默认行索引就像行号一样：
In [17]:
print Series1.index
Int64Index([0, 1, 2, 3], dtype='int64')
从Key不重复的Ordered Dict或者从Dict来定义Series就不需要担心行索引重复：
In [18]:
Series3_Dict = {"Japan":"Tokyo","S.Korea":"Seoul","China":"Beijing"}
Series3_pdSeries = pd.Series(Series3_Dict)
print Series3_pdSeries
print Series3_pdSeries.values
print Series3_pdSeries.index
China Beijing
Japan Tokyo
S.Korea Seoul
dtype: object
['Beijing' 'Tokyo' 'Seoul']
Index([u'China', u'Japan', u'S.Korea'], dtype='object')
与Dict区别一： 有序
In [19]:
Series4_IndexList = ["Japan","China","Singapore","S.Korea"]
Series4_pdSeries = pd.Series( Series3_Dict ,index = Series4_IndexList)
print Series4_pdSeries
print Series4_pdSeries.values
print Series4_pdSeries.index
print Series4_pdSeries.isnull()
print Series4_pdSeries.notnull()
Japan Tokyo
China Beijing
Singapore NaN
S.Korea Seoul
dtype: object
['Tokyo' 'Beijing' nan 'Seoul']
Index([u'Japan', u'China', u'Singapore', u'S.Korea'], dtype='object')
Japan False
China False
Singapore True
S.Korea False
dtype: bool
Japan True
China True
Singapore False
S.Korea True
dtype: bool
与Dict区别二： index内值可以重复，尽管不推荐。
In [20]:
Series5_IndexList = ['A','B','B','C']
Series5 = pd.Series(Series1.values,index = Series5_IndexList)
print Series5
print Series5[['B','A']]
A -0.909672
B 1.739425
B -1.163028
C 0.408693
dtype: float64
B 1.739425
B -1.163028
A -0.909672
dtype: float64
整个序列级别的元数据信息：name
当数据序列以及index本身有了名字，就可以更方便的进行后续的数据关联啦！
In [21]:
print Series4_pdSeries.name
print Series4_pdSeries.index.name
None
None
In [22]:
Series4_pdSeries.name = "Capital Series"
Series4_pdSeries.index.name = "Nation"
print Series4_pdSeries
pd.DataFrame(Series4_pdSeries)
Nation
Japan Tokyo
China Beijing
Singapore NaN
S.Korea Seoul
Name: Capital Series, dtype: object
Out[22]:
| Capital Series | |
|---|---|
| Nation | |
| Japan | Tokyo |
| China | Beijing |
| Singapore | NaN |
| S.Korea | Seoul |
1.2 DataFrame：pandas的战锤(数据表，二维数组)
Series的有序集合，就像R的DataFrame一样方便。
仔细想想，绝大部分的数据形式都可以表现为DataFrame。
从NumPy二维数组、从文件或者从数据库定义：数据虽好，勿忘列名
In [23]:
dataNumPy = np.asarray([('Japan','Tokyo',4000),\
('S.Korea','Seoul',1300),('China','Beijing',9100)])
DF1 = pd.DataFrame(dataNumPy,columns=['nation','capital','GDP'])
DF1
Out[23]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | Japan | Tokyo | 4000 |
| 1 | S.Korea | Seoul | 1300 |
| 2 | China | Beijing | 9100 |
等长的列数据保存在一个字典里（JSON）：很不幸，字典key是无序的
In [24]:
dataDict = {'nation':['Japan','S.Korea','China'],\
'capital':['Tokyo','Seoul','Beijing'],'GDP':[4900,1300,9100]}
DF2 = pd.DataFrame(dataDict)
DF2
Out[24]:
| GDP | capital | nation | |
|---|---|---|---|
| 0 | 4900 | Tokyo | Japan |
| 1 | 1300 | Seoul | S.Korea |
| 2 | 9100 | Beijing | China |
从另一个DataFrame定义DataFrame：啊，强迫症犯了！
In [25]:
DF21 = pd.DataFrame(DF2,columns=['nation','capital','GDP'])
DF21
Out[25]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | Japan | Tokyo | 4900 |
| 1 | S.Korea | Seoul | 1300 |
| 2 | China | Beijing | 9100 |
In [26]:
DF22 = pd.DataFrame(DF2,columns=['nation','capital','GDP'],index = [2,0,1])
DF22
Out[26]:
| nation | capital | GDP | |
|---|---|---|---|
| 2 | China | Beijing | 9100 |
| 0 | Japan | Tokyo | 4900 |
| 1 | S.Korea | Seoul | 1300 |
从DataFrame中取出列？两种方法（与JavaScript完全一致！）
- '.'的写法容易与其他预留关键字产生冲突
- '[ ]'的写法最安全。
In [27]:
print DF22.nation
print DF22.capital
print DF22['GDP']
2 China
0 Japan
1 S.Korea
Name: nation, dtype: object
2 Beijing
0 Tokyo
1 Seoul
Name: capital, dtype: object
2 9100
0 4900
1 1300
Name: GDP, dtype: int64
从DataFrame中取出行？（至少）两种方法：
In [28]:
print DF22[0:1] #给出的实际是DataFrame
print DF22.ix[0] #通过对应Index给出行
nation capital GDP
2 China Beijing 9100
nation Japan
capital Tokyo
GDP 4900
Name: 0, dtype: object
像NumPy切片一样的终极招式：iloc
In [29]:
print DF22.iloc[0,:]
print DF22.iloc[:,0]
nation China
capital Beijing
GDP 9100
Name: 2, dtype: object
2 China
0 Japan
1 S.Korea
Name: nation, dtype: object
听说你从Alter Table地狱来，大熊猫笑了
然而动态增加列无法用"."的方式完成，只能用"[ ]"
In [30]:
DF22['population'] = [1600,130,55]
DF22['region'] = 'East_Asian'
DF22
Out[30]:
| nation | capital | GDP | population | region | |
|---|---|---|---|---|---|
| 2 | China | Beijing | 9100 | 1600 | East_Asian |
| 0 | Japan | Tokyo | 4900 | 130 | East_Asian |
| 1 | S.Korea | Seoul | 1300 | 55 | East_Asian |
In [ ]:
1.3 Index：pandas进行数据操纵的鬼牌（行级索引）
行级索引是
- 元数据
- 可能由真实数据产生，因此可以视作数据
- 可以由多重索引也就是多个列组合而成
- 可以和列名进行交换，也可以进行堆叠和展开，达到Excel透视表效果
Index有四种...哦不，很多种写法，一些重要的索引类型包括
- pd.Index（普通）
- Int64Index（数值型索引）
- MultiIndex（多重索引，在数据操纵中更详细描述）
- DatetimeIndex（以时间格式作为索引）
- PeriodIndex （含周期的时间格式作为索引）
直接定义普通索引，长得就和普通的Series一样
In [31]:
index_names = ['a','b','c']
Series_for_Index = pd.Series(index_names)
print pd.Index(index_names)
print pd.Index(Series_for_Index)
Index([u'a', u'b', u'c'], dtype='object')
Index([u'a', u'b', u'c'], dtype='object')
可惜Immutable，牢记！
In [32]:
index_names = ['a','b','c']
index0 = pd.Index(index_names)
print index0.get_values()
index0[2] = 'd'
['a' 'b' 'c']
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-32-f34da0a8623c> in <module>()
2 index0 = pd.Index(index_names)
3 print index0.get_values()
----> 4 index0[2] = 'd' /Users/wangweiyang/anaconda/anaconda/lib/python2.7/site-packages/pandas/core/index.pyc in __setitem__(self, key, value)
1055
1056 def __setitem__(self, key, value):
-> 1057 raise TypeError("Indexes does not support mutable operations")
1058
1059 def __getitem__(self, key): TypeError: Indexes does not support mutable operations
扔进去一个含有多元组的List，就有了MultiIndex
可惜，如果这个List Comprehension改成小括号，就不对了。
In [33]:
#print [('Row_'+str(x+1),'Col_'+str(y+1)) for x in xrange(4) for y in xrange(4)]
multi1 = pd.Index([('Row_'+str(x+1),'Col_'+str(y+1)) for x in xrange(4) for y in xrange(4)])
multi1.name = ['index1','index2']
print multi1
MultiIndex(levels=[[u'Row_1', u'Row_2', u'Row_3', u'Row_4'], [u'Col_1', u'Col_2', u'Col_3', u'Col_4']],
labels=[[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]])
对于Series来说，如果拥有了多重Index，数据，变形！
下列代码说明：
- 二重MultiIndex的Series可以unstack()成DataFrame
- DataFrame可以stack成拥有二重MultiIndex的Series
In [34]:
data_for_multi1 = pd.Series(xrange(0,16),index=multi1)
data_for_multi1
Out[34]:
Row_1 Col_1 0
Col_2 1
Col_3 2
Col_4 3
Row_2 Col_1 4
Col_2 5
Col_3 6
Col_4 7
Row_3 Col_1 8
Col_2 9
Col_3 10
Col_4 11
Row_4 Col_1 12
Col_2 13
Col_3 14
Col_4 15
dtype: int64
In [35]:
data_for_multi1.unstack()
Out[35]:
| Col_1 | Col_2 | Col_3 | Col_4 | |
|---|---|---|---|---|
| Row_1 | 0 | 1 | 2 | 3 |
| Row_2 | 4 | 5 | 6 | 7 |
| Row_3 | 8 | 9 | 10 | 11 |
| Row_4 | 12 | 13 | 14 | 15 |
In [36]:
data_for_multi1.unstack().stack()
Out[36]:
Row_1 Col_1 0
Col_2 1
Col_3 2
Col_4 3
Row_2 Col_1 4
Col_2 5
Col_3 6
Col_4 7
Row_3 Col_1 8
Col_2 9
Col_3 10
Col_4 11
Row_4 Col_1 12
Col_2 13
Col_3 14
Col_4 15
dtype: int64
我们来看一下非平衡数据的例子：
Row_1,2,3,4和Col_1,2,3,4并不是全组合的。
In [37]:
multi2 = pd.Index([('Row_'+str(x),'Col_'+str(y+1)) \
for x in xrange(5) for y in xrange(x)])
multi2
Out[37]:
MultiIndex(levels=[[u'Row_1', u'Row_2', u'Row_3', u'Row_4'], [u'Col_1', u'Col_2', u'Col_3', u'Col_4']],
labels=[[0, 1, 1, 2, 2, 2, 3, 3, 3, 3], [0, 0, 1, 0, 1, 2, 0, 1, 2, 3]])
In [38]:
data_for_multi2 = pd.Series(np.arange(10),index = multi2)
data_for_multi2
Out[38]:
Row_1 Col_1 0
Row_2 Col_1 1
Col_2 2
Row_3 Col_1 3
Col_2 4
Col_3 5
Row_4 Col_1 6
Col_2 7
Col_3 8
Col_4 9
dtype: int64
In [39]:
data_for_multi2.unstack()
Out[39]:
| Col_1 | Col_2 | Col_3 | Col_4 | |
|---|---|---|---|---|
| Row_1 | 0 | NaN | NaN | NaN |
| Row_2 | 1 | 2 | NaN | NaN |
| Row_3 | 3 | 4 | 5 | NaN |
| Row_4 | 6 | 7 | 8 | 9 |
In [40]:
data_for_multi2.unstack().stack()
Out[40]:
Row_1 Col_1 0
Row_2 Col_1 1
Col_2 2
Row_3 Col_1 3
Col_2 4
Col_3 5
Row_4 Col_1 6
Col_2 7
Col_3 8
Col_4 9
dtype: float64
DateTime标准库如此好用，你值得拥有
In [41]:
dates = [datetime.datetime(2015,1,1),datetime.datetime(2015,1,8),datetime.datetime(2015,1,30)]
pd.DatetimeIndex(dates)
Out[41]:
DatetimeIndex(['2015-01-01', '2015-01-08', '2015-01-30'], dtype='datetime64[ns]', freq=None, tz=None)
如果你不仅需要时间格式统一，时间频率也要统一的话
In [42]:
periodindex1 = pd.period_range('2015-01','2015-04',freq='M')
print periodindex1
PeriodIndex(['2015-01', '2015-02', '2015-03', '2015-04'], dtype='int64', freq='M')
月级精度和日级精度如何转换？
有的公司统一以1号代表当月，有的公司统一以最后一天代表当月，转化起来很麻烦，可以asfreq
In [43]:
print periodindex1.asfreq('D',how='start')
print periodindex1.asfreq('D',how='end')
PeriodIndex(['2015-01-01', '2015-02-01', '2015-03-01', '2015-04-01'], dtype='int64', freq='D')
PeriodIndex(['2015-01-31', '2015-02-28', '2015-03-31', '2015-04-30'], dtype='int64', freq='D')
最后的最后，我要真正把两种频率的时间精度匹配上？
In [44]:
periodindex_mon = pd.period_range('2015-01','2015-03',freq='M').asfreq('D',how='start')
periodindex_day = pd.period_range('2015-01-01','2015-03-31',freq='D')
print periodindex_mon
print periodindex_day
PeriodIndex(['2015-01-01', '2015-02-01', '2015-03-01'], dtype='int64', freq='D')
PeriodIndex(['2015-01-01', '2015-01-02', '2015-01-03', '2015-01-04',
'2015-01-05', '2015-01-06', '2015-01-07', '2015-01-08',
'2015-01-09', '2015-01-10', '2015-01-11', '2015-01-12',
'2015-01-13', '2015-01-14', '2015-01-15', '2015-01-16',
'2015-01-17', '2015-01-18', '2015-01-19', '2015-01-20',
'2015-01-21', '2015-01-22', '2015-01-23', '2015-01-24',
'2015-01-25', '2015-01-26', '2015-01-27', '2015-01-28',
'2015-01-29', '2015-01-30', '2015-01-31', '2015-02-01',
'2015-02-02', '2015-02-03', '2015-02-04', '2015-02-05',
'2015-02-06', '2015-02-07', '2015-02-08', '2015-02-09',
'2015-02-10', '2015-02-11', '2015-02-12', '2015-02-13',
'2015-02-14', '2015-02-15', '2015-02-16', '2015-02-17',
'2015-02-18', '2015-02-19', '2015-02-20', '2015-02-21',
'2015-02-22', '2015-02-23', '2015-02-24', '2015-02-25',
'2015-02-26', '2015-02-27', '2015-02-28', '2015-03-01',
'2015-03-02', '2015-03-03', '2015-03-04', '2015-03-05',
'2015-03-06', '2015-03-07', '2015-03-08', '2015-03-09',
'2015-03-10', '2015-03-11', '2015-03-12', '2015-03-13',
'2015-03-14', '2015-03-15', '2015-03-16', '2015-03-17',
'2015-03-18', '2015-03-19', '2015-03-20', '2015-03-21',
'2015-03-22', '2015-03-23', '2015-03-24', '2015-03-25',
'2015-03-26', '2015-03-27', '2015-03-28', '2015-03-29',
'2015-03-30', '2015-03-31'],
dtype='int64', freq='D')
粗粒度数据＋reindex＋ffill/bfill
In [45]:
#print pd.Series(periodindex_mon,index=periodindex_mon).reindex(periodindex_day)
full_ts = pd.Series(periodindex_mon,index=periodindex_mon).reindex(periodindex_day)
full_ts
Out[45]:
2015-01-01 2015-01-01
2015-01-02 NaN
2015-01-03 NaN
2015-01-04 NaN
2015-01-05 NaN
2015-01-06 NaN
2015-01-07 NaN
2015-01-08 NaN
2015-01-09 NaN
2015-01-10 NaN
2015-01-11 NaN
2015-01-12 NaN
2015-01-13 NaN
2015-01-14 NaN
2015-01-15 NaN
2015-01-16 NaN
2015-01-17 NaN
2015-01-18 NaN
2015-01-19 NaN
2015-01-20 NaN
2015-01-21 NaN
2015-01-22 NaN
2015-01-23 NaN
2015-01-24 NaN
2015-01-25 NaN
2015-01-26 NaN
2015-01-27 NaN
2015-01-28 NaN
2015-01-29 NaN
2015-01-30 NaN
...
2015-03-02 NaN
2015-03-03 NaN
2015-03-04 NaN
2015-03-05 NaN
2015-03-06 NaN
2015-03-07 NaN
2015-03-08 NaN
2015-03-09 NaN
2015-03-10 NaN
2015-03-11 NaN
2015-03-12 NaN
2015-03-13 NaN
2015-03-14 NaN
2015-03-15 NaN
2015-03-16 NaN
2015-03-17 NaN
2015-03-18 NaN
2015-03-19 NaN
2015-03-20 NaN
2015-03-21 NaN
2015-03-22 NaN
2015-03-23 NaN
2015-03-24 NaN
2015-03-25 NaN
2015-03-26 NaN
2015-03-27 NaN
2015-03-28 NaN
2015-03-29 NaN
2015-03-30 NaN
2015-03-31 NaN
Freq: D, dtype: object
In [46]:
full_ts = pd.Series(periodindex_mon,index=periodindex_mon).reindex(periodindex_day,method='ffill')
full_ts
Out[46]:
2015-01-01 2015-01-01
2015-01-02 2015-01-01
2015-01-03 2015-01-01
2015-01-04 2015-01-01
2015-01-05 2015-01-01
2015-01-06 2015-01-01
2015-01-07 2015-01-01
2015-01-08 2015-01-01
2015-01-09 2015-01-01
2015-01-10 2015-01-01
2015-01-11 2015-01-01
2015-01-12 2015-01-01
2015-01-13 2015-01-01
2015-01-14 2015-01-01
2015-01-15 2015-01-01
2015-01-16 2015-01-01
2015-01-17 2015-01-01
2015-01-18 2015-01-01
2015-01-19 2015-01-01
2015-01-20 2015-01-01
2015-01-21 2015-01-01
2015-01-22 2015-01-01
2015-01-23 2015-01-01
2015-01-24 2015-01-01
2015-01-25 2015-01-01
2015-01-26 2015-01-01
2015-01-27 2015-01-01
2015-01-28 2015-01-01
2015-01-29 2015-01-01
2015-01-30 2015-01-01
...
2015-03-02 2015-03-01
2015-03-03 2015-03-01
2015-03-04 2015-03-01
2015-03-05 2015-03-01
2015-03-06 2015-03-01
2015-03-07 2015-03-01
2015-03-08 2015-03-01
2015-03-09 2015-03-01
2015-03-10 2015-03-01
2015-03-11 2015-03-01
2015-03-12 2015-03-01
2015-03-13 2015-03-01
2015-03-14 2015-03-01
2015-03-15 2015-03-01
2015-03-16 2015-03-01
2015-03-17 2015-03-01
2015-03-18 2015-03-01
2015-03-19 2015-03-01
2015-03-20 2015-03-01
2015-03-21 2015-03-01
2015-03-22 2015-03-01
2015-03-23 2015-03-01
2015-03-24 2015-03-01
2015-03-25 2015-03-01
2015-03-26 2015-03-01
2015-03-27 2015-03-01
2015-03-28 2015-03-01
2015-03-29 2015-03-01
2015-03-30 2015-03-01
2015-03-31 2015-03-01
Freq: D, dtype: object
关于索引，方便的操作有？
前面描述过了，索引有序，重复，但一定程度上又能通过key来访问，也就是说，某些集合操作都是可以支持的。
In [47]:
index1 = pd.Index(['A','B','B','C','C'])
index2 = pd.Index(['C','D','E','E','F'])
index3 = pd.Index(['B','C','A'])
print index1.append(index2)
print index1.difference(index2)
print index1.intersection(index2)
print index1.union(index2) # Support unique-value Index well
print index1.isin(index2)
print index1.delete(2)
print index1.insert(0,'K') # Not suggested
print index3.drop('A') # Support unique-value Index well
print index1.is_monotonic,index2.is_monotonic,index3.is_monotonic
print index1.is_unique,index2.is_unique,index3.is_unique
Index([u'A', u'B', u'B', u'C', u'C', u'C', u'D', u'E', u'E', u'F'], dtype='object')
Index([u'A', u'B'], dtype='object')
Index([u'C', u'C'], dtype='object')
Index([u'A', u'B', u'B', u'C', u'C', u'D', u'E', u'E', u'F'], dtype='object')
[False False False True True]
Index([u'A', u'B', u'C', u'C'], dtype='object')
Index([u'K', u'A', u'B', u'B', u'C', u'C'], dtype='object')
Index([u'B', u'C'], dtype='object')
True True False
False False True
2. 大熊猫世界来去自如：Pandas的I/O
老生常谈，从基础来看，我们仍然关心pandas对于与外部数据是如何交互的。
2.1 结构化数据输入输出
- read_csv与to_csv 是一对输入输出的工具，read_csv直接返回pandas.DataFrame，而to_csv只要执行命令即可写文件
- read_table：功能类似
- read_fwf：操作fixed width file
- read_excel与to_excel方便的与excel交互
还记得刚开始的例子吗？
- header 表示数据中是否存在列名，如果在第0行就写就写0，并且开始读数据时跳过相应的行数，不存在可以写none
- names 表示要用给定的列名来作为最终的列名
- encoding 表示数据集的字符编码，通常而言一份数据为了方便的进行文件传输都以utf-8作为标准
提问：下列例子中，header=4，names=cnames时，究竟会读到怎样的数据？
In [48]:
print cnames
irisdata = pd.read_csv('S1EP3_Iris.txt',header = None, names = cnames,\
encoding='utf-8')
irisdata[::30]
['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class']
Out[48]:
| sepal_length | sepal_width | petal_length | petal_width | class | |
|---|---|---|---|---|---|
| 0 | 5.1 | 3.5 | 1.4 | 0.2 | Iris-setosa |
| 30 | 4.8 | 3.1 | 1.6 | 0.2 | Iris-setosa |
| 60 | 5.0 | 2.0 | 3.5 | 1.0 | Iris-versicolor |
| 90 | 5.5 | 2.6 | 4.4 | 1.2 | Iris-versicolor |
| 120 | 6.9 | 3.2 | 5.7 | 2.3 | Iris-virginica |
希望了解全部参数的请移步API：
http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html#pandas.read_csv
这里介绍一些常用的参数：
读取处理：
- skiprows：跳过一定的行数
- nrows：仅读取一定的行数
- skipfooter：尾部有固定的行数永不读取
- skip_blank_lines：空行跳过
内容处理：
- sep/delimiter：分隔符很重要，常见的有逗号，空格和Tab('\t')
- na_values：指定应该被当作na_values的数值
- thousands：处理数值类型时，每千位分隔符并不统一 (1.234.567,89或者1,234,567.89都可能)，此时要把字符串转化为数字需要指明千位分隔符
收尾处理：
- index_col：将真实的某列（列的数目，甚至列名）当作index
- squeeze：仅读到一列时，不再保存为pandas.DataFrame而是pandas.Series
2.1.x Excel ... ?
对于存储着极为规整数据的Excel而言，其实是没必要一定用Excel来存，尽管Pandas也十分友好的提供了I/O接口。
In [49]:
irisdata.to_excel('S1EP3_irisdata.xls',index = None,encoding='utf-8')
irisdata_from_excel = pd.read_excel('S1EP3_irisdata.xls',header=0, encoding='utf-8')
irisdata_from_excel[::30]
Out[49]:
| sepal_length | sepal_width | petal_length | petal_width | class | |
|---|---|---|---|---|---|
| 0 | 5.1 | 3.5 | 1.4 | 0.2 | Iris-setosa |
| 30 | 4.8 | 3.1 | 1.6 | 0.2 | Iris-setosa |
| 60 | 5.0 | 2.0 | 3.5 | 1.0 | Iris-versicolor |
| 90 | 5.5 | 2.6 | 4.4 | 1.2 | Iris-versicolor |
| 120 | 6.9 | 3.2 | 5.7 | 2.3 | Iris-virginica |
唯一重要的参数：sheetname=k，标志着一个excel的第k个sheet页将会被取出。（从0开始）
2.2 半结构化数据
JSON：网络传输中常用的一种数据格式。
仔细看一下，实际上这就是我们平时收集到异源数据的风格是一致的：
- 列名不能完全匹配
- 关联键可能并不唯一
- 元数据被保存在数据里
In [50]:
json_data = [{'name':'Wang','sal':50000,'job':'VP'},\
{'name':'Zhang','job':'Manager','report':'VP'},\
{'name':'Li','sal':5000,'report':'Manager'}]
data_employee = pd.read_json(json.dumps(json_data))
data_employee_ri = data_employee.reindex(columns=['name','job','sal','report'])
data_employee_ri
Out[50]:
| name | job | sal | report | |
|---|---|---|---|---|
| 0 | Wang | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager |
2.3 数据库连接流程（Optional）
使用下列包，通过数据库配置建立Connection
- pymysql
- pyODBC
- cx_Oracle
通过pandas.read_sql_query,read_sql_table,to_sql进行数据库操作。
Python与数据库的交互方案有很多种，从数据分析师角度看pandas方案比较适合，之后的讲义中会结合SQL语法进行讲解。
进行数据库连接首先你需要类似的这样一组信息：
In [ ]:
IP = '127.0.0.1'
us = 'root'
pw = '123456'
举例说明如果是MySQL：
In [ ]:
import pymysql
import pymysql.cursors
connection = pymysql.connect(host=IP,\
user=us,\
password=pw,\
charset='utf8mb4',\
cursorclass=pymysql.cursors.DictCursor)
#pd.read_sql_query("sql",connection)
#df.to_sql('tablename',connection,flavor='mysql')
3. 深入Pandas数据操纵
在第一部分的基础上，数据会有更多种操纵方式：
- 通过列名、行index来取数据，结合ix、iloc灵活的获取数据的一个子集（第一部分已经介绍）
- 按记录拼接（就像Union All）或者关联（join）
- 方便的自定义函数映射
- 排序
- 缺失值处理
- 与Excel一样灵活的数据透视表（在第四部分更详细介绍）
3.1 数据整合：方便灵活
3.1.1 横向拼接：直接DataFrame
In [51]:
pd.DataFrame([np.random.rand(2),np.random.rand(2),np.random.rand(2)],columns=['C1','C2'])
Out[51]:
| C1 | C2 | |
|---|---|---|
| 0 | 0.958384 | 0.826066 |
| 1 | 0.607771 | 0.687302 |
| 2 | 0.943502 | 0.647464 |
3.1.2 横向拼接：Concatenate
In [52]:
pd.concat([data_employee_ri,data_employee_ri,data_employee_ri])
Out[52]:
| name | job | sal | report | |
|---|---|---|---|---|
| 0 | Wang | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager |
| 0 | Wang | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager |
| 0 | Wang | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager |
In [53]:
pd.concat([data_employee_ri,data_employee_ri,data_employee_ri],ignore_index=True)
Out[53]:
| name | job | sal | report | |
|---|---|---|---|---|
| 0 | Wang | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager |
| 3 | Wang | VP | 50000 | NaN |
| 4 | Zhang | Manager | NaN | VP |
| 5 | Li | NaN | 5000 | Manager |
| 6 | Wang | VP | 50000 | NaN |
| 7 | Zhang | Manager | NaN | VP |
| 8 | Li | NaN | 5000 | Manager |
3.1.3 纵向拼接：Merge
根据数据列关联，使用on关键字
- 可以指定一列或多列
- 可以使用left_on和right_on
In [54]:
pd.merge(data_employee_ri,data_employee_ri,on='name')
Out[54]:
| name | job_x | sal_x | report_x | job_y | sal_y | report_y | |
|---|---|---|---|---|---|---|---|
| 0 | Wang | VP | 50000 | NaN | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager | NaN | 5000 | Manager |
In [55]:
pd.merge(data_employee_ri,data_employee_ri,on=['name','job'])
Out[55]:
| name | job | sal_x | report_x | sal_y | report_y | |
|---|---|---|---|---|---|---|
| 0 | Wang | VP | 50000 | NaN | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP | NaN | VP |
| 2 | Li | NaN | 5000 | Manager | 5000 | Manager |
根据index关联，可以直接使用left_index和right_index
In [56]:
data_employee_ri.index.name = 'index1'
pd.merge(data_employee_ri,data_employee_ri,\
left_index='index1',right_index='index1')
Out[56]:
| name_x | job_x | sal_x | report_x | name_y | job_y | sal_y | report_y | |
|---|---|---|---|---|---|---|---|---|
| index1 | ||||||||
| 0 | Wang | VP | 50000 | NaN | Wang | VP | 50000 | NaN |
| 1 | Zhang | Manager | NaN | VP | Zhang | Manager | NaN | VP |
| 2 | Li | NaN | 5000 | Manager | Li | NaN | 5000 | Manager |
TIPS: 增加how关键字，并指定
- how = 'inner'
- how = 'left'
- how = 'right'
- how = 'outer'
结合how，可以看到merge基本再现了SQL应有的功能，并保持代码整洁。
In [57]:
DF31xA = pd.DataFrame({'name':[u'老王',u'老张',u'老李'],'sal':[5000,3000,1000]})
DF31xA
Out[57]:
| name | sal | |
|---|---|---|
| 0 | 老王 | 5000 |
| 1 | 老张 | 3000 |
| 2 | 老李 | 1000 |
In [58]:
DF31xB = pd.DataFrame({'name':[u'老王',u'老刘'],'job':['VP','Manager']})
DF31xB
Out[58]:
| job | name | |
|---|---|---|
| 0 | VP | 老王 |
| 1 | Manager | 老刘 |
how='left': 保留左表信息
In [59]:
pd.merge(DF31xA,DF31xB,on='name',how='left')
Out[59]:
| name | sal | job | |
|---|---|---|---|
| 0 | 老王 | 5000 | VP |
| 1 | 老张 | 3000 | NaN |
| 2 | 老李 | 1000 | NaN |
how='right': 保留右表信息
In [60]:
pd.merge(DF31xA,DF31xB,on='name',how='right')
Out[60]:
| name | sal | job | |
|---|---|---|---|
| 0 | 老王 | 5000 | VP |
| 1 | 老刘 | NaN | Manager |
how='inner': 保留两表交集信息，这样尽量避免出现缺失值
In [61]:
pd.merge(DF31xA,DF31xB,on='name',how='inner')
Out[61]:
| name | sal | job | |
|---|---|---|---|
| 0 | 老王 | 5000 | VP |
how='outer': 保留两表并集信息，这样会导致缺失值，但最大程度的整合了已有信息
In [62]:
pd.merge(DF31xA,DF31xB,on='name',how='outer')
Out[62]:
| name | sal | job | |
|---|---|---|---|
| 0 | 老王 | 5000 | VP |
| 1 | 老张 | 3000 | NaN |
| 2 | 老李 | 1000 | NaN |
| 3 | 老刘 | NaN | Manager |
3.2 数据清洗三剑客
接下来的三个功能，map,applymap,apply,功能，是绝大多数数据分析师在数据清洗这一步骤中的必经之路。
他们分别回答了以下问题：
- 我想根据一列数据新做一列数据，怎么办？（Series->Series）
- 我想根据整张表的数据新做整张表，怎么办？ （DataFrame->DataFrame）
- 我想根据很多列的数据新做一列数据，怎么办？ （DataFrame->Series）
不要再写什么for循环了！改变思维，提高编码和执行效率
In [63]:
dataNumPy32 = np.asarray([('Japan','Tokyo',4000),('S.Korea','Seoul',1300),('China','Beijing',9100)])
DF32 = pd.DataFrame(dataNumPy,columns=['nation','capital','GDP'])
DF32
Out[63]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | Japan | Tokyo | 4000 |
| 1 | S.Korea | Seoul | 1300 |
| 2 | China | Beijing | 9100 |
map: 以相同规则将一列数据作一个映射，也就是进行相同函数的处理
In [64]:
def GDP_Factorize(v):
fv = np.float64(v)
if fv > 6000.0:
return 'High'
elif fv < 2000.0:
return 'Low'
else:
return 'Medium'
DF32['GDP_Level'] = DF32['GDP'].map(GDP_Factorize)
DF32['NATION'] = DF32.nation.map(str.upper)
DF32
Out[64]:
| nation | capital | GDP | GDP_Level | NATION | |
|---|---|---|---|---|---|
| 0 | Japan | Tokyo | 4000 | Medium | JAPAN |
| 1 | S.Korea | Seoul | 1300 | Low | S.KOREA |
| 2 | China | Beijing | 9100 | High | CHINA |
类似的功能还有applymap，可以对一个dataframe里面每一个元素像map那样全局操作
In [65]:
DF32.applymap(lambda x: float(x)*2 if x.isdigit() else x.upper())
Out[65]:
| nation | capital | GDP | GDP_Level | NATION | |
|---|---|---|---|---|---|
| 0 | JAPAN | TOKYO | 8000 | MEDIUM | JAPAN |
| 1 | S.KOREA | SEOUL | 2600 | LOW | S.KOREA |
| 2 | CHINA | BEIJING | 18200 | HIGH | CHINA |
apply则可以对一个DataFrame操作得到一个Series
他会有点像我们后面介绍的agg,但是apply可以按行操作和按列操作，用axis控制即可。
In [66]:
DF32.apply(lambda x:x['nation']+x['capital']+'_'+x['GDP'],axis=1)
Out[66]:
0 JapanTokyo_4000
1 S.KoreaSeoul_1300
2 ChinaBeijing_9100
dtype: object
3.3 数据排序
- sort: 按一列或者多列的值进行行级排序
- sort_index: 根据index里的取值进行排序，而且可以根据axis决定是重排行还是列
In [67]:
dataNumPy33 = np.asarray([('Japan','Tokyo',4000),('S.Korea','Seoul',1300),('China','Beijing',9100)])
DF33 = pd.DataFrame(dataNumPy33,columns=['nation','capital','GDP'])
DF33
Out[67]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | Japan | Tokyo | 4000 |
| 1 | S.Korea | Seoul | 1300 |
| 2 | China | Beijing | 9100 |
In [68]:
DF33.sort(['capital','nation'])
Out[68]:
| nation | capital | GDP | |
|---|---|---|---|
| 2 | China | Beijing | 9100 |
| 1 | S.Korea | Seoul | 1300 |
| 0 | Japan | Tokyo | 4000 |
In [69]:
DF33.sort('GDP',ascending=False)
Out[69]:
| nation | capital | GDP | |
|---|---|---|---|
| 2 | China | Beijing | 9100 |
| 0 | Japan | Tokyo | 4000 |
| 1 | S.Korea | Seoul | 1300 |
In [70]:
DF33.sort('GDP').sort(ascending=False)
Out[70]:
| nation | capital | GDP | |
|---|---|---|---|
| 2 | China | Beijing | 9100 |
| 1 | S.Korea | Seoul | 1300 |
| 0 | Japan | Tokyo | 4000 |
In [71]:
DF33.sort_index(axis=1,ascending=True)
Out[71]:
| GDP | capital | nation | |
|---|---|---|---|
| 0 | 4000 | Tokyo | Japan |
| 1 | 1300 | Seoul | S.Korea |
| 2 | 9100 | Beijing | China |
一个好用的功能：Rank
In [72]:
DF33
Out[72]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | Japan | Tokyo | 4000 |
| 1 | S.Korea | Seoul | 1300 |
| 2 | China | Beijing | 9100 |
In [73]:
DF33.rank()
Out[73]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | 2 | 3 | 2 |
| 1 | 3 | 2 | 1 |
| 2 | 1 | 1 | 3 |
In [74]:
DF33.rank(ascending=False)
Out[74]:
| nation | capital | GDP | |
|---|---|---|---|
| 0 | 2 | 1 | 2 |
| 1 | 1 | 2 | 3 |
| 2 | 3 | 3 | 1 |
注意tied data（相同值）的处理：
- method = 'average'
- method = 'min'
- method = 'max'
- method = 'first'
In [75]:
DF33x = pd.DataFrame({'name':[u'老王',u'老张',u'老李',u'老刘'],'sal':np.array([5000,3000,5000,9000])})
DF33x
Out[75]:
| name | sal | |
|---|---|---|
| 0 | 老王 | 5000 |
| 1 | 老张 | 3000 |
| 2 | 老李 | 5000 |
| 3 | 老刘 | 9000 |
DF33x.rank()默认使用method='average'，两条数据相等时，处理排名时大家都用平均值
In [76]:
DF33x.sal.rank()
Out[76]:
0 2.5
1 1.0
2 2.5
3 4.0
Name: sal, dtype: float64
method='min'，处理排名时大家都用最小值
In [77]:
DF33x.sal.rank(method='min')
Out[77]:
0 2
1 1
2 2
3 4
Name: sal, dtype: float64
method='max'，处理排名时大家都用最大值
In [78]:
DF33x.sal.rank(method='max')
Out[78]:
0 3
1 1
2 3
3 4
Name: sal, dtype: float64
method='first'，处理排名时谁先出现就先给谁较小的数值。
In [79]:
DF33x.sal.rank(method='first')
Out[79]:
0 2
1 1
2 3
3 4
Name: sal, dtype: float64
3.4 缺失数据处理
In [80]:
DF34 = data_for_multi2.unstack()
DF34
Out[80]:
| Col_1 | Col_2 | Col_3 | Col_4 | |
|---|---|---|---|---|
| Row_1 | 0 | NaN | NaN | NaN |
| Row_2 | 1 | 2 | NaN | NaN |
| Row_3 | 3 | 4 | 5 | NaN |
| Row_4 | 6 | 7 | 8 | 9 |
忽略缺失值：
In [81]:
DF34.mean(skipna=True)
Out[81]:
Col_1 2.500000
Col_2 4.333333
Col_3 6.500000
Col_4 9.000000
dtype: float64
In [82]:
DF34.mean(skipna=False)
Out[82]:
Col_1 2.5
Col_2 NaN
Col_3 NaN
Col_4 NaN
dtype: float64
如果不想忽略缺失值的话，就需要祭出fillna了：
In [83]:
DF34
Out[83]:
| Col_1 | Col_2 | Col_3 | Col_4 | |
|---|---|---|---|---|
| Row_1 | 0 | NaN | NaN | NaN |
| Row_2 | 1 | 2 | NaN | NaN |
| Row_3 | 3 | 4 | 5 | NaN |
| Row_4 | 6 | 7 | 8 | 9 |
In [84]:
DF34.fillna(0).mean(axis=1,skipna=False)
Out[84]:
Row_1 0.00
Row_2 0.75
Row_3 3.00
Row_4 7.50
dtype: float64
4. “一组”大熊猫：Pandas的groupby
groupby的功能类似SQL的group by关键字：
Split-Apply-Combine
- Split，就是按照规则分组
- Apply，通过一定的agg函数来获得输入pd.Series返回一个值的效果
- Combine，把结果收集起来
Pandas的groupby的灵活性：
- 分组的关键字可以来自于index，也可以来自于真实的列数据
- 分组规则可以通过一列或者多列
In [85]:
from IPython.display import Image
Image(filename="S1EP3_group.png")
Out[85]:
aaarticlea/png;base64,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" alt="" />
分组的具体逻辑
In [86]:
irisdata_group = irisdata.groupby('class')
irisdata_group
Out[86]:
<pandas.core.groupby.DataFrameGroupBy object at 0x10a543b10>
In [87]:
for level,subsetDF in irisdata_group:
print level
print subsetDF[::20]
Iris-setosa
sepal_length sepal_width petal_length petal_width class
0 5.1 3.5 1.4 0.2 Iris-setosa
20 5.4 3.4 1.7 0.2 Iris-setosa
40 5.0 3.5 1.3 0.3 Iris-setosa
Iris-versicolor
sepal_length sepal_width petal_length petal_width class
50 7.0 3.2 4.7 1.4 Iris-versicolor
70 5.9 3.2 4.8 1.8 Iris-versicolor
90 5.5 2.6 4.4 1.2 Iris-versicolor
Iris-virginica
sepal_length sepal_width petal_length petal_width class
100 6.3 3.3 6.0 2.5 Iris-virginica
120 6.9 3.2 5.7 2.3 Iris-virginica
140 6.7 3.1 5.6 2.4 Iris-virginica
分组可以快速实现MapReduce的逻辑
- Map: 指定分组的列标签，不同的值就会被扔到不同的分组处理
- Reduce: 输入多个值，返回一个值，一般可以通过agg实现，agg能接受一个函数
In [88]:
irisdata.groupby('class').agg(\
lambda x:((x-x.mean())**3).sum()*(len(x)-0.0)/\
(len(x)-1.0)/(len(x)-2.0)/(x.std()*np.sqrt((len(x)-0.0)/(len(x)-1.0)))**3 if len(x)>2 else None)
Out[88]:
| sepal_length | sepal_width | petal_length | petal_width | |
|---|---|---|---|---|
| class | ||||
| Iris-setosa | 0.116502 | 0.103857 | 0.069702 | 1.161506 |
| Iris-versicolor | 0.102232 | -0.352014 | -0.588404 | -0.030249 |
| Iris-virginica | 0.114492 | 0.355026 | 0.533044 | -0.125612 |
In [89]:
irisdata.groupby('class').agg(spstat.skew)
Out[89]:
| sepal_length | sepal_width | petal_length | petal_width | |
|---|---|---|---|---|
| class | ||||
| Iris-setosa | 0.116454 | 0.103814 | 0.069673 | 1.161022 |
| Iris-versicolor | 0.102190 | -0.351867 | -0.588159 | -0.030236 |
| Iris-virginica | 0.114445 | 0.354878 | 0.532822 | -0.125560 |
汇总之后的广播操作
在OLAP数据库上，为了避免groupby+join的二次操作，提出了sum()over(partition by)的开窗操作。
在Pandas中，这种操作能够进一步被transform所取代。
In [90]:
pd.concat([irisdata,irisdata.groupby('class').transform('mean')],axis=1)[::20]
Out[90]:
| sepal_length | sepal_width | petal_length | petal_width | class | sepal_length | sepal_width | petal_length | petal_width | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 5.1 | 3.5 | 1.4 | 0.2 | Iris-setosa | 5.006 | 3.418 | 1.464 | 0.244 |
| 20 | 5.4 | 3.4 | 1.7 | 0.2 | Iris-setosa | 5.006 | 3.418 | 1.464 | 0.244 |
| 40 | 5.0 | 3.5 | 1.3 | 0.3 | Iris-setosa | 5.006 | 3.418 | 1.464 | 0.244 |
| 60 | 5.0 | 2.0 | 3.5 | 1.0 | Iris-versicolor | 5.936 | 2.770 | 4.260 | 1.326 |
| 80 | 5.5 | 2.4 | 3.8 | 1.1 | Iris-versicolor | 5.936 | 2.770 | 4.260 | 1.326 |
| 100 | 6.3 | 3.3 | 6.0 | 2.5 | Iris-virginica | 6.588 | 2.974 | 5.552 | 2.026 |
| 120 | 6.9 | 3.2 | 5.7 | 2.3 | Iris-virginica | 6.588 | 2.974 | 5.552 | 2.026 |
| 140 | 6.7 | 3.1 | 5.6 | 2.4 | Iris-virginica | 6.588 | 2.974 | 5.552 | 2.026 |
产生 MultiIndex（多列分组）后的数据透视表操作
一般来说，多列groupby的一个副作用就是.groupby().agg()之后你的行index已经变成了一个多列分组的分级索引。
如果我们希望达到Excel的数据透视表的效果，行和列的索引自由交换，达到统计目的，究竟应该怎么办呢？
In [91]:
factor1 = np.random.randint(0,3,50)
factor2 = np.random.randint(0,2,50)
factor3 = np.random.randint(0,3,50)
values = np.random.randn(50)
In [92]:
hierindexDF = pd.DataFrame({'F1':factor1,'F2':factor2,'F3':factor3,'F4':values})
hierindexDF
Out[92]:
| F1 | F2 | F3 | F4 | |
|---|---|---|---|---|
| 0 | 1 | 0 | 1 | -0.083928 |
| 1 | 0 | 0 | 0 | 0.949984 |
| 2 | 2 | 1 | 0 | -0.037692 |
| 3 | 0 | 1 | 1 | -0.518305 |
| 4 | 1 | 0 | 0 | 0.963678 |
| 5 | 1 | 1 | 1 | -0.284463 |
| 6 | 0 | 0 | 1 | 0.412449 |
| 7 | 2 | 0 | 0 | -0.277126 |
| 8 | 0 | 0 | 2 | -2.488946 |
| 9 | 0 | 1 | 0 | 0.167413 |
| 10 | 0 | 1 | 1 | 1.520003 |
| 11 | 0 | 1 | 2 | -0.665450 |
| 12 | 1 | 1 | 2 | 0.783906 |
| 13 | 1 | 1 | 1 | -0.077717 |
| 14 | 2 | 0 | 2 | -2.018863 |
| 15 | 0 | 1 | 1 | -0.993884 |
| 16 | 2 | 0 | 2 | -1.051174 |
| 17 | 0 | 0 | 2 | -0.723457 |
| 18 | 1 | 1 | 0 | -0.783521 |
| 19 | 1 | 0 | 2 | 0.355093 |
| 20 | 1 | 0 | 0 | -0.252415 |
| 21 | 0 | 0 | 2 | 0.600679 |
| 22 | 2 | 1 | 2 | -0.660498 |
| 23 | 0 | 0 | 2 | -0.301613 |
| 24 | 0 | 1 | 2 | -1.270339 |
| 25 | 0 | 0 | 0 | 0.074086 |
| 26 | 1 | 0 | 0 | -0.043586 |
| 27 | 0 | 1 | 2 | -2.000161 |
| 28 | 2 | 1 | 1 | -1.041330 |
| 29 | 2 | 1 | 1 | 0.984101 |
| 30 | 2 | 0 | 0 | 0.160715 |
| 31 | 1 | 1 | 2 | 0.903035 |
| 32 | 1 | 1 | 1 | -1.105763 |
| 33 | 1 | 0 | 0 | 0.850310 |
| 34 | 1 | 1 | 0 | -0.062946 |
| 35 | 1 | 1 | 0 | -0.507763 |
| 36 | 1 | 0 | 1 | 0.112303 |
| 37 | 2 | 1 | 2 | -0.663782 |
| 38 | 2 | 1 | 1 | 1.147671 |
| 39 | 0 | 0 | 2 | -1.552327 |
| 40 | 1 | 1 | 1 | -1.166517 |
| 41 | 0 | 1 | 0 | -0.622502 |
| 42 | 0 | 1 | 2 | 1.620961 |
| 43 | 1 | 1 | 0 | -0.354238 |
| 44 | 1 | 0 | 2 | -0.233783 |
| 45 | 0 | 0 | 0 | 0.131051 |
| 46 | 2 | 1 | 1 | -1.301164 |
| 47 | 1 | 0 | 2 | -1.013341 |
| 48 | 2 | 0 | 1 | -0.508761 |
| 49 | 0 | 0 | 1 | -1.104457 |
In [93]:
hierindexDF_gbsum = hierindexDF.groupby(['F1','F2','F3']).sum()
hierindexDF_gbsum
Out[93]:
| F4 | |||
|---|---|---|---|
| F1 | F2 | F3 | |
| 0 | 0 | 0 | 1.155121 |
| 1 | -0.692009 | ||
| 2 | -4.465664 | ||
| 1 | 0 | -0.455089 | |
| 1 | 0.007813 | ||
| 2 | -2.314989 | ||
| 1 | 0 | 0 | 1.517987 |
| 1 | 0.028374 | ||
| 2 | -0.892030 | ||
| 1 | 0 | -1.708468 | |
| 1 | -2.634460 | ||
| 2 | 1.686941 | ||
| 2 | 0 | 0 | -0.116412 |
| 1 | -0.508761 | ||
| 2 | -3.070037 | ||
| 1 | 0 | -0.037692 | |
| 1 | -0.210722 | ||
| 2 | -1.324281 |
观察Index：
In [94]:
hierindexDF_gbsum.index
Out[94]:
MultiIndex(levels=[[0, 1, 2], [0, 1], [0, 1, 2]],
labels=[[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2], [0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1], [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]],
names=[u'F1', u'F2', u'F3'])
unstack：
- 无参数时，把最末index置换到column上
- 有数字参数时，把指定位置的index置换到column上
- 有列表参数时，依次把特定位置的index置换到column上
In [95]:
hierindexDF_gbsum.unstack()
Out[95]:
| F4 | ||||
|---|---|---|---|---|
| F3 | 0 | 1 | 2 | |
| F1 | F2 | |||
| 0 | 0 | 1.155121 | -0.692009 | -4.465664 |
| 1 | -0.455089 | 0.007813 | -2.314989 | |
| 1 | 0 | 1.517987 | 0.028374 | -0.892030 |
| 1 | -1.708468 | -2.634460 | 1.686941 | |
| 2 | 0 | -0.116412 | -0.508761 | -3.070037 |
| 1 | -0.037692 | -0.210722 | -1.324281 | |
In [96]:
hierindexDF_gbsum.unstack(0)
Out[96]:
| F4 | ||||
|---|---|---|---|---|
| F1 | 0 | 1 | 2 | |
| F2 | F3 | |||
| 0 | 0 | 1.155121 | 1.517987 | -0.116412 |
| 1 | -0.692009 | 0.028374 | -0.508761 | |
| 2 | -4.465664 | -0.892030 | -3.070037 | |
| 1 | 0 | -0.455089 | -1.708468 | -0.037692 |
| 1 | 0.007813 | -2.634460 | -0.210722 | |
| 2 | -2.314989 | 1.686941 | -1.324281 | |
In [97]:
hierindexDF_gbsum.unstack(1)
Out[97]:
| F4 | |||
|---|---|---|---|
| F2 | 0 | 1 | |
| F1 | F3 | ||
| 0 | 0 | 1.155121 | -0.455089 |
| 1 | -0.692009 | 0.007813 | |
| 2 | -4.465664 | -2.314989 | |
| 1 | 0 | 1.517987 | -1.708468 |
| 1 | 0.028374 | -2.634460 | |
| 2 | -0.892030 | 1.686941 | |
| 2 | 0 | -0.116412 | -0.037692 |
| 1 | -0.508761 | -0.210722 | |
| 2 | -3.070037 | -1.324281 | |
In [98]:
hierindexDF_gbsum.unstack([2,0])
Out[98]:
| F4 | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| F3 | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 1 | 2 |
| F1 | 0 | 0 | 0 | 1 | 1 | 1 | 2 | 2 | 2 |
| F2 | |||||||||
| 0 | 1.155121 | -0.692009 | -4.465664 | 1.517987 | 0.028374 | -0.892030 | -0.116412 | -0.508761 | -3.070037 |
| 1 | -0.455089 | 0.007813 | -2.314989 | -1.708468 | -2.634460 | 1.686941 | -0.037692 | -0.210722 | -1.324281 |
更进一步的，stack的功能是和unstack对应，把column上的多级索引换到index上去
In [99]:
hierindexDF_gbsum.unstack([2,0]).stack([1,2])
Out[99]:
| F4 | |||
|---|---|---|---|
| F2 | F3 | F1 | |
| 0 | 0 | 0 | 1.155121 |
| 1 | 1.517987 | ||
| 2 | -0.116412 | ||
| 1 | 0 | -0.692009 | |
| 1 | 0.028374 | ||
| 2 | -0.508761 | ||
| 2 | 0 | -4.465664 | |
| 1 | -0.892030 | ||
| 2 | -3.070037 | ||
| 1 | 0 | 0 | -0.455089 |
| 1 | -1.708468 | ||
| 2 | -0.037692 | ||
| 1 | 0 | 0.007813 | |
| 1 | -2.634460 | ||
| 2 | -0.210722 | ||
| 2 | 0 | -2.314989 | |
| 1 | 1.686941 | ||
| 2 | -1.324281 |
Pandas python的更多相关文章
- 基于pandas python的美团某商家的评论销售数据分析(可视化）
基于pandas python的美团某商家的评论销售数据分析 第一篇 数据初步的统计 本文是该可视化系列的第二篇 第三篇 数据中的评论数据用于自然语言处理 导入相关库 from pyecharts i ...
- 基于pandas python sklearn 的美团某商家的评论分类(文本分类）
美团店铺评价语言处理以及分类(NLP) 第一篇 数据分析部分 第二篇 可视化部分, 本文是该系列第三篇,文本分类 主要用到的包有jieba,sklearn,pandas,本篇博文主要先用的是词袋模型( ...
- 基于pandas python的美团某商家的评论销售(数据分析)
数据初步的分析 本文是该系列的第一篇 数据清洗 数据初步的统计 第二篇 数据可视化 第三篇 数据中的评论数据用于自然语言处理 from pyecharts import Bar,Pie import ...
- 推荐：python科学计算pandas/python画图库matplotlib【转】
机器学习基础3--python科学计算pandas(上) 地址:https://wangyeming.github.io/2018/09/04/marchine-learning-base-panda ...
- Pandas Python For Data Science
- Python 数据处理库 pandas 入门教程
Python 数据处理库 pandas 入门教程2018/04/17 · 工具与框架 · Pandas, Python 原文出处: 强波的技术博客 pandas是一个Python语言的软件包,在我们使 ...
- Python自动化测试-使用Pandas来高效处理测试数据
一.思考 1.Pandas是什么? 功能极其强大的数据分析库 可以高效地操作各种数据集 csv格式的文件 Excel文件 HTML文件 XML格式的文件 JSON格式的文件 数据库操作 2.经典面试题 ...
- python之pandas学习笔记-初识pandas
初识pandas python最擅长的就是数据处理,而pandas则是python用于数据分析的最常用工具之一,所以学python一定要学pandas库的使用. pandas为python提供了高性能 ...
- Python使用Pandas高效处理测试数据
转自:https://www.cnblogs.com/keyou1/p/10948796.html 一.思考 1.Pandas是什么? 功能极其强大的数据分析库 可以高效地操作各种数据集 csv格式的 ...
随机推荐
- IntraWeb XIV 类型速查表
tkClass ================== IWUserSessionBase.TIWUserSessionBase < TDataModule < TComponent < ...
- FireDAC 下的 Sqlite [4] - 创建数据库
建立数据库的代码: {建立内存数据库的一般代码:} begin FDConnection1.DriverName := 'SQLite'; //同 FDConnection1.Params.Add(' ...
- 前端构建和模块化工具-coolie
[前言] 假设你之前用过前端模块化工具:seajs.requirejs. 用过前端构建工具grunt.gulp, 而且感到了一些不方便和痛苦,那么你能够试试coolie [coolie] 本文不是一篇 ...
- SWD and JTAG selection mechanism
SWD and JTAG selection mechanism SWJ-DP enables either an SWD or JTAG protocol to be used on the deb ...
- gitblit.cmd运行自动关闭
前几天运行gitblit.cmd一直正常,今天运行gitblit.cmd,几秒钟后命令行窗口就自动关闭了,导致无法启动gitblit服务器,查看日志如下: 刚开始以为是防火墙问题,在防火墙中添加了程序 ...
- PHP 如何创建守护(daemon)进程
先讲几个概念 守护进程: Linux中的后台服务进程.它是一个生存期较长的进程,通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件.守护进程常常在系统引导装入时启动,在系统关闭时终止. ...
- 使用Edge模式通知Internet Explorer以最高级别的可用模式显示内容
一.EasyUI$的window('open')在IE8下兼容性问题 今天在公司使用EasyUI的$('#win').window('open');方法打开一个window窗体时发现EaysUI的脚本 ...
- javascript:常用数组操作
concat()方法 数组和数组的 粘结: var a=[1,2,3,4]; var b=[5,6,7,8]; var c=a.concat(b); console.log(c); // [1,2,3 ...
- mormot支持https
mormot支持https 将ssl证书导入电脑系统,以Windows 10为例: 运行 mmc 证书导入成功后,双击证书,查看证书指纹: 第二项工作:将证书与https绑定:以管理员身份启动cmd, ...
- iOS 内存斗争小史之 NavigationController
1.怎样写一个不泄漏的NavigationController页面跳转程序? 非arc模式下,假设有A.B两个viewController,从A推到B,怎样写内存才能不泄漏? A.m -(IBActi ...