什么是pandas
pandas是一種Python數據分析的利器，是一個開源的數據分析包，最初是應用於金融數據分析工具而開發出來的，因此pandas為時間序列分析提供了很好的支持。pandas是PyData項目的一部分。
官方文檔：http://pandas.pydata.org/pandas-docs/stable/
安裝pandas
Python版本要求：2.7、3.4、3.5、3.6
依賴Python庫：setuptools、NumPy、python-dateutil、pytz
安裝方式：
Python的Anaconda發行版，已經安裝好pandas庫，不需要另外安裝
使用Anaconda界面安裝，選擇對應的pandas進行勾選安裝即可
使用Anaconda命令安裝：conda install pandas
使用PyPi安裝命令安裝：pip install pandas
使用Anaconda界面安裝pandas
pandas操作
pandas引入約定
from pandas import Series,
DataFrame import pandas as pd
pandas基本數據結構
pandas中主要有兩種數據結構，分別是：Series和DataFrame。
Series：一種類似於一維數組的對象，是由一組數據(各種NumPy數據類型)以及一組與之相關的數據標簽(即索引)組成。僅由一組數據也可產生簡單的Series對象。注意：Series中的索引值是可以重復的。
DataFrame：一個表格型的數據結構，包含有一組有序的列，每列可以是不同的值類型(數值、字符串、布爾型等)，DataFrame即有行索引也有列索引，可以被看做是由Series組成的字典。
Series：通過一維數組創建
練習
In [2]:
import pandas as pd
import numpy as np
series創建
In [8]:
# ser01 = pd.Series([1,2,3,4])
# ser01
ser01 = pd.Series(np.array([1,2,3,4]))
ser01
print(ser01.dtype)
print(ser01.values)
print(ser01.index)
print(ser01)
int32
[1 2 3 4]
RangeIndex(start=0, stop=4, step=1)
0 1
1 2
2 3
3 4
dtype: int32
In [9]:
#設置索引(創建好后改)
ser01.index = ['a','b','c','d']
ser01
Out[9]:
a 1
b 2
c 3
d 4
dtype: int32
In [10]:
ser01 = pd.Series(np.array([1,2,3,4]),index = ['a','b','c','d'])
ser01
Out[10]:
a 1
b 2
c 3
d 4
dtype: int32
Series：通過字典的方式創建
練習
通過字典的方式創建
In [11]:
ser02 = pd.Series({
'a':10, #key變為索引
'b':20,
'c':30
})
ser02
Out[11]:
a 10
b 20
c 30
dtype: int64
Series值的獲取
Series值的獲取主要有兩種方式：
通過方括號+索引的方式讀取對應索引的數據，有可能返回多條數據
通過方括號+下標值的方式讀取對應下標值的數據，下標值的取值范圍為：[0，len(Series.values))；另外下標值也可以是負數，表示從右往左獲取數據
Series獲取多個值的方式類似NumPy中的ndarray的切片操作，通過方括號+下標值/索引值+冒號(:)的形式來截取series對象中的一部分數據。
Series的運算
NumPy中的數組運算，在Series中都保留了，均可以使用，並且Series進行數組運算的時候，索引與值之間的映射關系不會發生改變。
注意：其實在操作Series的時候，基本上可以把Series看成NumPy中的ndarray數組來進行操作。ndarray數組的絕大多數操作都可以應用到Series上。
練習
Series值得獲取
In [15]:
print(ser02['a'])
print(ser02[0])
print(ser02[0:2])
print(ser02['a':'c'])
10
10
a 10
b 20
dtype: int64
a 10
b 20
c 30
dtype: int64
Series的運算
In [16]:
ser02 = pd.Series({
'a':10, #key變為索引
'b':20,
'c':30
})
ser02
Out[16]:
a 10
b 20
c 30
dtype: int64
In [20]:
ser02[ser02 > 10]
ser02/10
ser02+10
ser02*10
Out[20]:
a 100
b 200
c 300
dtype: int64
In [22]:
np.exp(ser02)
np.fabs(ser02)
Out[22]:
a 10.0
b 20.0
c 30.0
dtype: float64
Series缺失值檢測
pandas中的isnull和notnull兩個函數可以用於在Series中檢測缺失值，這兩個函數的返回時一個布爾類型的Series
Series自動對齊
當多個series對象之間進行運算的時候，如果不同series之間具有不同的索引值，那么運算會自動對齊不同索引值的數據，如果某個series沒有某個索引值，那么最終結果會賦值為NaN。
Series及其索引的name屬性
Series對象本身以及索引都具有一個name屬性，默認為空，根據需要可以進行賦值操作
Series缺失值檢測與處理
In [26]:
ser01 = pd.Series({
'a':10,
'b':20,
'c':30
})
ser01
ser02 = pd.Series(ser01,index = ['a','b','c','d'])
ser02
Out[26]:
a 10.0
b 20.0
c 30.0
d NaN
dtype: float64
In [28]:
ser02[pd.isnull(ser02)]
ser02[pd.notnull(ser02)]
Out[28]:
a 10.0
b 20.0
c 30.0
dtype: float64
In [29]:
ser01 = pd.Series([1,2,3,4],index = ['a','b','c','d'])
ser02 = pd.Series([10,20,30,40],index = ['e','a','f','b'])
ser01+ser02
Out[29]:
a 21.0
b 42.0
c NaN
d NaN
e NaN
f NaN
dtype: float64
In [32]:
#series的name屬性
ser01 = pd.Series([1,2,3,4],index = ['a','b','c','d'])
ser01.name = 'aaa'
ser01.index.name = 'names'
ser01
Out[32]:
names
a 1
b 2
c 3
d 4
Name: aaa, dtype: int64
DataFrame: 通過二維數組創建
In [1]:
import pandas as pd
In [3]:
df01 = pd.DataFrame([['joe','susan','anne'],[79,45,67]])
df01
Out[3]:
0 1 2
0 joe susan anne
1 79 45 67
In [10]:
df01 = pd.DataFrame([['joe','susan','anne'],[79,45,67]],index = ['one','teo'],columns = ['a','b','c'])
print(df01)
print(df01.index)
print(df01.columns)
print(df01.values)
a b c
one joe susan anne
teo 79 45 67
Index(['one', 'teo'], dtype='object')
Index(['a', 'b', 'c'], dtype='object')
[['joe' 'susan' 'anne']
[79 45 67]]
DataFrame: 通過字典的方式創建
索引對象
不管是Series還是DataFrame對象，都有索引對象。
索引對象負責管理軸標簽和其它元數據(eg：軸名稱等等)
通過索引可以從Series、DataFrame中獲取值或者對某個索引值進行重新賦值
Series或者DataFrame的自動對齊功能是通過索引實現的
DataFrame數據獲取
可以直接通過列索引獲取指定列的數據， eg: df[column_name]
如果需要獲取指定行的數據的話，需要通過ix方法來獲取對應行索引的行數據，eg: df.ix[index_name]
通過字典的方法創建
In [42]:
df01 = pd.DataFrame({
'name':['joe','susan','anne'],
'sex':['men','women','women'],
'age':[18,19,20],
'classid':3
},index = ['one','two','three'])
print(df01)
age classid name sex
one 18 3 joe men
two 19 3 susan women
three 20 3 anne women
DataFrame獲取數據
In [43]:
#列索引獲取數據
df01['name']
df01.name
Out[43]:
one joe
two susan
three anne
Name: name, dtype: object
In [44]:
#列添加
df01['address'] = ['北京','上海','廣州']
df01
Out[44]:
age classid name sex address
one 18 3 joe men 北京
two 19 3 susan women 上海
three 20 3 anne women 廣州
In [45]:
#列刪除
df01.pop('address')
df01
Out[45]:
age classid name sex
one 18 3 joe men
two 19 3 susan women
three 20 3 anne women
In [46]:
#列修改
df01['classid'] = 4
df01
Out[46]:
age classid name sex
one 18 4 joe men
two 19 4 susan women
three 20 4 anne women
In [47]:
#行獲取
df01.ix['one']
df01.loc['two']#兩種方式
df01.loc['two','name']
df01.loc['two']['name']#兩種方式
Out[47]:
'susan'
In [33]:
#行增加
df01.ix['four'] = [21,3,'black','men']
df01
Out[33]:
age classid name sex
one 18 4 joe men
two 19 4 susan women
three 20 4 anne wpmen
four 21 3 black men
In [48]:
#行修改
df01.ix['four'] = [23,4,'ronaldo','men']
df01
Out[48]:
age classid name sex
one 18 4 joe men
two 19 4 susan women
three 20 4 anne women
four 23 4 ronaldo men
In [35]:
#行刪除
df01.drop('four')
Out[35]:
age classid name sex
one 18 4 joe men
two 19 4 susan women
three 20 4 anne wpmen
pandas基本功能
數據文件讀取/文本數據讀取
索引、選取和數據過濾
算法運算和數據對齊
函數的應用和映射
重置索引
pandas：數據文件讀取
通過pandas提供的read_xxx相關的函數可以讀取文件中的數據，並形成DataFrame,常用的數據讀取方法為：read_csv，主要可以讀取文本類型的數據
In [13]:
import pandas as pd
import numpy as np
讀取文件
In [4]:
df01 = pd.read_csv('data.csv')
df01
Out[4]:
name age sex
0 joe 18 men
1 susan 19 women
2 anne 20 women
In [5]:
df02 = pd.read_excel('data.xlsx')
df02
Out[5]:
name age sex
0 joe 18 men
1 susan 19 women
2 anne 20 women
In [9]:
df03 = pd.read_csv('data.txt',sep = ';',header = None)
df03
Out[9]:
0 1 2
0 joe 18 men
1 susan 19 women
2 anne 20 women
pandas：數據過濾獲取
通過DataFrame的相關方式可以獲取對應的列或者數據形成一個新的DataFrame, 方便后續進行統計計算。
數據過濾
In [11]:
df01 = pd.DataFrame({
'name':['joe','susan','anne'],
'sex':['men','women','women'],
'age':[18,19,20],
'classid':3
},index = ['one','two','three'])
print(df01)
print(df01.columns)
age classid name sex
one 18 3 joe men
two 19 3 susan women
three 20 3 anne women
Index(['age', 'classid', 'name', 'sex'], dtype='object')
In [12]:
df01[df01.columns[2:]]
Out[12]:
name sex
one joe men
two susan women
three anne women
pandas：缺省值NaN處理方法
對於DataFrame/Series中的NaN一般采取的方式為刪除對應的列/行或者填充一個默認值
缺失值NaN
In [32]:
df01 = pd.DataFrame(np.random.randint(1,9,size = (4,4)))
df01
Out[32]:
0 1 2 3
0 7 7 1 6
1 3 8 5 7
2 7 4 3 2
3 8 2 6 6
In [33]:
df01.ix[1:2,1] = np.NaN
df01.ix[1:2,2] = np.NaN
df01.ix[1:2,3] = np.NaN
df01
Out[33]:
0 1 2 3
0 7 7.0 1.0 6.0
1 3 NaN NaN NaN
2 7 NaN NaN NaN
3 8 2.0 6.0 6.0
In [34]:
df01.dropna()#默認只要包含NaN就會刪除
Out[34]:
0 1 2 3
0 7 7.0 1.0 6.0
3 8 2.0 6.0 6.0
In [35]:
df01.ix[1,0] = np.NaN
df01.dropna(how = 'all')#指定閾值 刪除行
Out[35]:
0 1 2 3
0 7.0 7.0 1.0 6.0
2 7.0 NaN NaN NaN
3 8.0 2.0 6.0 6.0
In [36]:
df01.dropna(axis = 1)#刪除列（包含就刪除）
Out[36]:
0
1
2
3
In [37]:
df01 = pd.DataFrame(np.random.randint(1,9,size = (4,4)))
df01
Out[37]:
0 1 2 3
0 1 7 7 2
1 2 7 7 8
2 7 8 2 1
3 8 5 4 4
In [40]:
df01.ix[1,0] = np.NaN
df01.ix[1:2,1] = np.NaN
df01.ix[1:2,2] = np.NaN
df01.ix[1:2,3] = np.NaN
df01
Out[40]:
0 1 2 3
0 1.0 NaN 7.0 2.0
1 NaN NaN NaN NaN
2 7.0 NaN NaN NaN
3 8.0 5.0 4.0 4.0
In [41]:
df01.fillna(0)#將0插入
Out[41]:
0 1 2 3
0 1.0 0.0 7.0 2.0
1 0.0 0.0 0.0 0.0
2 7.0 0.0 0.0 0.0
3 8.0 5.0 4.0 4.0
In [42]:
df01.fillna({0:1,1:1,2:2,3:3})#指定列插入值
Out[42]:
0 1 2 3
0 1.0 1.0 7.0 2.0
1 1.0 1.0 2.0 3.0
2 7.0 1.0 2.0 3.0
3 8.0 5.0 4.0 4.0
pandas：常用的數學統計方法
數學統計方法
In [56]:
df01 = pd.DataFrame(np.random.randint(1,9,size = (5,4)))
df01
Out[56]:
0 1 2 3
0 4 2 3 6
1 5 3 1 8
2 7 1 1 7
3 8 8 2 5
4 4 4 6 7
In [50]:
df01.sum() #列求和
# df01.sum(axis = 1) #0 按照列求和 1 按照行求和
Out[50]:
0 16
1 22
2 17
3 12
dtype: int64
In [53]:
df01.min()
df01.min(axis = 1)
Out[53]:
0 1
1 2
2 2
3 2
dtype: int32
In [60]:
df01.quantile(0.25)#樣本位 分數位
df01.quantile(0.75)
Out[60]:
0 7.0
1 4.0
2 3.0
3 7.0
dtype: float64
In [57]:
df01.median()#中位數
Out[57]:
0 5.0
1 3.0
2 2.0
3 7.0
dtype: float64
In [61]:
df01.cumsum()#累加
Out[61]:
0 1 2 3
0 4 2 3 6
1 9 5 4 14
2 16 6 5 21
3 24 14 7 26
4 28 18 13 33
In [63]:
df01.pct_change()#計算百分數變化
Out[63]:
0 1 2 3
0 NaN NaN NaN NaN
1 0.250000 0.500000 -0.666667 0.333333
2 0.400000 -0.666667 0.000000 -0.125000
3 0.142857 7.000000 1.000000 -0.285714
4 -0.500000 -0.500000 2.000000 0.400000
In [64]:
df01.var()
Out[64]:
0 3.3
1 7.3
2 4.3
3 1.3
dtype: float64
In [65]:
df01.std()
Out[65]:
0 1.816590
1 2.701851
2 2.073644
3 1.140175
dtype: float64
In [66]:
df01.describe()
Out[66]:
0 1 2 3
count 5.00000 5.000000 5.000000 5.000000
mean 5.60000 3.600000 2.600000 6.600000
std 1.81659 2.701851 2.073644 1.140175
min 4.00000 1.000000 1.000000 5.000000
25% 4.00000 2.000000 1.000000 6.000000
50% 5.00000 3.000000 2.000000 7.000000
75% 7.00000 4.000000 3.000000 7.000000
max 8.00000 8.000000 6.000000 8.000000
pandas：相關系數與協方差
相關系數（Correlation coefficient）：反映兩個樣本/樣本之間的相互關系以及之間的相關程度。在COV的基礎上進行了無量綱化操作，也就是進行了標准化操作。
協方差(Covariance, COV)：反映兩個樣本/變量之間的相互關系以及之間的相關程度。
通俗理解協方差：如果有X,Y兩個變量，每時刻的"X值與均值只差"乘以"Y值與其均值只差"得到一個乘積，再對這每時刻的乘積求和並求出均值。
如果協方差為正，說明X,Y同向變化，協方差越大說明同向程度越高；如果協方差為負，說明X,Y反向運動，協方差越小說明方向程度越高。
pandas：唯一值、值計數以及成員資格
unique方法用於獲取Series中的唯一值數組(去重數據后的數組)
value_counts方法用於計算一個Series中各值的出現頻率
isin方法用於判斷矢量化集合的成員資格，可用於選取Series中或者DataFrame中列中數據的子集
相關系數與協方差
In [76]:
df01 = pd.DataFrame({
'GDP':[400,500,600,700],
'forgin_trade':[300,200,300,500,],
'year':['2012','2013','2014','2015']
})
df01
Out[76]:
GDP forgin_trade year
0 400 300 2012
1 500 200 2013
2 600 300 2014
3 700 500 2015
In [74]:
df01.cov()#協方差
Out[74]:
GDP forgin_trade
GDP 16666.666667 -8333.333333
forgin_trade -8333.333333 9166.666667
In [77]:
df01.corr()
Out[77]:
GDP forgin_trade
GDP 1.000000 0.718185
forgin_trade 0.718185 1.000000
In [81]:
#唯一值
ser01 = pd.Series(['a','b','c','d','a','b','c','d'])
ser01
ser02 = ser01.unique()
print(ser02.dtype)
object
In [85]:
#值計數
ser01 = pd.Series(['a','b','c','d','a','b','c','d','b','c','d'])
ser01.value_counts()
Out[85]:
c 3
b 3
d 3
a 2
dtype: int64
In [88]:
#成員資格
ser01.isin(['b','c'])
ser01[ser01.isin(['b','c'])]#過濾
Out[88]:
1 b
2 c
5 b
6 c
8 b
9 c
dtype: object
pandas：層次索引
在某一個方向擁有多個(兩個及兩個以上)索引級別
通過層次化索引，pandas能夠以較低維度形式處理高緯度的數據
通過層次化索引，可以按照層次統計數據
層次索引包括Series層次索引和DataFrame層次索引
pandas：按照層次索引進行統計數據
層次索引
In [99]:
data = pd.Series([988.44,95678,32455,2345,4346],
index = [
['2001','2001','2001','2002','2002'],
['蘋果','香蕉','西瓜','香蕉','西瓜']
])
print(data)
data['2001']
2001 蘋果 988.44
香蕉 95678.00
西瓜 32455.00
2002 香蕉 2345.00
西瓜 4346.00
dtype: float64
Out[99]:
蘋果 988.44
香蕉 95678.00
西瓜 32455.00
dtype: float64
In [118]:
df = pd.DataFrame({
'year':[2001,2001,2002,2002,2003],
'fruit':['apple','banana','apple','banana','apple'],
'production':[2345,3245,5567,4356,5672]
})
df
Out[118]:
fruit production year
0 apple 2345 2001
1 banana 3245 2001
2 apple 5567 2002
3 banana 4356 2002
4 apple 5672 2003
In [119]:
df2 = df.set_index(['year','fruit'])
df2
Out[119]:
production
year fruit
2001 apple 2345
banana 3245
2002 apple 5567
banana 4356
2003 apple 5672
In [121]:
df2.ix[2001,'apple']
Out[121]:
production 2345
Name: (2001, apple), dtype: int64
In [122]:
df2.sum(level = 'year')
Out[122]:
production
year
2001 5590
2002 9923
2003 5672
In [123]:
df2.mean(level='fruit')
Out[123]:
production
fruit
apple 4528.0
banana 3800.5
In [124]:
df2.min(level=['year','fruit'])
Out[124]:
production
year fruit
2001 apple 2345
banana 3245
2002 apple 5567
banana 4356
2003 apple 5672