利用python进行数据分析-pandas入门3

1.函数应用和映射

NumPy的ufuncs（元素级数组方法）也可用于操作pandas对象

frame=DataFrame(np.random.randn(4,3),columns=list('bde'),index=['Uath','Ohio','Texas','Oregon'])

print frame

print np.abs(frame)

结果为：

b d e

Uath 1.187068 1.589404 0.328555

Ohio -0.040634 1.489594 -0.453027

Texas 0.362667 0.601500 2.177313

Oregon 0.019020 -0.315751 -0.480646

b d e

Uath 1.187068 1.589404 0.328555

Ohio 0.040634 1.489594 0.453027

Texas 0.362667 0.601500 2.177313

Oregon 0.019020 0.315751 0.480646

另一个常见的操作是，将函数应用到由各列或行所形成的一维数组上。DataFrame的apply方法即可实现此功能

f=lambda x:x.max()-x.min()

print frame.apply(f)

print frame.apply(f,axis=1)

结果为：

b 0.605155

d 2.173279

e 2.737098

dtype: float64

Uath 1.913344

Ohio 0.302252

Texas 1.663901

Oregon 1.654397

dtype: float64

许多最为常见的数组统计功能都能被实现成DataFrame的方法（比如sum和mean），因此无需使用apply方法

除标量值外，传递给apply的函数还可以返回由多个值组成的Series

def f(x):

return Series([x.min(),x.max()],index=['min','max'])

print frame.apply(f)

结果为：

b d e

min -1.878553 -1.339043 -2.638153

max 1.051156 1.322494 0.242260

此外，元素级的Python函数也是可以用的。如你想得到frame中各个浮点值的格式化字符串，可以使用applymap

format=lambda x:'%.2f' % x

print frame.applymap(format)

结果为：

b d e

Uath 0.27 0.94 0.73

Ohio -0.81 0.78 -1.04

Texas 1.00 0.64 0.61

Oregon 0.55 -0.17 -0.40

之所以叫做applymap，是因为Series有一个用于应用元素级函数的map方法

print frame['e'].map(format)

结果为：

Uath 0.17

Ohio 2.22

Texas 0.58

Oregon 0.18

Name: e, dtype: object

2.排序和排名

要对行或列索引进行排序（按字典排序），可使用sort_index方法，它将返回一个已排序的新对象

obj=Series(range(4),index=['d','a','b','c'])

print obj.sort_index()

结果为：

a 1

b 2

c 3

d 0

dtype: int64

而对于DataFrame，可以根据任意一个轴上的索引进行排序

frame2=DataFrame(np.arange(8).reshape(2,4),index=['three','one'],columns=['d','a','b','c'])

print frame2.sort_index()

print frame2.sort_index(axis=1)

结果为：

d a b c

one 4 5 6 7

three 0 1 2 3

a b c d

three 1 2 3 0

one 5 6 7 4

数据默认是按照升序排序的，也可以降序排序

print frame2.sort_index(axis=1,ascending=False)

结果为：

d c b a

three 0 3 2 1

one 4 7 6 5

若要按值对Series进行排序，可使用其order方法

obj2=Series([4,7,-3,2])

print obj2.order()

结果为：

2 -3

3 2

0 4

1 7

在排序时，任何缺失值默认都会被放到Series末尾

obj3=Series([4,np.nan,7,np.nan,-3,2])

print obj3.order()

结果为：

4 -3

5 2

0 4

2 7

1 NaN

3 NaN

dtype: float64

在DataFrame上，你可能希望根据一个或多个列中的值进行排序。将一个或多个列的名字传递给by选项即可达到该目的

frame3=DataFrame({'b':[4,7,-3,2],'a':[0,1,0,1]})

print frame3

print frame3.sort_index(by='b')

结果为：

a b

0 0 4

1 1 7

2 0 -3

3 1 2

a b

2 0 -3

3 1 2

0 0 4

1 1 7

要根据多个列进行排序，传入名称的列表即可

print frame3.sort_index(by=['a','b'])

结果为：

a b

2 0 -3

0 0 4

3 1 2

1 1 7

排名（ranking）跟排序关系密切，且它会增设一个排名值（从1开始，一直到数组中有效数据的数量）。默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系的

obj4=Series([7,-5,7,4,2,0,4])

print obj4.rank()

结果为：

0 6.5

1 1.0

2 6.5

3 4.5

4 3.0

5 2.0

6 4.5

也可以根据值在原数据中出现的顺序给出排名

print obj4.rank(method='first')

结果为：

0 6

1 1

2 7

3 4

4 3

5 2

6 5

dtype: float64

也可以按降序进行排名

print obj4.rank(method='max',ascending=False)

结果为：

0 2

1 7

2 2

3 4

4 5

5 6

6 4

dtype: float64



3.带有重复值的轴索引

索引的is_unique属性可以告诉你它的值是否是唯一的

obj5=Series(range(5),index=['a','a','b','b','c'])

print obj5

print obj5.index.is_unique

结果为：

a 0

a 1

b 2

b 3

c 4

dtype: int64

False

如果某个索引对应多个值，则返回一个Series

print obj5['a']

结果为：

a 0

a 1

dtype: int64

对DataFrame进行索引时也是如此

df=DataFrame(np.arange(12).reshape(4,3),index=['a','a','b','b'])

print df.ix['b']

结果为：

0 1 2

b 6 7 8

b 9 10 11

4.汇总和计算描述统计

df2=DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index=['a','b','c','d'],columns=['one','two'])

print df2

print df2.sum()

print df2.sum(axis=1)

结果为：

one two

a 1.40 NaN

b 7.10 -4.5

c NaN NaN

d 0.75 -1.3

one 9.25

two -5.80

dtype: float64

a 1.40

b 2.60

c 0.00

d -0.55

dtype: float64

NA值会自动被排除，除非整个切片（这里指的是行或列）都是NA。通过skipna选项可以禁用该功能

print df2.sum(axis=1,skipna=False)

结果为：

a NaN

b 2.60

c NaN

d -0.55

dtype: float64



有些方法（如idxmin和idxmax）返回的是间接统计（比如达到最小值或最大值的索引）

print df2.idxmax()

结果为：

one b

two d

dtype: object

另一些方法则是累计型的

print df2.cumsum()

结果为：

one two

a 1.40 NaN

b 8.50 -4.5

c NaN NaN

d 9.25 -5.8

还有一种方法，它既不是约简型也不是累计型。describe就是一个例子，它用于一次性产生多个汇总统计

print df2.describe()

结果为：

one two

count 3.000000 2.000000

mean 3.083333 -2.900000

std 3.493685 2.262742

min 0.750000 -4.500000

25% 1.075000 -3.700000

50% 1.400000 -2.900000

75% 4.250000 -2.100000

max 7.100000 -1.300000





5.相关系数与协方差

import pandas.io.data as web

all_data={}

for ticker in ['AAPL','IBM','MSFT','GOOG']:

all_data[ticker]=web.get_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()})

returns=price.pct_change()

print returns.tail()

结果为：

AAPL GOOG IBM MSFT

Date

2009-12-24 0.034339 0.011117 0.004385 0.002587

2009-12-28 0.012294 0.007098 0.013326 0.005484

2009-12-29 -0.011861 -0.005571 -0.003477 0.007058

2009-12-30 0.012147 0.005376 0.005461 -0.013699

2009-12-31 -0.004300 -0.004416 -0.012597 -0.015504

Series的corr方法用于计算两个Series中重叠、非NA的、按索引对齐的值的相关系数。与此类似，cov用于计算协方差

print returns.MSFT.corr(returns.IBM)

print returns.MSFT.cov(returns.IBM)

结果为：

0.495979684549

0.000215957648434

DataFrame的corr和cov方法将以DataFrame的形式返回完整的相关系数与协方差矩阵

print returns.corr()

print returns.cov()

结果为：

AAPL GOOG IBM MSFT

AAPL 1.000000 0.470676 0.410011 0.424305

GOOG 0.470676 1.000000 0.390689 0.443587

IBM 0.410011 0.390689 1.000000 0.495980

MSFT 0.424305 0.443587 0.495980 1.000000

AAPL GOOG IBM MSFT

AAPL 0.001027 0.000303 0.000252 0.000309

GOOG 0.000303 0.000580 0.000142 0.000205

IBM 0.000252 0.000142 0.000367 0.000216

MSFT 0.000309 0.000205 0.000216 0.000516

利用DataFrame的corrwith方法，你可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series（针对各列进行计算）

print returns.corrwith(returns.IBM)

结果为：

AAPL 0.410011

GOOG 0.390689

IBM 1.000000

MSFT 0.495980

dtype: float64

传入一个DataFrame则会计算按列名配对的相关系数。这里，计算百分比变化与成交量的相关系数

print returns.corrwith(volume)

结果为：

AAPL -0.057549

GOOG 0.062647

IBM -0.007892

MSFT -0.014245

dtype: float64

传入axis=1即可按行进行计算。无论如何，在计算相关系数之前，所有的数据项都会按标签对齐

6.唯一值、值计数以及成员资格

obj6=Series(['c','a','d','a','a','b','b','c','c'])

uniques=obj6.unique()

print uniques

结果为：

['c' 'a' 'd' 'b']

返回的唯一值是未排序的，可以对结果再次进行排序（uniques.sort()）。value_counts计算一个Series中各值出现的频率

print obj6.value_counts()

结果为：

c 3

a 3

b 2

d 1

dtype: int64

value_counts还有一个顶级pandas方法，可用于任何数组或序列

print pd.value_counts(obj6.values,sort=False)

结果为：

a 3

c 3

b 2

d 1

dtype: int64

isin，它用于判断矢量化集合的成员资格，可用于选取Series中或DataFrame列中数据的子集

mask=obj6.isin(['b','c'])

print mask

print obj6[mask]

结果为：

0 True

1 False

2 False

3 False

4 False

5 True

6 True

7 True

8 True

dtype: bool

0 c

5 b

6 b

7 c

8 c

dtype: object



有时，你希望得到DataFrame中多个相关列的一张柱状图

data2=DataFrame({'Qu1':[1,3,4,3,4],

'Qu2':[2,3,1,2,3],

'Qu3':[1,5,2,4,4]})

print data2

result=data2.apply(pd.value_counts).fillna(0)

print result

结果为：

Qu1 Qu2 Qu3

0 1 2 1

1 3 3 5

2 4 1 2

3 3 2 4

4 4 3 4

Qu1 Qu2 Qu3

1 1 1 1

2 0 2 1

3 2 2 0

4 2 0 2

5 0 0 1

7.处理丢失数据

pandas使用浮点值NAN表示浮点和非浮点数组中的缺失数据，它只是一个便于被检测出来的标记而已

string_data=Series(['aardvark','artichoke',np.nan,'avocado'])

print string_data

print string_data.isnull()

结果为：

0 aardvark

1 artichoke

2 NaN

3 avocado

dtype: object

0 False

1 False

2 True

3 False

dtype: bool

python内置的None值也会被当做NA处理

string_data[0]=None

print string_data.isnull()

结果为：

0 True

1 False

2 True

3 False

dtype: bool



8.滤除缺失数据

对于一个Series，dropna返回一个仅含非空数据和索引值的Series

from numpy import nan as NA

data=Series([1,NA,3.5,NA,7])

print data.dropna()

print data[data.notnull()]

结果为：

0 1.0

2 3.5

4 7.0

dtype: float64

0 1.0

2 3.5

4 7.0

dtype: float64

对于DataFrame对象，事情就有点复杂了。你可能希望丢弃全NA或含有NA的行或列。dropna默认丢弃任何含有缺失值的行

data3=DataFrame([[1,6.5,3],[1,NA,NA],[NA,NA,NA],[NA,6.5,3]])

print data3

cleaned=data3.dropna()

print cleaned

结果为：

0 1 2

0 1 6.5 3

1 1 NaN NaN

2 NaN NaN NaN

3 NaN 6.5 3

0 1 2

0 1 6.5 3

传入how='all'将只丢弃全为NA的那些行

print data3.dropna(how='all')

结果为：

0 1 2

0 1 6.5 3

1 1 NaN NaN

3 NaN 6.5 3

要用这种方式丢弃列，只需传入axis=1即可

data3[4]=NA

print data3

print data3.dropna(axis=1,how='all')

结果为：

0 1 2 4

0 1 6.5 3 NaN

1 1 NaN NaN NaN

2 NaN NaN NaN NaN

3 NaN 6.5 3 NaN

0 1 2

0 1 6.5 3

1 1 NaN NaN

2 NaN NaN NaN

3 NaN 6.5 3

另一个滤除DataFrame行的问题涉及到时间序列数据。假设你只想留下一部分观测数据，可以用thresh参数实现此目的

df3=DataFrame(np.random.randn(7,3))

df3.ix[:4,1]=NA

df3.ix[:2,2]=NA

print df3

print df3.dropna(thresh=3)

结果为：

0 1 2

0 2.399544 NaN NaN

1 0.430949 NaN NaN

2 -1.083213 NaN NaN

3 -0.431232 NaN 0.756593

4 0.529114 NaN -0.595716

5 1.444382 -0.195083 -0.930979

6 -1.412920 -0.934195 2.861213

0 1 2

5 1.444382 -0.195083 -0.930979

6 -1.412920 -0.934195 2.861213

9.填充缺失数据

fillna方法是最主要的函数

print df3.fillna(0)

print df3.fillna({1:0.5,3:-1})

结果为：

0 1 2

0 -0.034171 0.000000 0.000000

1 -0.115502 0.000000 0.000000

2 0.308157 0.000000 0.000000

3 1.367718 0.000000 -0.306751

4 -1.360234 0.000000 0.999463

5 -0.148457 0.156416 -2.017497

6 -0.408602 0.403680 -1.352914

0 1 2

0 -0.034171 0.500000 NaN

1 -0.115502 0.500000 NaN

2 0.308157 0.500000 NaN

3 1.367718 0.500000 -0.306751

4 -1.360234 0.500000 0.999463

5 -0.148457 0.156416 -2.017497

6 -0.408602 0.403680 -1.352914

fillna默认会返回新对象，但也可以对现有对象进行就地修改

_=df3.fillna(0,inplace=True)

print df3

结果为：

0 1 2

0 -1.901323 0.000000 0.000000

1 -0.431574 0.000000 0.000000

2 1.452733 0.000000 0.000000

3 0.013765 0.000000 0.572696

4 0.121601 0.000000 -0.972343

5 0.411238 -0.023716 0.827292

6 0.266131 0.706082 0.859971

对reindex有效的那些插值方法也可用于fillna

df4=DataFrame(np.random.randn(6,3))

df4.ix[2:,1]=NA

df4.ix[4:,2]=NA

print df4

print df4.fillna(method='ffill')

print df4.fillna(method='ffill',limit=2)

结果为：

0 1 2

0 0.132548 0.581560 0.539203

1 0.250056 0.676504 -0.645744

2 0.760809 NaN 1.073846

3 -0.480362 NaN 0.221771

4 -0.600295 NaN NaN

5 0.005458 NaN NaN

0 1 2

0 0.132548 0.581560 0.539203

1 0.250056 0.676504 -0.645744

2 0.760809 0.676504 1.073846

3 -0.480362 0.676504 0.221771

4 -0.600295 0.676504 0.221771

5 0.005458 0.676504 0.221771

0 1 2

0 0.132548 0.581560 0.539203

1 0.250056 0.676504 -0.645744

2 0.760809 0.676504 1.073846

3 -0.480362 0.676504 0.221771

4 -0.600295 NaN 0.221771

5 0.005458 NaN 0.221771





10.层次化索引

它使你能以低纬度形式处理高纬度数据

data4=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]])

print data4

结果为：

a 1 -0.219090

2 -1.372102

3 1.108223

b 1 -0.796361

2 1.175877

3 0.520666

c 1 1.058822

2 1.325842

d 2 -0.040458

3 0.205163

dtype: float64

这就是带有MultiIndex索引的Series的格式化输出形式。索引之间的“间隔”表示“直接使用上面的标签”

print data4.index

结果为：

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]])

对于一个层次化索引的对象，选取数据子集的操作很简单

print data4['b']

结果为：

1 -0.094394

2 0.531658

3 -0.159814

dtype: float64

print data4['b':'c']

print data4.ix[['b','d']]

结果为：

b 1 -1.336168

2 0.074839

3 -0.615861

c 1 -0.349232

2 -0.024671

dtype: float64

b 1 -1.336168

2 0.074839

3 -0.615861

d 2 1.444744

3 -0.824043

dtype: float64

可以通过其unstack方法被重新安排到一个DataFrame中

print data4.unstack()

结果为：

1 2 3

a 1.483774 0.221626 0.085326

b 0.354429 -1.018716 0.423129

c -1.038540 2.103571 NaN

d NaN 0.596784 1.500782

unstack的逆运算是stack

print data4.unstack().stack()

结果为：

a 1 -0.718105

2 0.766081

3 -0.221549

b 1 -0.521521

2 -1.252716

3 -0.329751

c 1 1.912822

2 -0.794359

d 2 1.432758

3 1.244745

dtype: float64

对于一个DataFrame，每条轴上都可以有分层索引

frame4=DataFrame(np.arange(12).reshape((4,3)),

index=[['a','a','b','b'],[1,2,1,2]],

columns=[['Ohio','Ohio','Colorado'],

['Green','Red','Green']])

print frame4

frame4.index.names=['key1','key2']

frame4.columns.names=['state','color']

print frame4

结果为：

Ohio Colorado

Green Red Green

a 1 0 1 2

2 3 4 5

b 1 6 7 8

2 9 10 11

state Ohio Colorado

color Green Red Green

key1 key2

a 1 0 1 2

2 3 4 5

b 1 6 7 8

2 9 10 11

11.重排分级排序

swaplevel接受两个级别编号或名称，并返回一个互换了级别的新对象（但数据不会发生变化）

print frame4.swaplevel('key1','key2')

结果为：

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

而sortlevel则根据单个级别中的值对数据进行排序。交换级别时，常常也会用到sortlevel，这样最终结果就是有序的了

print frame4.sortlevel(1)

print frame4.swaplevel(0,1).sortlevel(0)

结果为：

state Ohio Colorado

color Green Red Green

key1 key2

a 1 0 1 2

b 1 6 7 8

a 2 3 4 5

b 2 9 10 11

state Ohio Colorado

color Green Red Green

key2 key1

1 a 0 1 2

b 6 7 8

2 a 3 4 5

b 9 10 11

12.根据级别汇总统计

print frame4.sum(level='key2')

print frame4.sum(level='color',axis=1)

结果为：

state Ohio Colorado

color Green Red Green

key2

1 6 8 10

2 12 14 16

color Green Red

key1 key2

a 1 2 1

2 8 4

b 1 14 7

2 20 10

13.使用DataFrame的列

frame5=DataFrame({'a':range(7),'b':range(7,0,-1),

'c':['one','one','one','two','two','two','two'],

'd':[0,1,2,0,1,2,3]})

print frame5

结果为：

a b c d

0 0 7 one 0

1 1 6 one 1

2 2 5 one 2

3 3 4 two 0

4 4 3 two 1

5 5 2 two 2

6 6 1 two 3

DataFrame的set_index函数会将其一个或多个列转换为行索引，并创建一个新的DataFrame

frame5=DataFrame({'a':range(7),'b':range(7,0,-1),

'c':['one','one','one','two','two','two','two'],

'd':[0,1,2,0,1,2,3]})

print frame5

frame6=frame5.set_index(['c','d'])

print frame6

结果为：

a b c d

0 0 7 one 0

1 1 6 one 1

2 2 5 one 2

3 3 4 two 0

4 4 3 two 1

5 5 2 two 2

6 6 1 two 3

a b

c d

one 0 0 7

1 1 6

2 2 5

two 0 3 4

1 4 3

2 5 2

3 6 1

默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来

print frame5.set_index(['c','d'],drop=False)

结果为：

a b c d

c d

one 0 0 7 one 0

1 1 6 one 1

2 2 5 one 2

two 0 3 4 two 0

1 4 3 two 1

2 5 2 two 2

3 6 1 two 3

reset_index的功能跟set_index刚好相反，层次化索引的级别会被转移到列里面

print frame6.reset_index()

结果为：

c d a b

0 one 0 0 7

1 one 1 1 6

2 one 2 2 5

3 two 0 3 4

4 two 1 4 3

5 two 2 5 2

6 two 3 6 1