量化投資與Python——pandas
簡介：
為什麼學習pandas
- numpy已經可以幫助我們進行資料的處理了，那麼學習pandas的目的是什麼呢？
- numpy能夠幫助我們處理的是數值型的資料，當然在資料分析中除了數值型的資料還有好多其他類型的資料（字元串，時間序列），那麼pandas就可以幫我們很好的處理除了數值型的其他資料！
什麼是pandas？
- 首先先來認識pandas中的兩個常用的類
- Series
- DataFrame
Series
- Series是一種類似與一維數組的對象，由下面兩個部分組成：
- values：一組資料（ndarray類型）
- index：相關的資料索引标簽
- Series的建立
- 由清單或 numpy 數組建立
- 由字典建立
import pandas as pd
a = pd.Series([1,2,3,4],index=['a','b','c','d']) # 建立數組，并指定索引，預設為 0-n
print（a）
a 1
b 2
c 3
d 4
dtype: int64 切片
import pandas as pd
a = pd.Series([1,2,3,4],index=['a','b','c','d']) # 建立數組，并指定索引，預設為 0-n
print(a)
a 1
b 2
c 3
d 4
dtype: int64
a[1] # 2
a['b'] # 2
a[0:2]
a 1
b 2
dtype: int64 常用屬性
a.shape # (4,)
a.size # 4
a.index # Index(['a', 'b', 'c', 'd'], dtype='object')
a.values # array([1, 2, 3, 4], dtype=int64)
a.dtype # dtype('int64') 注意：dtype('O') 為字元串類型 Series的常用方法
- head(),tail() # 取前（後）N 項
- unique() # 去重
- isnull(),notnull() # isnull() 判斷每一個元素是否為空,notnull() 是否為非空
- add() sub() mul() div() # 加減乘除
DataFrame
- DataFrame是一個【表格型】的資料結構。DataFrame由按一定順序排列的多列資料組成。設計初衷是将Series的使用場景從一維拓展到多元。DataFrame既有行索引，也有列索引。
- 行索引：index
- 列索引：columns
- 值：values df3 = DataFrame(data=data)
# df3 = DataFrame(data=data, index=['a', 'b', 'c'])
# print(df3.index) Index(['a', 'b', 'c'], dtype='object')
print(df3)
print(df3.index) # RangeIndex(start=0, stop=3, step=1) 索引 從 0 開始 3 結束 步長 1
print(df3.shape) # (3, 2) 三行二列
print(df3.columns) # Index(['name', 'salay'], dtype='object')
print(df3.values)
# [['動作' 1000]
# ['情感' 1001]
# ['喜劇' 1002]] DataFrame的建立
- ndarray建立
- 字典建立
df = DataFrame(data=[[1,2,3,4,5],['a','b','c','d']])
print(df)
df2 = DataFrame(data=np.random.randint(0,100,size=(3,6)))
print(df2)
0 1 2 3 4
0 1 2 3 4 5.0
1 a b c d NaN
0 1 2 3 4 5
0 8 55 48 78 94 78
1 97 56 34 74 15 9
2 74 76 27 46 5 83 DataFrame索引操作
- 對行進行索引
- 隊列進行索引
- 對元素進行索引
- iloc:
- 通過隐式索引取行
- loc:
- 通過顯示索引取行
注意：在使用 iloc 與 loc 時，應該保持索引是否是顯隐性的一緻。
# 資料
from pandas import DataFrame
df = DataFrame(data=np.random.randint(10,50,size=(3,6)),index=['a','b','c',])
df
0 1 2 3 4 5
a 26 29 26 39 31 29
b 20 43 40 19 48 22
c 11 42 19 22 23 47
# 對行進行索引
df.iloc[[2]] # 取單行
0 1 2 3 4 5
df.iloc[[0,2]] # 取多行
df[[1]] # 取單列
1
a 29
b 43
c 42
df[[1,3]] # 取多列
1 3
a 29 39
b 43 19
c 42 22
# 隊列進行索引
df[2][3]
# 注意
- 通過隐式索引取行
- 通過顯示索引取行
DataFrame的切片操作
- df索引和切片操作
- 索引：
- df[col]:取列
- df.loc[index]:取行
- df.iloc[index,col]:取元素
- 切片：
- df[index1:index3]:切行
- df.iloc[:,col1:col3]:切列 案例：
from pandas import DataFrame
df = DataFrame(data=np.random.randint(10,50,size=(3,6)),index=['a','b','c',])
df
0 1 2 3 4 5
a 24 25 18 23 23 20
b 21 32 48 40 46 28
c 41 17 44 13 29 20 - 對行進行切片
df[0:2]
0 1 2 3 4 5
a 24 25 18 23 23 20
b 21 32 48 40 46 28 - 對列進行切片
df.iloc[:,0:2]
0 1
a 24 25
b 21 32
c 41 17 練習：
1. 假設ddd是期中考試成績，ddd2是期末考試成績，請自由建立ddd2，并将其與ddd相加，求期中期末平均值。
date = {
'張三':[132,132,132,132,132],
'李四':[128,128,128,128,128],
}
ddd = DataFrame(data=date,index=['國文','數學','英語','化學','實體'])
ddd
張三 李四
國文 132 128
數學 132 128
英語 132 128
化學 132 128
實體 132 128
date2 = {
'張三':[150,150,150,150,150],
'李四':[130,130,130,130,130],
ddd = DataFrame(data=date2,index=['國文','數學','英語','化學','實體'])
ddd2
張三 李四
國文 150 130
數學 150 130
英語 150 130
化學 150 130
實體 150 130
(ddd+ddd2)/2
張三 李四
國文 141.0 129.0
數學 141.0 129.0
英語 141.0 129.0
化學 141.0 129.0
實體 141.0 129.0 2. 假設張三期中考試數學被發現作弊，要記為0分，如何實作？
ddd.iloc[1,0] = 0
ddd
張三 李四
國文 132 128
數學 0 128
英語 132 128
化學 132 128
實體 132 128 3. 李四因為舉報張三作弊立功，期中考試所有科目加100分，如何實作？
ddd[['李四']] += 100
ddd
張三 李四
國文 132 228
數學 0 228
英語 132 228
化學 132 228
實體 132 228 4. 後來老師發現有一道題出錯了，為了安撫學生情緒，給每位學生每個科目都加10分，如何實作？\n
ddd+=10
ddd
張三 李四
國文 142 238
數學 10 238
英語 142 238
化學 142 238
實體 142 238 資料清洗——删除行資料
df = DataFrame(data=np.random.randint(0, 100, size=(5, 7)))
df.loc[1, 3] = None
df.loc[3, 2] = np.nan
df.loc[0, 6] = None
# 過濾方法
# 方法一：删除空值所在的行
# 技術：isnull any，notnull all
# any：用于檢測行或列中是否存在 True，如果有 True，傳回 True，無 True，則傳回 False。
# df.loc[df.isnull().any(axis=1)] # True 對應的行就是有缺失資料的行
drop_index = df.loc[df.isnull().any(axis=1)].index # 取出有缺失資料的行索引
print(df.drop(labels=drop_index, axis=0)) # 删除缺失資料的行
print(df.loc[df.notnull().all(axis=1)]) # 1 是行，0 是列
# 方法二：dropna 直接删除有資料缺失的行或列
print(df.dropna(axis=0)) # 0 是行，1 是列 資料清洗——替代資料
# 對缺失值進行覆寫
# 使用指定值來覆寫
print(df.fillna(value=666))
# 水準覆寫
print(df.fillna(method='ffill',axis=1)) # 使用水準方向的向前填充
print(df.fillna(method='bfill',axis=1)) # 使用水準方向的向後填充
# 垂直覆寫
print(df.fillna(method='ffill',axis=0)) # 使用垂直方向的向下填充
print(df.fillna(method='bfill',axis=0)) # 使用垂直方向的向上填充 清洗案例
資料檔案
# 資料清洗，1 2 3 4 列
# 方法一：删除
df = pd.read_excel('./testData.xlsx')
df = df[[1,2,3,4]]
print(df.dropna(axis=0))
# 方法二：替換
# 采用垂直填充，因為每分鐘前後取得的檢測值一般差别不大
df = df.fillna(method='ffill',axis=0).fillna(method='bfill',axis=0)
print(df)
# 檢測是否還有空值
print(df.isnull().any(axis=0)) 重複資料與異常資料的清洗
重複資料處理
# 準備資料
import numpy as np
from pandas import DataFrame
df = DataFrame(data=np.random.randint(0,100,size=(7,3)))
df.iloc[1]=(0,0,0)
df.iloc[3]=(0,0,0)
df.iloc[5]=(0,0,0)
df=df.drop_duplicates(keep='first') # keep='first' 保留第一次出現的行數值，預設值
df=df.drop_duplicates(keep='last') # keep='last' 保留最後一次出現的行數值，預設值
df=df.drop_duplicates(keep=False) # keep=False 删除所有行數值，預設值
df 異常資料處理
自定義一個 1000行3列（A、B、C）取值範圍 0-1 的資料源，然後将 C 列中的大于其兩倍标準差的異常資料進行清理
# 資料準備
import numpy as np
from pandas import DataFrame
df = DataFrame(data = np.random.random(size=(1000,3)),columns=['A','B','C'])
# 設定異常值條件
two =df['C'].std()*2
df[~(df['C'] > two)] 級聯與合并
級聯
比對級聯
import pandas as pd
import numpy as np
from pandas import DataFrame
df = DataFrame(data=np.random.randint(1,100,size=(5,3)),columns=('a','b','c'))
df2 = DataFrame(data=np.random.randint(1,100,size=(5,3)),columns=('a','b','c'))
pd.concat((df,df2),axis=0) # 縱向級聯
pd.concat((df,df2),axis=1) # 橫向級聯 不比對級聯
即索引不一緻，有兩種連接配接方式：内連接配接、外連接配接（預設）。
import pandas as pd
import numpy as np
from pandas import DataFrame
df = DataFrame(data=np.random.randint(1,100,size=(5,3)),columns=('a','b','c'))
df2 = DataFrame(data=np.random.randint(1,100,size=(5,3)),columns=('a','d','c'))
pd.concat((df,df2),axis=1) # 橫向級聯
pd.concat((df,df2),axis=0) # 縱向級聯 執行結果：
# 橫向級聯
a b c a d c
0 79 77 64 65 57 76
1 83 67 72 61 51 82
2 5 44 50 86 80 44
3 66 14 24 92 88 27
4 52 10 8 3 91 58
# 縱向級聯
a b c d
0 79 77.0 64 NaN
1 83 67.0 72 NaN
2 5 44.0 50 NaN
3 66 14.0 24 NaN
4 52 10.0 8 NaN
0 65 NaN 76 57.0
1 61 NaN 82 51.0
2 86 NaN 44 80.0
3 92 NaN 27 88.0
4 3 NaN 58 91.0
内連接配接與外連接配接
外連接配接：保留資料的完整性
a b c d
0 79 77.0 64 NaN
1 83 67.0 72 NaN
2 5 44.0 50 NaN
3 66 14.0 24 NaN
4 52 10.0 8 NaN
0 65 NaN 76 57.0
1 61 NaN 82 51.0
2 86 NaN 44 80.0
3 92 NaN 27 88.0
4 3 NaN 58 91.0
内連接配接：存在資料丢失
a c
0 79 64
1 83 72
2 5 50
3 66 24
4 52 8
0 65 76
1 61 82
2 86 44
3 92 27
4 3 58
合并
merge 與 concat 的差別值于，merge 需要依據某一共同列來進行合并
使用 pd.merge() 合并時，會自動根據兩者相同 column 名稱的列作為 key 來進行合并
注意每一列元素的順序不要求一緻，與資料庫中 外連接配接、内連接配接一樣，對資料的合并。
# 文法操作
pd.merge(df,df2,on='列名') # 存在相同列名稱
pd.merge(df,df2,how='outer') # 外連接配接
pd.merge(df,df2,how='inner') # 内連接配接
pd.merge(df,df2,left_on='列名'，right_on='列名2') # 存在不同列名稱 替換
替換操作
- 替換操作可以同步作用于Series和DataFrame中
- 單值替換
- 普通替換： 替換所有符合要求的元素:to_replace=15,value='e'
- 按列指定單值替換： to_replace={列标簽：替換值} value='value'
- 多值替換
- 清單替換: to_replace=[] value=[]
- 字典替換（推薦） to_replace={to_replace:value,to_replace:value} 操作
# 資料準備
import pandas as pd
import numpy as np
from pandas import DataFrame
df = DataFrame(np.random.randint(0,100,size=(3,6)))
# 替換方法
df = df.replace(to_replace=28,value='two')
df = df.replace(to_replace={95:'one'})
df = df.replace(to_replace={5:98},value='three') # 指定列替換 映射
映射操作
- 概念：建立一個映射關系清單，把values元素和一個特定的标簽或者字元串綁定（給一個元素值提供不同的表現形式）
- 建立一個df，兩列分别是姓名和薪資，然後給其名字起對應的英文名
data={
'name':['張三','李四','張三'],
'manay':[12000,13000,12000]
}
df = DataFrame(data=data)
# 映射關系表
dic={
'張三':'tom',
'李四':'jack'
}
df['e_name'] = df['name'].map(dic)
df
name manay e_name
0 張三 12000 tom
1 李四 13000 jack
2 張三 12000 tom 注意：map是Series的方法，隻能被Series調用
運算工具
def after(s):
return s-(s-3000)*0.5
df['after_manay'] = df['manay'].map(after)
df
結果：
name manay e_name after_manay
0 張三 12000 tom 7500.0
1 李四 13000 jack 8000.0
2 張三 12000 tom 7500.0 排序實作的随機抽樣
take()
np.random.permutation()
df2 = DataFrame(np.random.randint(0,100,size=(100,3)),columns=['A','B','C'])
df2
# 随機打亂數組
# rp = np.random.permutation(3) # 生成随機數列
df2=df2.take(np.random.permutation(3),axis=1) # 按照隐式随機數列進行打亂
df2 = df2.take(np.random.permutation(3),axis=1).take(np.random.permutation(100),axis=0) # 同時打亂列與行
df2[5:10] # 切取 5-10 行 資料的分類處理
- 資料分類處理的核心：
- groupby() 函數
- groups 屬性檢視分組情況
# 資料準備
df = DataFrame({'item':['Apple','Banana','Orange','Banana','Orange','Apple'],
'price':[4,3,3,2.5,4,2],
'color':['red','yellow','yellow','green','green','green'],
'weight':[12,20,50,30,20,44]})
item price color weight
0 Apple 4.0 red 12
1 Banana 3.0 yellow 20
2 Orange 3.0 yellow 50
3 Banana 2.5 green 30
4 Orange 4.0 green 20
5 Apple 2.0 green 44
# 計算每種水果的平均價格
df.groupby(by='item')['price'].mean()
item
Apple 3.00
Banana 2.75
Orange 3.50
Name: price, dtype: float64
# 計算每一種顔色對應水果的平均總量
df_werght = df.groupby(by='color')['weight'].mean()
df_werght
color
green 31.333333
red 12.000000
yellow 35.000000
Name: weight, dtype: float64
# 将計算的出的平均總量彙總到原資料中
df['mena_w'] = df['color'].map(df_werght)
tem price color weight mena_w
0 Apple 4.0 red 12 12.000000
1 Banana 3.0 yellow 20 35.000000
2 Orange 3.0 yellow 50 35.000000
3 Banana 2.5 green 30 31.333333
4 Orange 4.0 green 20 31.333333
5 Apple 2.0 green 44 31.333333
進階資料聚合
- 使用groupby分組後，也可以使用transform和apply提供自定義函數實作更多的運算
- df.groupby('item')['price'].sum() <==> df.groupby('item')['price'].apply(sum)
- transform和apply都會進行運算，在transform或者apply中傳入函數即可
- transform和apply也可以傳入一個lambda表達式
def my_mean(s):
m_sum = 0
for i in s:
m_sum += i
return m_sum/len(s)
df.groupby(by='item')['weight'].transform(my_mean)
df
item price color weight mena_w
0 Apple 4.0 red 12 12.000000
1 Banana 3.0 yellow 20 35.000000
2 Orange 3.0 yellow 50 35.000000
3 Banana 2.5 green 30 31.333333
4 Orange 4.0 green 20 31.333333
5 Apple 2.0 green 44 31.333333
df.groupby(by='item')['weight'].apply(my_mean)
df
item price color weight mena_w
0 Apple 4.0 red 12 12.000000
1 Banana 3.0 yellow 20 35.000000
2 Orange 3.0 yellow 50 35.000000
3 Banana 2.5 green 30 31.333333
4 Orange 4.0 green 20 31.333333
5 Apple 2.0 green 44 31.333333 資料加載
源檔案：
你好-我好-她也好
你好-我好-她也好
你好-我好-她也好 預設讀取：兩行一列
現在改為三行三列
df2 = pd.read_csv(r'H:\py\進階\資料分析\科學計算基礎包-numpy\test.csv',header=None,sep='-') 透視表
- 透視表是一種可以對資料動态排布并且分類彙總的表格格式。或許大多數人都在Excel使用過資料透視表，也體會到它的強大功能，而在pandas中它被稱作pivot_table。
- 透視表的優點：
- 靈活性高，可以随意定制你的分析計算要求
- 脈絡清晰易于了解資料
- 操作性強，報表神器
資料檔案：透視表案例原資料
import pandas as pd
from pandas import DataFrame
data = pd.read_csv(r'H:\py\進階\資料分析\科學計算基礎包-numpy\透視表-籃球賽.csv')
df = DataFrame(data=data)
df pivot_table有四個最重要的參數index、values、columns、aggfunc
- index參數：分類彙總的分類條件
- 每個pivot_table必須擁有一個index。如果想檢視哈登對陣每個隊伍的得分則需要對每一個隊進行分類并計算其各類得分的平均值：
- 想看看哈登對陣同一對手在不同主客場下的資料，分類條件為對手和主客場
df.pivot_table(index=['對手','主客場']) - values參數：需要對計算的資料進行篩選
- 如果我們隻需要哈登在主客場和不同勝負情況下的得分、籃闆與助攻三項資料：
df.pivot_table(index=['主客場','勝負'],values=['得分','籃闆','助攻']) - Aggfunc參數：設定我們對資料聚合時進行的函數操作
- 當我們未設定aggfunc時，它預設aggfunc='mean'計算均值。
- 如果我們隻需要哈登在主客場和不同勝負情況下的總得分、總籃闆與總助攻三項資料：
df.pivot_table(index=['主客場','勝負'],values=['得分','籃闆','助攻'],aggfunc='sum') - Columns:可以設定列層次字段
- 對values字段進行分類
# 擷取所有隊主客場的總得分
df.pivot_table(index=['主客場'],values=['得分'],aggfunc='sum')
# 擷取每個隊主客場的總得分
df.pivot_table(index=['主客場'],values=['得分'],aggfunc='sum',columns='對手',fill_value=0) 交叉表
- 是一種用于計算分組的特殊透視圖,對資料進行彙總
- pd.crosstab(index,colums)
- index:分組資料，交叉表的行索引
- columns:交叉表的列索引
df = DataFrame({'sex':['man','man','women','women','man','women','man','women','women'],
'age':[15,23,25,17,35,57,24,31,22],
'smoke':[True,False,False,True,True,False,False,True,False],
'height':[168,179,181,166,173,178,188,190,160]})
df
# 求出各個性别抽煙的人數
pd.crosstab(df.smoke,df.sex)
# 求出各個年齡段抽煙人情況
pd.crosstab(df.age,df.sex) 案例
# -*- coding: utf-8 -*-
# @File : pandas-基礎.py
# @Date : 2020-06-09
# @Author : Administrator
import pandas as pd
import dateutil
from datetime import datetime
# ################ Series ################
a = pd.Series([4, 5, 6, 3])
# print(a)
# 0 4
# 1 5
# 2 6
# 3 3
# dtype: int64
b = pd.Series([4, 5, 6, 3], index=['a', 'b', 'c', 'd'])
print(b)
# a 4
# b 5
# c 6
# d 3
# 既可以通過下标通路，也可以通過 key 來通路
# print(b[2],b['c']) # 6 6
# 按照标簽進行累加
c = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
d = pd.Series([1, 2, 3, 4], index=['b', 'c', 'a', 'd'])
print(c+d)
# b 3
# c 5
# d 8
# 如果兩個清單的标簽不一緻，則隻累加标簽一緻的結果，其它為空
e = pd.Series([1, 2, 3, 4], index=['b', 'b', 'a', 'd'])
print(e+c)
# a 4.0
# b 3.0
# b 4.0
# c NaN
# d 8.0
# dtype: float64
f = pd.DataFrame({'one': [1, 2, 3], 'two': [4, 5, 6]})
print(f)
# one two
# 0 1 4
# 1 2 5
# 2 3 6
g = pd.DataFrame({'one': [1, 2, 3], 'two': [4, 5, 6]}, index=['a', 'b', 'c'])
print(g)
# a 1 4
# b 2 5
# c 3 6
h = pd.DataFrame({'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])})
print(h)
# a 1.0 1
# b 2.0 2
# c 3.0 3
# d NaN 4
print(h.keys()) # Index(['one', 'two'], dtype='object')
print(h.values)
# [[ 1. 1.]
# [ 2. 2.]
# [ 3. 3.]
# [nan 4.]]
print(h.T)
# a b c d
# one 1.0 2.0 3.0 NaN
# two 1.0 2.0 3.0 4.0
print(h.describe())
# one two
# count 3.0 4.000000
# mean 2.0 2.500000
# std 1.0 1.290994
# min 1.0 1.000000
# 25% 1.5 1.750000
# 50% 2.0 2.500000
# 75% 2.5 3.250000
# max 3.0 4.000000
# 時間處理
now = datetime.now()
time = dateutil.parser.parser('2001-01-01')
print(time) # <dateutil.parser._parser.parser object at 0x0000025D7A7A05C0>
pd_time = pd.to_datetime([now])
print(pd_time) # DatetimeIndex(['2020-06-28 13:43:48.554969'], dtype='datetime64[ns]', freq=None)
# 批量生成時間隊列
time_list = pd.date_range('2020-01-01',periods=30,freq='W-MON')
print(time_list)
# DatetimeIndex(['2020-01-06', '2020-01-13', '2020-01-20', '2020-01-27',
# '2020-02-03', '2020-02-10', '2020-02-17', '2020-02-24',
# '2020-03-02', '2020-03-09', '2020-03-16', '2020-03-23',
# '2020-03-30', '2020-04-06', '2020-04-13', '2020-04-20',
# '2020-04-27', '2020-05-04', '2020-05-11', '2020-05-18',
# '2020-05-25', '2020-06-01', '2020-06-08', '2020-06-15',
# '2020-06-22', '2020-06-29', '2020-07-06', '2020-07-13',
# '2020-07-20', '2020-07-27'],
# dtype='datetime64[ns]', freq='W-MON')
時間資料類型的轉換
- 時間資料類型的轉換
- pd.to_datetime(col)
- 将某一列設定為行索引
- df.set_index() data = {
"time":['2020-06-30','2020-06-29','2020-06-28'],
"num":[31,32,33]
}
dd = DataFrame(data=data)
print(dd)
time num
0 2020-06-30 31
1 2020-06-29 32
2 2020-06-28 33
# 将 time 列的字元串類型轉為時間序列類型
dd['time'] = pd.to_datetime(dd['time'])
print(dd)
print(dd['time'].dtype)
time num
0 2020-06-30 31
1 2020-06-29 32
2 2020-06-28 33
datetime64[ns]
# 将 time 列作為原資料的索引列
dd.set_index('time')
num
time
2020-06-30 31
2020-06-29 32
2020-06-28 33
# 改變原資料 inplace=True
dd.set_index('time',inplace=True)
print(dd) DataFrame