四、Pandas
- 簡介
- Series
- DataFrame
- 時間對象處理
- 數據分組和聚合
- 其他常用方法
1、簡介
pandas是一個強大的Python數據分析的工具包，它是基於Numpy構建的，正因pandas的出現，讓Python語言也成為使用最廣泛而且強大的數據分析環境之一。
Pandas的主要功能：
- 具備對其功能的數據結構DataFrame，Series
- 集成時間序列功能
- 提供豐富的數學運算和操作
- 靈活處理缺失數據
安裝方法：
pip install pandas
引用方法：
import pandas as pd
2、Series
Series是一種類似於一維數組的對象，由一組數據和一組與之相關的數據標簽(索引)組成
1、創建方法
第一種：
pd.Series([4,5,6,7,8])
執行結果：
0 4
1 5
2 6
3 7
4 8
dtype: int64
# 將數組索引以及數組的值打印出來，索引在左，值在右，由於沒有為數據指定索引，於是會自動創建一個0到N-1（N為數據的長度）的整數型索引，取值的時候可以通過索引取值，跟之前學過的數組和列表一樣
-----------------------------------------------
第二種：
pd.Series([4,5,6,7,8],index=['a','b','c','d','e'])
執行結果：
a 4
b 5
c 6
d 7
e 8
dtype: int64
# 自定義索引，index是一個索引列表，里面包含的是字符串，依然可以通過默認索引取值。
-----------------------------------------------
第三種：
pd.Series({"a":1,"b":2})
執行結果：
a 1
b 2
dtype: int64
# 指定索引
-----------------------------------------------
第四種：
pd.Series(0,index=['a','b','c'])
執行結果：
a 0
b 0
c 0
dtype: int64
# 創建一個值都是0的數組
-----------------------------------------------
對於Series，其實我們可以認為它是一個長度固定且有序的字典，因為它的索引和數據是按位置進行匹配的，像我們會使用字典的上下文，就肯定也會使用Series
缺失數據
- dropna() # 過濾掉值為NaN的行
- fill() # 填充缺失數據
- isnull() # 返回布爾數組，缺失值對應為True
- notnull() # 返回布爾數組，缺失值對應為False
# 第一步，創建一個字典，通過Series方式創建一個Series對象
st = {"sean":18,"yang":19,"bella":20,"cloud":21}
obj = pd.Series(st)
obj
運行結果：
sean 18
yang 19
bella 20
cloud 21
dtype: int64
------------------------------------------
# 第二步
a = {'sean','yang','cloud','rocky'} # 定義一個索引變量
------------------------------------------
#第三步
obj1 = pd.Series(st,index=a)
obj1 # 將第二步定義的a變量作為索引傳入
# 運行結果：
rocky NaN
cloud 21.0
sean 18.0
yang 19.0
dtype: float64
# 因為rocky沒有出現在st的鍵中，所以返回的是缺失值
通過上面的代碼演示，對於缺失值已經有了一個簡單的了解，接下來就來看看如何判斷缺失值
1、
obj1.isnull() # 是缺失值返回Ture
運行結果：
rocky True
cloud False
sean False
yang False
dtype: bool
2、
obj1.notnull() # 不是缺失值返回Ture
運行結果：
rocky False
cloud True
sean True
yang True
dtype: bool
3、過濾缺失值 # 布爾型索引
obj1[obj1.notnull()]
運行結果：
cloud 21.0
yang 19.0
sean 18.0
dtype: float64
Series特性
- 從ndarray創建Series:Series(arr)
- 與標量（數字）：sr * 2
- 兩個Series運算
- 通用函數：np.ads(sr)
- 布爾值過濾：sr[sr>0]
- 統計函數：mean()、sum()、cumsum()
支持字典的特性：
- 從字典創建Series：Series(dic),
- In運算：'a'in sr、for x in sr
- 鍵索引：sr['a'],sr[['a','b','d']]
- 鍵切片：sr['a':'c']
- 其他函數：get('a',default=0)等
整數索引
pandas當中的整數索引對象可能會讓初次接觸它的人很懵逼，接下來通過代碼演示：
sr = pd.Series(np.arange(10))
sr1 = sr[3:].copy()
sr1
運行結果：
3 3
4 4
5 5
6 6
7 7
8 8
9 9
dtype: int32
# 到這里會發現很正常，一點問題都沒有，可是當使用整數索引取值的時候就會出現問題了。因為在pandas當中使用整數索引取值是優先以標簽解釋的，而不是下標
sr1[1]
解決方法：
- loc屬性 # 以標簽解釋
- iloc屬性 # 以下標解釋
sr1.iloc[1] # 以下標解釋
sr1.loc[3] # 以標簽解釋
Series數據對齊
pandas在運算時，會按索引進行對齊然后計算。如果存在不同的索引，則結果的索引是兩個操作數索引的並集。
sr1 = pd.Series([12,23,34], index=['c','a','d'])
sr2 = pd.Series([11,20,10], index=['d','c','a',])
sr1 + sr2
運行結果:
a 33
c 32
d 45
dtype: int64
# 可以通過這種索引對齊直接將兩個Series對象進行運算
sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])
sr1 + sr3
運行結果：
a 33.0
b NaN
c 32.0
d 45.0
dtype: float64
# sr1 和 sr3的索引不一致，所以最終的運行會發現b索引對應的值無法運算，就返回了NaN,一個缺失值
將兩個Series對象相加時將缺失值設為0：
sr1 = pd.Series([12,23,34], index=['c','a','d'])
sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])
sr1.add(sr3,fill_value=0)
運行結果：
a 33.0
b 14.0
c 32.0
d 45.0
dtype: float64
# 將缺失值設為0，所以最后算出來b索引對應的結果為14
靈活的算術方法:add,sub,div,mul
3、DataFrame
DataFrame是一個表格型的數據結構，相當於是一個二維數組，含有一組有序的列。他可以被看做是由Series組成的字典，並且共用一個索引。
創建方式：
創建一個DataFrame數組可以有多種方式，其中最為常用的方式就是利用包含等長度列表或Numpy數組的字典來形成DataFrame：
第一種：
pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
# 產生的DataFrame會自動為Series分配所索引，並且列會按照排序的順序排列
運行結果：
one two
0 1 4
1 2 3
2 3 2
3 4 1
> 指定列
可以通過columns參數指定順序排列
data = pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
pd.DataFrame(data,columns=['one','two'])
# 打印結果會按照columns參數指定順序
第二種：
pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3],index=['b','a','c'])})
運行結果：
one two
a 1 2
b 2 1
c 3 3
以上創建方法簡單了解就可以，因為在實際應用當中更多是讀數據，不需要自己手動創建
查看數據
常用屬性和方法：
- index 獲取行索引
- columns 獲取列索引
- T 轉置
- columns 獲取列索引
- values 獲取值索引
- describe 獲取快速統計
one two
a 1 2
b 2 1
c 3 3
# 這樣一個數組df
-----------------------------------------------------------------------------
df.index
運行結果：
Index(['a', 'b', 'c'], dtype='object')
----------------------------------------------------------------------------
df.columns
運行結果：
Index(['one', 'two'], dtype='object')
--------------------------------------------------------------------------
df.T
運行結果：
a b c
one 1 2 3
two 2 1 3
-------------------------------------------------------------------------
df.values
運行結果：
array([[1, 2],
[2, 1],
[3, 3]], dtype=int64)
------------------------------------------------------------------------
df.describe()
運行結果：
one two
count 3.0 3.0
mean 2.0 2.0
std 1.0 1.0
min 1.0 1.0
25% 1.5 1.5
50% 2.0 2.0
75% 2.5 2.5
max 3.0 3.0
索引和切片
- DataFrame有行索引和列索引。
- DataFrame同樣可以通過標簽和位置兩種方法進行索引和切片。
DataFrame使用索引切片：
- 方法1：兩個中括號，先取列再取行。 df['A'][0]
- 方法2（推薦）：使用loc/iloc屬性，一個中括號，逗號隔開，先取行再取列。
- loc屬性：解釋為標簽
- iloc屬性：解釋為下標
- 向DataFrame對象中寫入值時只使用方法2
- 行/列索引部分可以是常規索引、切片、布爾值索引、花式索引任意搭配。（注意：兩部分都是花式索引時結果可能與預料的不同）
4、時間對象處理
時間序列類型
- 時間戳：特定時刻
- 固定時期：如2019年1月
- 時間間隔：起始時間-結束時間
Python庫：datatime
- date、time、datetime、timedelta
- dt.strftime()
- strptime()
靈活處理時間對象：dateutil包
- dateutil.parser.parse()
import dateutil
dateutil.parser.parse("2019 Jan 2nd") # 這中間的時間格式一定要是英文格式
運行結果:
datetime.datetime(2019, 1, 2, 0, 0)
成組處理時間對象：pandas
- pd.to_datetime(['2018-01-01', '2019-02-02'])
pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
運行結果：
DatetimeIndex(['2018-03-01', '2019-02-03', '2019-08-12'], dtype='datetime64[ns]', freq=None) # 產生一個DatetimeIndex對象
# 轉換時間索引
ind = pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
sr = pd.Series([1,2,3],index=ind)
sr
運行結果：
2018-03-01 1
2019-02-03 2
2019-08-12 3
dtype: int64
通過以上方式就可以將索引轉換為時間
補充：
pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019']).to_pydatetime()
運行結果：
array([datetime.datetime(2018, 3, 1, 0, 0),
datetime.datetime(2019, 2, 3, 0, 0),
datetime.datetime(2019, 8, 12, 0, 0)], dtype=object)
# 通過to_pydatetime()方法將其轉換為array數組
產生時間對象數組：data_range
- start 開始時間
- end 結束時間
- periods 時間長度
- freq 時間頻率，默認為'D'，可選H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…
pd.date_range("2019-1-1","2019-2-2")
運行結果：
DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
'2019-01-05', '2019-01-06', '2019-01-07', '2019-01-08',
'2019-01-09', '2019-01-10', '2019-01-11', '2019-01-12',
'2019-01-13', '2019-01-14', '2019-01-15', '2019-01-16',
'2019-01-17', '2019-01-18', '2019-01-19', '2019-01-20',
'2019-01-21', '2019-01-22', '2019-01-23', '2019-01-24',
'2019-01-25', '2019-01-26', '2019-01-27', '2019-01-28',
'2019-01-29', '2019-01-30', '2019-01-31', '2019-02-01',
'2019-02-02'],
dtype='datetime64[ns]', freq='D')
時間序列
時間序列就是以時間對象為索引的Series或DataFrame。datetime對象作為索引時是存儲在DatetimeIndex對象中的。
# 轉換時間索引
dt = pd.date_range("2019-01-01","2019-02-02")
a = pd.DataFrame({"num":pd.Series(random.randint(-100,100) for _ in range(30)),"date":dt})
# 先生成一個帶有時間數據的DataFrame數組
a.index = pd.to_datetime(a["date"])
# 再通過index修改索引
特殊功能：
- 傳入“年”或“年月”作為切片方式
- 傳入日期范圍作為切片方式
- 豐富的函數支持：resample(), strftime(), ……
- 批量轉換為datetime對象：to_pydatetime()
a.resample("3D").mean() # 計算每三天的均值
a.resample("3D").sum() # 計算每三天的和
...
5、數據分組和聚合
在數據分析當中，我們有時需要將數據拆分，然后在每一個特定的組里進行運算，這些操作通常也是數據分析工作中的重要環節。
本章學習內容：
- 分組(GroupBY機制)
- 聚合(組內應用某個函數)
- apply
- 透視表和交叉表
5.1、分組(GroupBY機制)
插圖：惡搞圖03
pandas對象（無論Series、DataFrame還是其他的什么）當中的數據會根據提供的一個或者多個鍵被拆分為多組，拆分操作實在對象的特定軸上執行的。就比如DataFrame可以在他的行上或者列上進行分組，然后將一個函數應用到各個分組上並產生一個新的值。最后將所有的執行結果合並到最終的結果對象中。
分組鍵的形式：
- 列表或者數組，長度與待分組的軸一樣
- 表示DataFrame某個列名的值。
- 字典或Series，給出待分組軸上的值與分組名之間的對應關系
- 函數，用於處理軸索引或者索引中的各個標簽嗎
后三種只是快捷方式，最終仍然是為了產生一組用於拆分對象的值。
首先，通過一個很簡單的DataFrame數組嘗試一下：
df = pd.DataFrame({'key1':['x','x','y','y','x',
'key2':['one','two','one',',two','one'],
'data1':np.random.randn(5),
'data2':np.random.randn(5)})
df
運行結果：
key1 key2 data1 data2
0 x one 0.951762 1.632336
1 x two -0.369843 0.602261
2 y one 1.512005 1.331759
3 y ,two 1.383214 1.025692
4 x one -0.475737 -1.182826
訪問data1，並根據key1調用groupby：
f1 = df['data1'].groupby(df['key1'])
f1
運行結果：
<pandas.core.groupby.groupby.SeriesGroupBy object at 0x00000275906596D8>
上述運行是沒有進行任何計算的，但是我們想要的中間數據已經拿到了，接下來，就可以調用groupby進行任何計算
f1.mean() # 調用mean函數求出平均值
運行結果：
key1
x 0.106183
y 2.895220
Name: data1, dtype: float64
以上數據經過分組鍵（一個Series數組）進行了聚合，產生了一個新的Series，索引就是key1列中的唯一值。這些索引的名稱就為key1。接下來就嘗試一次將多個數組的列表傳進來
f2 = df['data1'].groupby([df['key1'],df['key2']])
f2.mean()
運行結果：
key1 key2
x one 0.083878
two 0.872437
y one -0.665888
two -0.144310
Name: data1, dtype: float64
傳入多個數據之后會發現，得到的數據具有一個層次化的索引，key1對應的x\y;key2對應的one\two.
f2.mean().unstack()
運行結果：
key2 one two
key1
x 0.083878 0.872437
y -0.665888 -0.144310
# 通過unstack方法就可以讓索引不堆疊在一起了
補充：
- 1、分組鍵可以是任意長度的數組
- 2、分組時，對於不是數組數據的列會從結果中排除，例如key1、key2這樣的列
- 3、GroupBy的size方法，返回一個含有分組大小的Series
# 以上面的f2測試
f2.size()
運行結果：
key1 key2
x one 2
two 1
y one 1
two 1
Name: data1, dtype: int64
5.2、聚合(組內應用某個函數)
插圖：惡搞圖04
聚合是指任何能夠從數組產生標量值的數據轉換過程。剛才上面的操作會發現使用GroupBy並不會直接得到一個顯性的結果，而是一個中間數據，可以通過執行類似mean、count、min等計算得出結果，常見的還有一些:
| 函數名 | 描述 | |
|---|---|---|
| sum | 非NA值的和 | |
| median | 非NA值的算術中位數 | |
| std、var | 無偏（分母為n-1）標准差和方差 | |
| prod | 非NA值的積 | |
| first、last | 第一個和最后一個非NA值 |
自定義聚合函數
不僅可以使用這些常用的聚合運算，還可以自己自定義。
# 使用自定義的聚合函數，需要將其傳入aggregate或者agg方法當中
def peak_to_peak(arr):
return arr.max() - arr.min()
f1.aggregate(peak_to_peak)
運行結果：
key1
x 3.378482
y 1.951752
Name: data1, dtype: float64
多函數聚合：
f1.agg(['mean','std'])
運行結果：
mean std
key1
x -0.856065 0.554386
y -0.412916 0.214939
最終得到的列就會以相應的函數命名生成一個DataFrame數組
5.3、apply
GroupBy當中自由度最高的方法就是apply，它會將待處理的對象拆分為多個片段，然后各個片段分別調用傳入的函數，最后將它們組合到一起。
df.apply(
['func', 'axis=0', 'broadcast=None', 'raw=False', 'reduce=None', 'result_type=None', 'args=()', '**kwds']
func:傳入一個自定義函數
axis:函數傳入參數當axis=1就會把一行數據作為Series的數據
# 分析歐洲杯和歐洲冠軍聯賽決賽名單
import pandas as pd
url="https://en.wikipedia.org/wiki/List_of_European_Cup_and_UEFA_Champions_League_finals"
eu_champions=pd.read_html(url) # 獲取數據
a1 = eu_champions[2] # 取出決賽名單
a1.columns = a1.loc[0] # 使用第一行的數據替換默認的橫向索引
a1.drop(0,inplace=True) # 將第一行的數據刪除
a1.drop('#',axis=1,inplace=True) # 將以#為列名的那一列刪除
a1.columns=['Season', 'Nation', 'Winners', 'Score', 'Runners_up', 'Runners_up_Nation', 'Venue','Attendance'] # 設置列名
a1.tail() # 查看后五行數據
a1.drop([64,65],inplace=True) # 刪除其中的缺失行以及無用行
a1
運行結果：
現在想根據分組選出Attendance列中值最高的三個。
# 先自定義一個函數
def top(df,n=3,column='Attendance'):
return df.sort_values(by=column)[-n:]
top(a1,n=3)
運行結果：
接下來，就對a1分組並且使用apply調用該函數：
a1.groupby('Nation').apply(top)
運行之后會發現，我們通過這個操作將每個國家各個年份時段出席的人數的前三名進行了一個提取。
以上top函數是在DataFrame的各個片段上調用，然后結果又通過pandas.concat組裝到一起，並且以分組名稱進行了標記。
以上只是基本用法，apply的強大之處就在於傳入函數能做什么都由自己說了算，它只是返回一個pandas對象或者標量值就行
6、其他常用方法
pandas常用方法（適用Series和DataFrame）
- mean(axis=0,skipna=False)
- sum(axis=1)
- sort_index(axis, …, ascending) # 按行或列索引排序
- sort_values(by, axis, ascending) # 按值排序
- apply(func, axis=0) # 將自定義函數應用在各行或者各列上，func可返回標量或者Series
- applymap(func) # 將函數應用在DataFrame各個元素上
- map(func) # 將函數應用在Series各個元素上