python之pandas用法詳解

Four兄 2019-09-03

展開全文

pandas是基于numpy構(gòu)建的，使得數(shù)據(jù)分析工作變得更快更簡單的高級數(shù)據(jù)結(jié)構(gòu)和操作工具。

一、pandas數(shù)據(jù)結(jié)構(gòu)

兩個主要的數(shù)據(jù)結(jié)構(gòu)：Series和DataFrame。

1.1 Series

Series是一種類似于一維數(shù)組的對象，它由一維數(shù)組（各種numpy數(shù)據(jù)類型）以及一組與之相關的數(shù)據(jù)標簽（即索引）組成，僅由一組數(shù)據(jù)即可產(chǎn)生最簡單的Series.

Series的字符串表現(xiàn)形式為：索引在左邊，值在右邊。如果沒有為數(shù)據(jù)指定索引，于是會自動創(chuàng)建一個0到N-1(N為數(shù)據(jù)的長度)的整數(shù)型索引?？梢酝ㄟ^Series的values和index屬性獲取其數(shù)組表現(xiàn)形式和索引對象：


import numpy as np
import pandas as pd
from pandas import Series,DataFrame
#**********************************Series*************************************
obj=Series([2,4,7,8,9,3])
'''obj=
0    2
1    4
2    7
3    8
4    9
5    3
dtype: int64
'''
obj.values    #return:array([2, 4, 7, 8, 9, 3], dtype=int64)
obj.index     #return: RangeIndex(start=0, stop=6, step=1)
#創(chuàng)建對數(shù)據(jù)點進行標記的索引
obj2=Series([2,4,7,8,9,3],index=['a','b','c','d','e','f'])
'''obj2=
a    2
b    4
c    7
d    8
e    9
f    3
dtype: int64
'''
obj2.index   #return:Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
#利用索引的方式選取Series的單個或一組值
obj2['c']   #return:7
obj2[['a','c','f']]
'''out:
a    2
c    7
f    3
dtype: int64
'''
#numpy數(shù)組運算（布爾型數(shù)組進行過濾、標量乘法、應用數(shù)學函數(shù)等）都會保留索引和值之間的鏈接
obj2[obj2>5]
obj2*2
np.exp(obj2)
'''
obj2[obj2>5]:      obj2*2:       np.exp(obj2):
c    7             a     4           a       7.389056
d    8             b     8           b      54.598150
e    9             c    14           c    1096.633158
dtype: int64       d    16           d    2980.957987
                   e    18           e    8103.083928
                   f     6           f      20.085537
                   dtype: int64      dtype: float64
'''
#可以將Series看成是一個有定長的有序字典，因為它是索引值到數(shù)據(jù)值的一個映射
#因此，一些字典函數(shù)也可以在這里使用：
'a' in obj2        #return:True
'h' in obj2        #return:False
2 in obj2.values   #return:True
#利用字典創(chuàng)建Series
dic={'l':1,'z':2,'h':3}
obj3=Series(dic)
'''obj3=
h    3
l    1
z    2
dtype: int64
'''
#若索引比字典的索引多，則與字典索引相匹配的則會被找到，并放置到相應的位置中
#而對應字找不到的索引，其結(jié)果則為NaN(即非數(shù)字，Not a Number，在pandas中，用于表示缺失或NA值)
ind=['l','z','h','a']
obj4=Series(dic,index=ind)
'''obj4=
l    1.0
z    2.0
h    3.0
a    NaN
dtype: float64
'''
#pandas中isnull和notnull函數(shù)用于檢測缺失數(shù)據(jù)：
pd.isnull(obj4)    #等效于： obj4.isnull()
pd.notnull(obj4)
'''
pd.isnull(obj4):        pd.notnull(obj4)
l    False              l     True
z    False              z     True
h    False              h     True
a     True              a     False
dtype: bool             dtype: bool
'''
#算術運算中自動對齊不同索引的數(shù)據(jù)
obj3+obj4
'''out：
a    NaN
h    6.0
l    2.0
z    4.0
dtype: float64
'''
#Series對象本身及其索引都有一個name屬性
obj4.name='myname'
obj4.index.name='letter'
'''obj4=
letter
l    1.0
z    2.0
h    3.0
a    NaN
Name: myname, dtype: float64
'''
#索引可以通過賦值的方式進行改變
obj4.index=['li','zi','hua','a']
'''obj4=
li     1.0
zi     2.0
hua    3.0
a      NaN
Name: myname, dtype: float64
'''

1.2 DataFrame

DataFrame是一個表格型的數(shù)據(jù)結(jié)構(gòu)，它含有一組有序的列，每列可以是不同的值類型（數(shù)值、字符串、布爾值等）。DataFrame既有行索引也有列索引，它可以被看做由Series組成的字典（公用同一個索引）。跟其他類似的數(shù)據(jù)結(jié)構(gòu)相比，DataFrame中面向行和面向列的操作基本是平衡的。其實，DataFrame中的數(shù)據(jù)是以一個或多個二維塊存放的（而不是列表、字典或者別的一維數(shù)據(jù)結(jié)構(gòu)）。

其中，可以輸入給DataFrame構(gòu)造器的數(shù)據(jù)類型及相關說明：


#*******************************DataFrame*************************************
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
#構(gòu)建DataFrame
#最常用的一種是直接傳入一個由等長列表或numpy數(shù)組組成的字典：
data={'names':['Bob','Jane','Jack','Ann'],
       'sex':['M','F','M','F'],
       'age':[21,30,26,28]}
frame=DataFrame(data)
'''沒有指定索引，會自動加上索引，且全部列會被有序排列
frame=
   age names sex
0   21   Bob   M
1   30  Jane   F
2   26  Jack   M
3   28   Ann   F
'''
#若指定列序列，則會按照指定順序排列
frame=DataFrame(data,columns=['names','sex','age'])
'''frame=
  names sex  age
0   Bob   M   21
1  Jane   F   30
2  Jack   M   26
3   Ann   F   28
'''
#若傳入列在數(shù)據(jù)中找不到，會返回NA值
frame1=DataFrame(data,columns=['names','sex','age','id'],index=['a','b','c','d'])
'''frame1=
  names sex  age   id
a   Bob   M   21  NaN
b  Jane   F   30  NaN
c  Jack   M   26  NaN
d   Ann   F   28  NaN
'''
#通過類似字典標記或?qū)傩缘姆绞剑梢垣@取Series（列數(shù)據(jù)）：
frame1['sex']
frame1.age
'''
frame1['sex']:                           frame1.age:
a    M                                    a      21
b    F                                    b      30
c    M                                    c      26
d    F                                    d      28
Name: sex, dtype: object                  Name: age, dtype: int64
'''
#行也可以通過位置或名稱獲取
#ix VS loc VS iloc
#loc——通過行標簽索引行數(shù)據(jù)
frame1.loc('c')
#等效于
#iloc——通過行號獲取行數(shù)據(jù)
frame1.iloc[2]
#ix--以上兩種的混合，既可以用行號，也可以用行標簽
frame1.ix[2]
frame1.ix['c']
'''result：
names    Jack
sex         M
age        26
id        NaN
Name: c, dtype: object
'''
#獲取多行
#注意：使用行標簽時，：兩邊是全包括，使用行號時是左閉右開
frame1.loc['b':'c']
frame1.iloc[2:4]
frame1.ix['b':'c']
frame1.ix[2:4]
'''result:
 names sex  age   id
c  Jack   M   26  NaN
d   Ann   F   28  NaN
'''
#利用ix、loc、iloc拓展獲取列數(shù)據(jù)
#獲取單列，如下所示，或?qū)'sex']寫成'sex'，將不顯示columns名
frame1.ix[:,['sex']]   #等效于frame1['sex']
frame1.loc[:,['sex']] 
frame1.ix[:,[1]] 
'''
frame1.ix[:,['sex']]:      VS       frame1.ix[:,'sex'] :
  sex
a   M                               a    M
b   F                               b    F
c   M                               c    M
d   F                               d    F
'''
#獲取多列
frame1.ix[:,'sex':]
frame1.loc[:,'sex':]
frame1.iloc[:,1:4]
'''result:
  sex  age   id
a   M   21  NaN
b   F   30  NaN
c   M   26  NaN
d   F   28  NaN
'''
#給列賦值,賦值是列表或數(shù)組時，長度必須相匹配
frame1['id']=np.arange(4)    
'''frame1=
  names sex  age  id
a   Bob   M   21   0
b  Jane   F   30   1
c  Jack   M   26   2
d   Ann   F   28   3
'''
#若賦值的是一個Series，將精確匹配DataFrame的索引，空位將補上缺失值
frame1['id']=Series([11,12],index=['a','c'])
'''frame1=
  names sex  age    id
a   Bob   M   21  11.0
b  Jane   F   30   NaN
c  Jack   M   26  12.0
d   Ann   F   28   NaN
'''
#為不存在的列賦一個新列
frame1['Female']=frame1.sex=='F'
'''frame1=
  names sex  age    id  Female
a   Bob   M   21  11.0   False
b  Jane   F   30   NaN    True
c  Jack   M   26  12.0   False
d   Ann   F   28   NaN    True
'''
#刪除列數(shù)據(jù)
del frame1['Female']
'''frame1=
  names sex  age    id
a   Bob   M   21  11.0
b  Jane   F   30   NaN
c  Jack   M   26  12.0
d   Ann   F   28   NaN
'''
#嵌套字典(字典的字典)作為參數(shù)，傳入DataFrame
#外層字典的鍵作為列（columns），內(nèi)層鍵作為行索引(index)
pop={'Nevada':{2001:2.4,2002:2.9},'Ohio':{2000:1.5,2001:1.7,2002:3.6}}
frame2=DataFrame(pop)
'''frame2=
      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7
2002     2.9   3.6
'''
#對結(jié)果進行轉(zhuǎn)置
frame2.T
'''result:
        2000  2001  2002
Nevada   NaN   2.4   2.9
Ohio     1.5   1.7   3.6
'''
#顯示指定索引
DataFrame(pop,index=[2001,2002,2003])
'''result:
      Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2003     NaN   NaN
'''
#跟Series一樣，values屬性也會以二維ndarray的形式返回DataFrame中的數(shù)據(jù)
frame2.values     #result:array([[ nan,  1.5],[ 2.4,  1.7],[ 2.9,  3.6]])

二、基本功能

2.1 重新索引-------reindex：創(chuàng)建一個適合新索引的新對象

reindex函數(shù)的參數(shù)：

Series中reindex方法：


#Series中的reindex方法
obj=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
#rreindex會根據(jù)新索引重新排列，若索引值不存在，則引入缺省值
obj.reindex(['a','b','c','d','e'])
#還可設置缺省項的值
obj.reindex(['a','b','c','d','e'],fill_value=0)    #此時，上面結(jié)果中的NaN將變成0
'''
obj:            obj.reindex(['a','b','c','d','e']):
d    1.2             a    3.4
a    3.4             b    5.6
c   -7.8             c   -7.8
b    5.6             d    1.2
dtype: float64       e    NaN
                     dtype: float64
'''
#插值處理
#對于時間序列這樣的有序序列，重新索引時需要做一些插值處理
obj1=Series(['yellow','pink','blue'],index=[0,2,4])
obj1.reindex(range(6),method='ffill')
'''obj1=
0    yellow
1    yellow
2      pink
3      pink
4      blue
5      blue
dtype: object
'''

DataFrame中reindex方法：

reindex可以修改（行）索引、列，或兩個都修改。如果僅傳入一個序列，則會重新索引行：


frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
'''frame=
   US  UK  CN
a   0   1   2
b   3   4   5
c   6   7   8
'''
frame1=frame.reindex(['a','b','c','e'])
#使用columns關鍵字即可重新索引列
states=['US','HK','CN']
frame.reindex(columns=states)
'''result:
   US  HK  CN
a   0 NaN   2
b   3 NaN   5
c   6 NaN   8
'''
#可以同時對行和列進行索引，但插值只能按照行（即軸0）應用
frame.reindex(index=['a','b','c','e'],method='ffill',columns=states)
'''
   US  HK  CN
a   0 NaN   2
b   3 NaN   5
c   6 NaN   8
e   6 NaN   8
'''
#利用ix索引功能，重新索引任務變得更加簡潔
frame.ix[['a','b','c','e'],states]
'''
    US  HK   CN
a  0.0 NaN  2.0
b  3.0 NaN  5.0
c  6.0 NaN  8.0
e  NaN NaN  NaN
'''

2.2 丟棄指定軸上的項------drop方法

由于需要執(zhí)行一些數(shù)據(jù)整理和集合邏輯，所以drop方法返回的是一個在指定軸上刪除了指定值的新對象。


#對于Series對象
obj=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
obj.drop('c')               #返回的是新對象，obj沒變
obj.drop(['a','d'])
'''
obj:            obj.drop('c'):               obj.drop(['a','d']):
d    1.2             d    1.2                      c   -7.8
a    3.4             a    3.4                      b    5.6
c   -7.8             b    5.6                      dtype: float64
b    5.6             dtype: float64
dtype: float64                        
'''
#對于DataFrame，可以刪除任意軸上的索引值：
frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
frame.drop('a')   #默認axis=0
frame.drop(['US','UK'],axis=1)
'''
frame:              frame.drop('a'):        frame.drop(['US','UK'],axis=1):
   US  UK  CN          US  UK  CN                CN
a   0   1   2       b   3   4   5            a    2
b   3   4   5       c   6   7   8            b    5
c   6   7   8                                c    8
'''

2.3 算術運算和數(shù)據(jù)對齊

pandas最重要的一個功能是，它可以對不同索引的對象進行算術運算。在將對象相加時，如果存在不同的索引對，則結(jié)果的索引就是索引對的并集。


#對于Series對象
s1=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
s2=Series([1.1,2.2,3.3,4.4.,5.5,6.6],index=['a','b','c','d','e','f'])
s1+s2     #在不重疊的地方引入了NA值，且缺失值會在算術運算過程中傳播
'''result:
a    4.5
b    7.8
c   -4.5
d    5.6
e    NaN
f    NaN
dtype: float64
'''

對于DataFrame對象，對齊操作會發(fā)生在列和行上，具體過程和Series一樣。

2.4 DataFrame和Series之間的運算

跟Numpy數(shù)組一樣，DataFrame和Series之間的算術運算也是有明確規(guī)定的，和不同形狀的數(shù)組之間的運算類似，也具有廣播效應。

默認情況下，DataFrame和Series之間的算術運算會將Series的索引匹配到DataFrame的列，然后沿著行已知向下傳播（行傳播）：


frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
s=frame.ix['a']
frame-s
'''
frame:                 s:                     frame-s:
   US  UK  CN         US  0                      US  UK  CN
a   0   1   2         UK  1                   a   0   0   0
b   3   4   5         CN  2                   b   3   3   3
c   6   7   8                                 c   6   6   6
'''

如果你希望匹配行，且在列上廣播（列傳播），則必須使用算術運算方法：


frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
s1=frame['CN']
frame.sub(s1,axis=0)  #axis=0不能少，否則運算時，默認沿著行向下傳播
'''
frame:                 s1:                     frame.sub(s1,axis=0)
   US  UK  CN            CN                      US  UK  CN
a   0   1   2         a   2                   a  -2  -1   0
b   3   4   5         b   5                   b  -2  -1   0
c   6   7   8         c   8                   c  -2  -1   0
'''
frame-s1   #或frame.sub(s1)
'''result:
   CN  UK  US   a   b   c
a NaN NaN NaN NaN NaN NaN
b NaN NaN NaN NaN NaN NaN
c NaN NaN NaN NaN NaN NaN
'''

算術方法：

2.5 函數(shù)應用和映射

numpy中ufuncs(元素級數(shù)組方法)也可以用于pandas對象，例：


np.exp(frame)
'''
           US           UK           CN
a    1.000000     2.718282     7.389056
b   20.085537    54.598150   148.413159
c  403.428793  1096.633158  2980.957987
'''

另一個常見的操作是，將函數(shù)應用到由各列或行所形成的一維數(shù)組上，DataFrame的apply方法即可實現(xiàn)該功能：


f=lambda x:x.max()-x.min()
frame.apply(f)           #函數(shù)應用到每列所形成一維數(shù)組
frame.apply(f,axis=1)    #函數(shù)應用到每行所形成一維數(shù)組
'''
frame:              
   US  UK  CN        frame.apply(f):         frame.apply(f,axis=1)
a   0   1   2        US    6                       a    2
b   3   4   5        UK    6                       b    2
c   6   7   8        CN    6                       c    2
'''

2.6 排序和排名

根據(jù)條件對數(shù)據(jù)集排序，這是一個內(nèi)置運算，要對行或列索引進行排序（按字典排序），可使用sort_index方法，它將返回一個已排序好的新對象。

2.6.1 排序


#排序
obj=Series([1.2,3.4,-7.8,5.6],index=['d','a','c','b'])
#索引排序
obj.sort_index()
#值排序
obj.sort_values()
'''
obj:             obj.sort_index():          obj.sort_values()：
d    1.2             a    3.4                   c   -7.8
a    3.4             b    5.6                   d    1.2
c   -7.8             c   -7.8                   a    3.4
b    5.6             d    1.2                   b    5.6
'''
frame=DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['US','UK','CN'])
#索引排序，分軸0和軸1，若需要按照哪行排序，可利用by=''，鎖定某行
frame.sort_index(axis=1)
#值排序
#axis=0代表對列操作，by='CN'代表對name為'CN'的列處理，ascending默認為True，代表升序排
frame.sort_values(by='CN',axis=0,ascending=False)
'''
frame:              frame.sort_index(axis=1):   frame.sort_values(by='CN',axis=0,ascending=False)：
   US  UK  CN          CN  UK  US                        US  UK  CN
a   0   1   2       a   2   1   0                     c   6   7   8
b   3   4   5       b   5   4   3                     b   3   4   5
c   6   7   8       c   8   7   6                     a   0   1   2   
'''
#在排序中，默認缺失值都會被放到最后
obj1=Series([4,np.nan,7,np.nan,-3,5])
'''result:
4   -3.0
0    4.0
5    5.0
2    7.0
1    NaN
3    NaN
dtype: float64
'''

2.6.2 排名

排名（ranking）跟排序關系密切，且它會增設一個排名值（從1開始，一直到數(shù)組中有效數(shù)據(jù)的數(shù)量）。它跟numpy.argsort產(chǎn)生的間接排序索引差不多，只不過它可以根據(jù)某種規(guī)則破壞平級關系。默認情況下，rank是通過”為各組分配一個平均排名“的方式破壞平級關系的。

rank()函數(shù)中，用于破壞平級關系的method選項：


#排名：
obj=Series([7,-5,7,4,2,0,4])
obj.rank()
obj.rank(method='first')
'''
obj:           obj.rank():            obj.rank(method='first'):
0    7          0    6.5                  0    6.0
1   -5          1    1.0                  1    1.0
2    7          2    6.5                  2    7.0
3    4          3    4.5                  3    4.0
4    2          4    3.0                  4    3.0
5    0          5    2.0                  5    2.0
6    4          6    4.5                  6    5.0
'''
frame=DataFrame({'b':[3,2,4,1],'a':[7,5,2,9],'c':[3,9,6,2]})
frame.rank(axis=1)
'''
frame:                  frame.rank(axis=1):
   a  b  c                      a    b    c
0  7  3  3                 0  3.0  1.5  1.5
1  5  2  9                 1  2.0  1.0  3.0
2  2  4  6                 2  1.0  2.0  3.0
3  9  1  2                 3  3.0  1.0  2.0
'''

三、匯總和計算描述統(tǒng)計

pandas對象擁有一組常用的數(shù)學和統(tǒng)計方法。它們大部分都屬于簡約和匯總統(tǒng)計，用于從Series中提取單個值（如sum或mean）或從DataFrame的行或列中提取一個Series。更對應的numpy數(shù)組方法，它們都是基于沒有缺失數(shù)據(jù)的假設而構(gòu)建的。

3.1與描述統(tǒng)計相關的函數(shù)：

3.2 函數(shù)中常見的選項:

3.3部分代碼示例：


#匯總和統(tǒng)計
df=DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],columns=['one','two'])
#計算每列的和，默認排除NaN
df.sum()
#計算每行的和，默認排除NaN
df.sum(axis=1)
#計算每行的和，設置skipna=False，NaN參與計算，結(jié)果仍為NaN
df.sum(axis=1,skipna=False)
'''
df:                    df.sum():       df.sum(axis=1):     df.sum(axis=1,skipna=False):
    one  two         one    9.25         0    1.40               0     NaN
0  1.40  NaN         two   -5.80         1    2.60               1    2.60
1  7.10 -4.5                             2    0.00               2     NaN
2   NaN  NaN                             3   -0.55               3   -0.55
3  0.75 -1.3
'''
obj=Series(['a','b','a','d']*4)
obj.describe()
'''
count     16
unique     3
top        a
freq       8
dtype: object
'''

3.4、唯一值、值計數(shù)以及成員資格

常見方法：（對于Series對象）

相關代碼：


obj=Series(['a','d','a','b']*4)
unique=obj.unique()    #結(jié)果未排序 return:array(['a', 'd', 'b'], dtype=object)
obj.value_counts()     #結(jié)果按值頻率降序排序
#等效于   pd.value_counts(obj,sort=True)
'''result:
a    8
d    4
b    4
dtype: int64
'''  
obj1=Series(['a','b','c','d'])
#判斷矢量化集合的成員資格
obj1.isin(['b','d'])
'''
0    False
1     True
2    False
3     True
dtype: bool
'''

對于DataFrame對象，可以使用apply函數(shù)和以上函數(shù)聯(lián)合使用。


frame=DataFrame({'b':[3,2,4,1],'a':[3,5,2,1],'c':[3,3,2,2]})
#fillna(0)將nan值的位置上填補0
frame.apply(pd.value_counts).fillna(0)
'''
     a    b    c
1  1.0  1.0  0.0
2  1.0  1.0  2.0
3  1.0  1.0  2.0
4  0.0  1.0  0.0
5  1.0  0.0  0.0
'''

四、處理缺失數(shù)據(jù)

缺失數(shù)據(jù)是大部分數(shù)據(jù)分析應用中都很常見。pandas的設計目標之一就是讓缺失數(shù)據(jù)的處理任務盡量輕松。pandas使用浮點值（NaN）表示浮點和非浮點數(shù)據(jù)中的缺失數(shù)據(jù)。它只是一個便于被檢測出來的標記而已。python中的內(nèi)置none也會被當做NA處理。

NA的處理方法：