利用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)