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

随书练习，第五章  pandas入门1

# coding: utf-8

# In[1]:

from pandas import Series, DataFrame

# In[2]:

import pandas as pd

# In[3]:

import numpy as np

# In[4]:

obj = Series([4,7,-5,3])

# In[5]:

obj

# In[6]:

obj.values

# In[7]:

obj.index

# In[8]:

obj2 = Series([4,7,-5,3],index=['d','b','a','c'])

# In[9]:

obj2

# In[10]:

obj2.index

# In[11]:

obj2['a']

# In[12]:

obj2['d'] = 6 #给索引'd'位置赋值6

# In[13]:

obj2[['c','a','d']]

# In[14]:

obj2

# In[15]:

obj2[obj2 > 0]

# In[16]:

obj2*2

# In[17]:

np.exp(obj2)

# In[18]:

'b' in obj2 #将Series看做定长有序字典

# In[19]:

'e' in obj2

# In[20]:

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000} #字典是无序的

# In[21]:

obj3 = Series(sdata)

# In[22]:

obj3

# In[23]:

states = ['California','Ohio','Oregon','Texas']

# In[24]:

obj4 = Series(sdata, index=states)

# In[25]:

obj4

# In[26]:

pd.isnull(obj4) #用于检测缺失数据

# In[27]:

pd.notnull(obj4)

# In[28]:

obj4.isnull()

# In[29]:

obj3

# In[30]:

obj4

# In[31]:

obj3+obj4 #自动对齐不同索引的数据

# In[32]:

obj4.name = 'population'

# In[33]:

obj4.index.name = 'state'

# In[34]:

obj4

# In[35]:

obj.index = ['Bob','Steve','Jeff','Ryan'] #Series索引可以通过赋值的方式就地修改

# In[36]:

obj

# In[37]:

data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],'year':[2000,2001,2002,2001,2002],'pop':[1.5,1.7,3.6,2.4,2.9]}
frame = DataFrame(data)

# In[38]:

frame

# In[39]:

DataFrame(data,columns=['year','state','pop']) #指定列顺序

# In[40]:

frame2 = DataFrame(data,columns=['year','state','pop','debt'],index=['one','two','three','four','five'])

# In[41]:

frame2

# In[42]:

frame2.columns

# In[43]:

frame2['state'] #列获取：字典标记方式

# In[44]:

frame2.year #列获取：属性方式

# In[45]:

frame2.loc['three'] #行获取：利用索引

# In[46]:

frame2['debt'] = 16.5 #通过赋值的方式修改列

# In[47]:

frame2

# In[48]:

frame2['debt'] = np.arange(5)

# In[49]:

frame2

# In[50]:

val = Series([-1.2,-1.5,-1.7],index=['two','four','five']) #将Series赋值给DataFrame的列，精确匹配索引

# In[51]:

frame2['debt'] = val

# In[52]:

frame2

# In[53]:

val1 = ([1,2,3,2,1]) 

# In[54]:

frame2['debt'] = val1 #将数组赋值给DataFrame的某一列，长度必须一致

# In[55]:

frame2

# In[56]:

frame2['eastern'] = frame2.state == 'Ohio' #为不存在的列赋值可以创建一个新列

# In[57]:

frame2

# In[58]:

del frame2['eastern'] #关键字del用于删除列

# In[59]:

frame2.columns

# In[60]:

pop = {'Nevada':{2001:2.4,2002:2.9},'Ohio':{2000:1.5,2001:1.7,2002:3.6}} #嵌套字典

# In[61]:

frame3 = DataFrame(pop)

# In[62]:

frame3

# In[63]:

frame3.T

# In[64]:

DataFrame(pop,index=[2001,2001,2003])

# In[65]:

pdata = {'Ohio':frame3['Ohio'][:-1],'Nevada':frame3['Nevada'][:2]}

# In[66]:

DataFrame(pdata)

# In[67]:

frame3.index.name = 'year';frame3.columns.name = 'state'

# In[68]:

frame3

# In[69]:

frame3.values #values属性

# In[70]:

frame2.values #各列数据类型不同，选择能兼容所有的类型

# In[71]:

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

# In[72]:

index = obj.index

# In[73]:

index

# In[74]:

index[1:]

# In[75]:

#index[1] = 'd' #索引不可修改

# In[76]:

index = (['x', 'y', 'z'])

# In[77]:

index

# In[78]:

index[1] = 'd'

# In[79]:

index

# In[80]:

obj.index = (['x', 'y', 'z'])  #通过赋值的方式整个可以全部改

# In[81]:

obj.index

# In[82]:

#obj.index[1] = 'd' #索引不可修改

# In[83]:

index = pd.Index(np.arange(3))

# In[84]:

obj2 = Series([1.5,-2.5,0],index=index)

# In[85]:

obj2.index is index

# In[86]:

frame3

# In[87]:

'Ohio' in frame3.columns

# In[88]:

2003 in frame3.index

# In[89]:

frame3.index.is_unique #index的方法和属性

# In[90]:

frame3.index.is_monotonic # 当各元素均大于等于前一个元素时，返回True

# In[91]:

frame3.index.drop([2002])

# In[92]:

frame3.index.insert(2,2002)

# In[93]:

obj = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])

# In[94]:

obj

# In[95]:

obj2 = obj.reindex(['a','b','c','d','e']) #Series的重新索引

# In[96]:

obj2

# In[97]:

obj.reindex(['a','b','c','d','e'],fill_value=0) #缺失值处理

# In[98]:

obj3 = Series(['blue','purple','yellow'],index=[0,2,4])

# In[99]:

obj3.reindex(range(6),method='ffill') #插值处理(只能按行应用)：method选项：ffill或pad向前填充；bfill或backfill向后填充

# In[100]:

frame = DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],columns=['Ohio','Texas','California'])

# In[101]:

frame

# In[102]:

frame2 = frame.reindex(['a','b','c','d']) #DataFrame的重新索引，只传入一个序列，默认为行

# In[103]:

frame2

# In[104]:

states = ['Texas','Utah','California']

# In[105]:

frame.reindex(columns=states)

# In[106]:

#frame.reindex(index=['a','b','c','d'],method='ffill',columns=states) #行列不能同时重新索引，会报错，或者把method选项去掉也行

# In[107]:

frame.loc[['a','b','c','d'],states]

# In[108]:

obj = Series(np.arange(5),index=['a','b','c','d','e'])

# In[109]:

new_obj = obj.drop('c')

# In[110]:

new_obj

# In[111]:

obj.drop(['d','c'])

# In[112]:

data = DataFrame(np.arange(16).reshape((4,4)),index=['Ohio','Colorado','Utah','New York'],columns=['one','two','three','four'])

# In[113]:

data.drop(['Colorado','Ohio']) #默认为行

# In[114]:

data.drop('two',axis=1)

# In[115]:

data.drop(['two','four'],axis=1)

# In[116]:

#索引、选取、过滤

# In[117]:

obj = Series(np.arange(4),index=['a','b','c','d']) #以下是对Series进行索引

# In[118]:

obj['b'] #按索引标签

# In[119]:

obj[1] #按位置

# In[120]:

obj[2:4] #切片，按位置，末端不包含

# In[121]:

obj[['b','a','d']] #按索引

# In[122]:

obj[[1,3]]

# In[123]:

obj[obj < 2]

# In[124]:

obj['b':'c'] # 按照索引标签的切片，末端包含

# In[125]:

obj['b':'c'] = 5

# In[126]:

obj

# In[127]:

data = DataFrame(np.arange(16).reshape((4,4)),index=['Ohio','Colorado','Utah','New York'],columns=['one','two','three','four'])

# In[128]:

data #以下是对DataFrame的索引

# In[129]:

data['two']

# In[130]:

data[['three','one']] #获取列，因为选取列的操作更常见

# In[131]:

data[:2] #按位置索引：通过切片选取行

# In[132]:

data[data['three']>5] #通过布尔型数组选取行

# In[133]:

data < 5

# In[134]:

data[data<5] = 0

# In[135]:

data

# In[136]:

data.loc['Colorado',['two','three']]

# In[137]:

data.iloc[data.index.get_indexer(['Colorado','Utah']),[3,0,1]] ##天啊，同时选取行列，且一个为标签一个为位置
#For getting multiple indexers, using .get_indexer

# In[138]:

data.ix[['Colorado','Utah'],[3,0,1]] 

# In[139]:

data.iloc[2]

# In[140]:

data.loc[:'Utah','two'] #标签，末端包含

# In[141]:

data.ix[data.three > 5, :3]

# In[142]:

s1 = Series([7.3,-2.5,3.4,1.5],index=['a','c','d','e'])

# In[143]:

s2 = Series([-2.1,3.6,-1.5,4,3.1],index=['a','c','e','f','g'])

# In[144]:

s1

# In[145]:

s2

# In[146]:

s1+s2 #自动对齐，缺失值在算数运算中传播

# In[147]:

df1 = DataFrame(np.arange(9).reshape((3,3)),columns=list('bcd'),index=['Ohio','Texas','Colorado'])

# In[148]:

df2 = DataFrame(np.arange(12).reshape((4,3)),columns=list('bde'),index=['Utah','Ohio','Texas','Oregon'])

# In[149]:

df1

# In[150]:

df2

# In[151]:

df1+df2

# In[160]:

df1 = DataFrame(np.arange(12).reshape((3,4)),columns=list('abcd'))

# In[158]:

df2 = DataFrame(np.arange(20).reshape((4,5)),columns=list('abcde'))

# In[161]:

df1

# In[159]:

df2

# In[163]:

df1 + df2

# In[165]:

df1.add(df2, fill_value=0)

# In[166]:

df1.reindex(columns=df2.columns,fill_value=0) #重新索引

# In[167]:

# add加法,sub减法,div除法,mul乘法

# In[169]:

arr = np.arange(12).reshape((3,4))

# In[170]:

arr

# In[171]:

arr[0]

# In[173]:

arr - arr[0] #广播

# In[174]:

frame = DataFrame(np.arange(12).reshape((4,3)),columns=list('bde'),index=['Utah','Ohio','Texas','Oregon'])

# In[175]:

series = frame.iloc[0]

# In[176]:

frame

# In[177]:

series

# In[178]:

frame - series

# In[179]:

series2 = Series(range(3),index=['b','e','f'])

# In[180]:

frame + series2 #默认匹配列在行上传播

# In[181]:

series3 = frame['d']

# In[182]:

frame

# In[183]:

series3

# In[184]:

frame.sub(series3,axis=0) #匹配行在列上广播，传入的轴号是希望匹配的轴

# In[185]:

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

# In[186]:

frame

# In[187]:

np.abs(frame) #函数应用在元素级

# In[188]:

f = lambda x:x.max() - x.min() #匿名函数

# In[190]:

frame.apply(f) #将函数应用到各行各列所形成的一维数组上

# In[191]:

frame.apply(f,axis=1)

# In[192]:

def f(x):
    return Series([x.min(),x.max()],index=['min','max'])  #自定义函数，传递给apply的函数还可以返回Series

# In[193]:

frame.apply(f)

# In[194]:

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

# In[199]:

frame.applymap(format)

# In[200]:

frame['e'].map(format) 

# In[201]:

#apply()是一种让函数作用于列或者行操作，applymap()是一种让函数作用于DataFrame每一个元素的操作，而map是一种让函数作用于Series每一个元素的操作

# In[202]:

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

# In[203]:

obj.sort_index() #对索引排序

# In[204]:

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

# In[205]:

frame.sort_index()

# In[206]:

frame.sort_index(axis=1) #可以对任意轴上索引进行排序

# In[207]:

frame.sort_index(axis=1,ascending=False) #降序

# In[208]:

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

# In[212]:

obj.sort_values()

# In[213]:

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

# In[214]:

obj.sort_values() #任何缺失值默认放在末尾

# In[215]:

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

# In[216]:

frame

# In[218]:

frame.sort_values(by='b')

# In[221]:

frame.sort_values(by=['a','b'])

# In[222]:

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

# In[223]:

obj.rank() #method='average'

# In[224]:

obj.rank(method='first')

# In[225]:

obj.rank(ascending=False,method='max')

# In[226]:

frame = DataFrame({'b':[4.3,7,-3,2],'a':[0,1,0,1],'c':[-2,5,8,-2.5]})

# In[227]:

frame

# In[228]:

frame.rank(axis=1)