Python---pandas包
來源:http://www.th7.cn/Program/Python/201412/329841.shtml
pandas 是基於 Numpy 構建的含有更高階資料結構和工具的資料分析包
類似於 Numpy 的核心是 ndarray,pandas 也是圍繞著 Series 和 DataFrame 兩個核心資料結構展開的 。Series 和 DataFrame 分別對應於一維的序列和二維的表結構。pandas 約定俗成的匯入方法如下:
from pandas import Series,DataFrame
import pandas as pd
Series
Series 可以看做一個定長的有序字典
>>> s = Series([1,2,3.0,'abc'])
>>> s
0 1
1 2
2 3
3 abc
dtype: object
雖然 dtype:object
可以包含多種基本資料型別,但總感覺會影響效能的樣子,最好還是保持單純的 dtype。
Series 物件包含兩個主要的屬性:index 和 values,分別為上例中左右兩列。因為傳給構造器的是一個列表,所以 index 的值是從 0 起遞增的整數,如果傳入的是一個類字典的鍵值對結構,就會生成 index-value 對應的 Series;或者在初始化的時候以關鍵字引數顯式指定一個 index 物件:
>>> s = Series(data=[1,3,5,7],index = ['a','b','x','y'])
>>> s
a 1
b 3
x 5
y 7
dtype: int64
>>> s.index
Index(['a', 'b', 'x', 'y'], dtype='object')
>>> s.values
array([1, 3, 5, 7], dtype=int64)
Series 物件的元素會嚴格依照給出的 index 構建,這意味著:如果 data 引數是有鍵值對的,那麼只有 index 中含有的鍵會被使用;以及如果 data 中缺少響應的鍵,即使給出 NaN 值,這個鍵也會被新增。
注意 Series 的 index 和 values 的元素之間雖然存在對應關係,但這與字典的對映不同。index 和 values 實際仍為互相獨立的 ndarray 陣列,因此 Series 物件的效能完全 ok。
Series 這種使用鍵值對的資料結構最大的好處在於,Series 間進行算術運算時,index 會自動對齊。
另外,Series 物件和它的 index 都含有一個 name
屬性:
>>> s.name = 'a_series'
>>> s.index.name = 'the_index'
>>> s
the_index
a 1
b 3
x 5
y 7
Name: a_series, dtype: int64
DataFrame
DataFrame 是一個表格型的資料結構,它含有一組有序的列(類似於 index),每列可以是不同的值型別(不像 ndarray 只能有一個 dtype)。基本上可以把 DataFrame 看成是共享同一個 index 的 Series 的集合。
DataFrame 的構造方法與 Series 類似,只不過可以同時接受多條一維資料來源,每一條都會成為單獨的一列:
>>> data = {'state':['Ohino','Ohino','Ohino','Nevada','Nevada'],
'year':[2000,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9]}
>>> df = DataFrame(data)
>>> df
pop state year
0 1.5 Ohino 2000
1 1.7 Ohino 2001
2 3.6 Ohino 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2002
[5 rows x 3 columns]
雖然引數 data 看起來是個字典,但字典的鍵並非充當 DataFrame 的 index 的角色,而是 Series 的 “name” 屬性。這裡生成的 index 仍是 “01234”。
較完整的 DataFrame 構造器引數為:DataFrame(data=None,index=None,coloumns=None)
,columns
即 “name”:
>>> df = DataFrame(data,index=['one','two','three','four','five'],
columns=['year','state','pop','debt'])
>>> df
year state pop debt
one 2000 Ohino 1.5 NaN
two 2001 Ohino 1.7 NaN
three 2002 Ohino 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
[5 rows x 4 columns]
同樣缺失值由 NaN 補上。看一下 index、columns 和 索引的型別:
>>> df.index
Index(['one', 'two', 'three', 'four', 'five'], dtype='object')
>>> df.columns
Index(['year', 'state', 'pop', 'debt'], dtype='object')
>>> type(df['debt'])
<class 'pandas.core.series.Series'>
DataFrame 面向行和麵向列的操作基本是平衡的,任意抽出一列都是 Series。
物件屬性
重新索引
Series 物件的重新索引通過其 .reindex(index=None,**kwargs)
方法實現。**kwargs
中常用的引數有倆:method=None,fill_value=np.NaN
:
ser = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c'])
>>> a = ['a','b','c','d','e']
>>> ser.reindex(a)
a -5.3
b 7.2
c 3.6
d 4.5
e NaN
dtype: float64
>>> ser.reindex(a,fill_value=0)
a -5.3
b 7.2
c 3.6
d 4.5
e 0.0
dtype: float64
>>> ser.reindex(a,method='ffill')
a -5.3
b 7.2
c 3.6
d 4.5
e 4.5
dtype: float64
>>> ser.reindex(a,fill_value=0,method='ffill')
a -5.3
b 7.2
c 3.6
d 4.5
e 4.5
dtype: float64
In [1]: from pandas import Series
...: ser3 = Series(['USA','Mexico','Canada'],index = [0,5,10])
...: ranger = range(15)
...: ser3.reindex(ranger,method = 'ffill')
...:
Out[1]:
0 USA
1 USA
2 USA
3 USA
4 USA
5 Mexico
6 Mexico
7 Mexico
8 Mexico
9 Mexico
10 Canada
11 Canada
12 Canada
13 Canada
14 Canada
dtype: object
.reindex()
方法會返回一個新物件,其 index 嚴格遵循給出的引數,method:{'backfill',
'bfill', 'pad', 'ffill', None}
引數用於指定插值(填充)方式,當沒有給出時,自動用fill_value
填充,預設為
NaN(ffill = pad,bfill = back fill,分別指插值時向前還是向後取值)
DataFrame 物件的重新索引方法為:.reindex(index=None,columns=None,**kwargs)
。僅比 Series
多了一個可選的 columns 引數,用於給列索引。用法與上例類似,只不過插值方法method
引數只能應用於行,即軸
0。
>>> state = ['Texas','Utha','California']
>>> df.reindex(columns=state,method='ffill')
Texas Utha California
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8
[3 rows x 3 columns]
>>> df.reindex(index=['a','b','c','d'],columns=state,method='ffill')
Texas Utha California
a 1 NaN 2
b 1 NaN 2
c 4 NaN 5
d 7 NaN 8
[4 rows x 3 columns]
不過 fill_value
依然對有效。聰明的小夥伴可能已經想到了,可不可以通過df.T.reindex(index,method='**').T
這樣的方式來實現在列上的插值呢,答案是可行的。另外要注意,使用 reindex(index,method='**')
的時候,index
必須是單調的,否則就會引發一個ValueError: Must be monotonic
for forward fill
,比如上例中的最後一次呼叫,如果使用index=['a','b','d','c']
的話就不行。
刪除指定軸上的項
即刪除 Series 的元素或 DataFrame 的某一行(列)的意思,通過物件的 .drop(labels, axis=0)
方法:
>>> ser
d 4.5
b 7.2
a -5.3
c 3.6
dtype: float64
>>> df
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8
[3 rows x 3 columns]
>>> ser.drop('c')
d 4.5
b 7.2
a -5.3
dtype: float64
>>> df.drop('a')
Ohio Texas California
c 3 4 5
d 6 7 8
[2 rows x 3 columns]
>>> df.drop(['Ohio','Texas'],axis=1)
California
a 2
c 5
d 8
[3 rows x 1 columns]
.drop()
返回的是一個新物件,元物件不會被改變。
索引和切片
就像 Numpy,pandas 也支援通過 obj[::]
的方式進行索引和切片,以及通過布林型陣列進行過濾。
不過須要注意,因為 pandas 物件的 index 不限於整數,所以當使用非整數作為切片索引時,它是末端包含的。
>>> foo
a 4.5
b 7.2
c -5.3
d 3.6
dtype: float64
>>> bar
0 4.5
1 7.2
2 -5.3
3 3.6
dtype: float64
>>> foo[:2]
a 4.5
b 7.2
dtype: float64
>>> bar[:2]
0 4.5
1 7.2
dtype: float64
>>> foo[:'c']
a 4.5
b 7.2
c -5.3
dtype: float64
這裡 foo 和 bar 只有 index 不同——bar 的 index 是整數序列。可見當使用整數索引切片時,結果與 Python 列表或 Numpy 的預設狀況相同;換成 'c'
這樣的字串索引時,結果就包含了這個邊界元素。
另外一個特別之處在於 DataFrame 物件的索引方式,因為他有兩個軸向(雙重索引)。
可以這麼理解:DataFrame 物件的標準切片語法為:.ix[::,::]
。ix 物件可以接受兩套切片,分別為行(axis=0)和列(axis=1)的方向:
>>> df
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8
[3 rows x 3 columns]
>>> df.ix[:2,:2]
Ohio Texas
a 0 1
c 3 4
[2 rows x 2 columns]
>>> df.ix['a','Ohio']
0
而不使用 ix ,直接切的情況就特殊了:
- 索引時,選取的是列
- 切片時,選取的是行
這看起來有點不合邏輯,但作者解釋說 “這種語法設定來源於實踐”,我們信他。
>>> df['Ohio']
a 0
c 3
d 6
Name: Ohio, dtype: int32
>>> df[:'c']
Ohio Texas California
a 0 1 2
c 3 4 5
[2 rows x 3 columns]
>>> df[:2]
Ohio Texas California
a 0 1 2
c 3 4 5
[2 rows x 3 columns]
使用布林型陣列的情況,注意行與列的不同切法(列切法的 :
不能省):
>>> df['Texas']>=4
a False
c True
d True
Name: Texas, dtype: bool
>>> df[df['Texas']>=4]
Ohio Texas California
c 3 4 5
d 6 7 8
[2 rows x 3 columns]
>>> df.ix[:,df.ix['c']>=4]
Texas California
a 1 2
c 4 5
d 7 8
[3 rows x 2 columns]
[python] view
plain copy
print?
- import numpy as np
- import pandas as pd
- df = pd.DataFrame(np.arange(0,60,2).reshape(10,3),columns=list('abc'))
那麼這三種選取資料的方式該怎麼選擇呢?
一、當每列已有column name時,用 df [ 'a' ] 就能選取出一整列資料。如果你知道column names 和index,且兩者都很好輸入,可以選擇 .loc
[python] view plain copy print?- df.loc[0, 'a']
- df.loc[0:3, ['a', 'b']]
- df.loc[[1, 5], ['b', 'c']]
二、如果我們嫌column name太長了,輸入不方便,有或者index是一列時間序列,更不好輸入,那就可以選擇 .iloc了。這邊的 i 我覺得代表index,比較好記點。
[python] view plain copy print?- df.iloc[1,1]
- df.iloc[0:3, [0,1]]
- df.iloc[[0, 3, 5], 0:2]
算術運算和資料對齊
pandas 最重要的一個功能是,它可以對不同索引的物件進行算術運算。在將物件相加時,結果的索引取索引對的並集。自動的資料對齊在不重疊的索引處引入空值,預設為 NaN。
>>> foo = Series({'a':1,'b':2})
>>> foo
a 1
b 2
dtype: int64
>>> bar = Series({'b':3,'d':4})
>>> bar
b 3
d 4
dtype: int64
>>> foo + bar
a NaN
b 5
d NaN
dtype: float64
DataFrame 的對齊操作會同時發生在行和列上。
當不希望在運算結果中出現 NA 值時,可以使用前面 reindex 中提到過 fill_value
引數,不過為了傳遞這個引數,就需要使用物件的方法,而不是操作符:df1.add(df2,fill_value=0)
。其他算術方法還有:sub(),
div(), mul()
。
Series 和 DataFrame 之間的算術運算涉及廣播,暫時先不講。
函式應用和對映
Numpy 的 ufuncs(元素級陣列方法)也可用於操作 pandas 物件。
當希望將函式應用到 DataFrame 物件的某一行或列時,可以使用 .apply(func, axis=0, args=(), **kwds)
方法。
f = lambda x:x.max()-x.min()
>>> df
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8
[3 rows x 3 columns]
>>> df.apply(f)
Ohio 6
Texas 6
California 6
dtype: int64
>>> df.apply(f,axis=1)
a 2
c 2
d 2
dtype: int64
排序和排名
Series 的 sort_index(ascending=True)
方法可以對 index 進行排序操作,ascending 引數用於控制升序或降序,預設為升序。
若要按值對 Series 進行排序,當使用 .order()
方法,任何缺失值預設都會被放到 Series 的末尾。
在 DataFrame 上,.sort_index(axis=0, by=None, ascending=True)
方法多了一個軸向的選擇引數與一個
by 引數,by 引數的作用是針對某一(些)列進行排序(不能對行使用 by 引數):
>>> df.sort_index(by='Ohio')
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8
[3 rows x 3 columns]
>>> df.sort_index(by=['California','Texas'])
Ohio Texas California
a 0 1 2
c 3 4 5
d 6 7 8
[3 rows x 3 columns]
>>> df.sort_index(axis=1)
California Ohio Texas
a 2 0 1
c 5 3 4
d 8 6 7
[3 rows x 3 columns]
排名(Series.rank(method='average', ascending=True)
)的作用與排序的不同之處在於,他會把物件的 values
替換成名次(從 1 到 n)。這時唯一的問題在於如何處理平級項,方法裡的method
引數就是起這個作用的,他有四個值可選:average,
min, max, first
。
>>> ser=Series([3,2,0,3],index=list('abcd'))
>>> ser
a 3
b 2
c 0
d 3
dtype: int64
>>> ser.rank()
a 3.5
b 2.0
c 1.0
d 3.5
dtype: float64
>>> ser.rank(method='min')
a 3
b 2
c 1
d 3
dtype: float64
>>> ser.rank(method='max')
a 4
b 2
c 1
d 4
dtype: float64
>>> ser.rank(method='first')
a 3
b 2
c 1
d 4
dtype: float64
注意在 ser[0]=ser[3] 這對平級項上,不同 method 引數表現出的不同名次。
DataFrame 的 .rank(axis=0, method='average', ascending=True)
方法多了個 axis 引數,可選擇按行或列分別進行排名,暫時好像沒有針對全部元素的排名方法。
統計方法
pandas 物件有一些統計方法。它們大部分都屬於約簡和彙總統計,用於從 Series 中提取單個值,或從 DataFrame 的行或列中提取一個 Series。
比如 DataFrame.mean(axis=0,skipna=True)
方法,當資料集中存在 NA 值時,這些值會被簡單跳過,除非整個切片(行或列)全是
NA,如果不想這樣,則可以通過 skipna=False
來禁用此功能:
>>> df
one two
a 1.40 NaN
b 7.10 -4.5
c NaN NaN
d 0.75 -1.3
[4 rows x 2 columns]
>>> df.mean()
one 3.083333
two -2.900000
dtype: float64
>>> df.mean(axis=1)
a 1.400
b 1.300
c NaN
d -0.275
dtype: float64
>>> df.mean(axis=1,skipna=False)
a NaN
b 1.300
c NaN
d -0.275
dtype: float64
其他常用的統計方法有:
######################## | ****************************************** |
count | 非 NA 值的數量 |
describe | 針對 Series 或 DF 的列計算彙總統計 |
min , max | 最小值和最大值 |
argmin , argmax | 最小值和最大值的索引位置(整數) |
idxmin , idxmax | 最小值和最大值的索引值 |
quantile | 樣本分位數(0 到 1) |
sum | 求和 |
mean | 均值 |
median | 中位數 |
mad | 根據均值計算平均絕對離差 |
var | 方差 |
std | 標準差 |
skew | 樣本值的偏度(三階矩) |
kurt | 樣本值的峰度(四階矩) |
cumsum | 樣本值的累計和 |
cummin , cummax | 樣本值的累計最大值和累計最小值 |
cumprod | 樣本值的累計積 |
diff | 計算一階差分(對時間序列很有用) |
pct_change | 計算百分數變化 |
處理缺失資料
pandas 中 NA 的主要表現為 np.nan,另外 Python 內建的 None 也會被當做 NA 處理。
處理 NA 的方法有四種:dropna , fillna , isnull , notnull
。
is(not)null
這一對方法對物件做元素級應用,然後返回一個布林型陣列,一般可用於布林型索引。
dropna
對於一個 Series,dropna 返回一個僅含非空資料和索引值的 Series。
問題在於對 DataFrame 的處理方式,因為一旦 drop 的話,至少要丟掉一行(列)。這裡的解決方式與前面類似,還是通過一個額外的引數:dropna(axis=0,
how='any', thresh=None)
,how 引數可選的值為 any 或者 all。all 僅在切片元素全為 NA 時才拋棄該行(列)。另外一個有趣的引數是 thresh,該引數的型別為整數,它的作用是,比如 thresh=3,會在一行中至少有 3 個非 NA 值時將其保留。
fillna
fillna(value=None, method=None, axis=0)
中的 value 引數除了基本型別外,還可以使用字典,這樣可以實現對不同的列填充不同的值。method
的用法與前面 .reindex()
方法相同,這裡不再贅述。
inplace 引數
前面有個點一直沒講,結果整篇示例寫下來發現還挺重要的。就是 Series 和 DataFrame 物件的方法中,凡是會對陣列作出修改並返回一個新陣列的,往往都有一個 replace=False
的可選引數。如果手動設定為
True,那麼原陣列就可以被替換。
2.4 dataframe型別轉換-----------------------------------------------------------------------
df.astype(int)
2.5 dataframe和Series的資料結構構建--------------------------------------------------------------
只規定一維的話,預設將每個維度看作一column,可以在index對另一個維度的索引進行規定(當然如果對column排序有要求,也可以按照column進行重排序reindex操作)
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002],
'pop': [1.5, 1.7, 3.6, NaN, 2.9]}
frame = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four', 'five'])
請注意這種建立方法,字典的key值一定是frame的列索引column index
如果是二維字典的話,那麼將最外層的規定為columnID,內層的為rowID
data = {'state': {1:'Ohio', 2:'Ohio', 3:'Ohio', 4:'Nevada', 5:'Nevada'},
'year': {1:2000, 2:2001, 3:2002, 4:2001, 5:2002},
'pop': {1:1.5, 2:1.7, 3:3.6, 4:2.4, 5:2.9}}
frame = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four', 'five'])
外層字典的鍵是列索引,內層鍵是row索引
如果一維都不規定,那麼則將data看作np.array物件,而在index和columns函式中對rowID和columns分別進行規定
dataframe和Series的歸根的結構特徵
pd.Series({'a':2,'b':1,'c':3,'d':54,'e':3})
pd.Series([2,1,3,54,3],index=['a','b','c','d','e'])
dataframe(Series(),index=[],columns=[])
除卻值外
dataframe有兩個維度
Series只有一個維度
2.6 dataframe索引index------------------------------------------
幾種index索引種類
Index
Int64Index
MultiIndex
DatatimeIndex
PeriodIndex
df.columns和df.index 都是一種索引
reindex重索引
df.reindex(['e','d','c','b','a']) #按照這個索引進行重新排序
df.reindex(['e','d','c','b','a'],method='ffill') #沒有這個索引的,自動根據前個索引的值進行填充
df.reindex(['e','d','c','b','a'],fill_value=0) #沒有這個索引的,自動賦值為0
2.7 dataframe函式操作---------------------------------------------
元組能夠操作的函式,在dataframe裡一樣能夠操作
f=lambda x:x.max()-x.min()
df.apply(f)
f=lambda x:'%.2f' %x
df.apply(f)
排序操作-------------------------------------
dataframe可以按照index和columns兩種索引對dataframe進行排序
sort_index()按照索引排序
df.sort_index() #按照rowID進行排序,預設升序
df.sore_index(axis=1,ascending=False) #按照columnID進行排序,設定為降序
order()按照值排序
dataframe的按值排序,其實是按照某列,或者聯合多列中的大小值給所有的row排序
也就是說以某個列的值,代表各個row之間的值進行排序
df.order(by=['a'])
df.order(by=['a','b'])
rank排序
df.rank() 預設在各個column裡面進行排序
df.rank(axis=1)預設在各個row裡面進行排序
彙總操作-------------------------------------
df
one two
a 1.4 NaN
b 7.1 -4.5
c NaN NaN
d 0.74 -1.3
df.sum()按照列進行加和,計算各個column的和
df.sum(axis=1) #跟matlab和Octave一樣
df.mean() #和sum一樣原理
df.idxmax() 會返回各個列索引內最大的值
output: one b
two d
df.idxmin() 會返回各個列索引內最小的值
output: a
two d
相關係數操作-------------------------------------
兩個series協方差
s1.corr(s2)相關係數
s1.cov(s2)協方差
dataframe的協方差和相關係數,計算的就是兩個或多個column之間的相關引數
df.corr()協方差
df.cov()相關係數
df.corr(df['a'])計算所有列和某個列的相關係數
唯一性操作-------------------------------------
s1.unique()
pd.value_count(s1,sort=False) #進行map-reduce運算
df.apply(pd.value_counts,fillna(0)) #也是對各個列進行操作,然後沒有出現的key的次數賦值為0
2.8 dataframe和series的對齊操作align-----------------------------------------------
dataframe之間加和對齊
是二維的操作,在row和col上都有對齊操作,沒有重疊的項都為NaN
series之間的加和對齊
是一維的操作,對於菲重疊的index項,也賦值為NaN
dataframe和series的加和操作
s=pd.DataFrame(np.arange(9).reshape(3,3),index=['New York','beijing', 'Tian Jin'],columns=['b','d','e'] )
series2=pd.Series(range(3),index=['b','e','f'])
因為dataframe是二維的,而Series是一維的物件,那麼二維和一維操作如何運算呢?
我們預設將Series看作一個row行物件,然後dataframe有多少個行,那麼我們就複製多少個值為Series的row物件,然後跟dataframe進行相減運算。
沒有重疊的列column的時候,就按NaN處置。
3 清理資料-------------------------------------------------------------------
df[df.isnull()]
df[df.notnull()]
df.dropna()將所有含有nan項的row刪除
df.dropna(axis=1,thresh=3) 將在列的方向上三個為NaN的項刪除
df.dropna(how='ALL')將全部項都是nan的row刪除
填充值
df.fillna(0)
df.fillna({1:0,2:0.5}) 對第一列nan值賦0,第二列賦值0.5
df.fillna(method='ffill') 在列方向上以前一個值作為值賦給NaN
4 一些定式發現-------------------------------------------------------------------------------------------
預設是以column為單位進行操作
比如pd.dataframe(data) pd.dataframe(dict)
比如df.rank()
比如pd.sort_index()
比如df.sum()
都需要設定axis=1或者指定index才能夠進行亞row級別的操作
也就是說我們認知的時候,先認知的是column欄位,然後是各個row
兩級訪問元素
s['a',2]
s[:,2]
df=s.unstack()
s=df.stack()
來源:https://sanwen8.cn/p/2241oUa.html
shift函式是對資料進行移動的操作,假如現在有一個DataFrame資料df,如下所示:
index | value1 |
---|---|
A | 0 |
B | 1 |
C | 2 |
D | 3 |
那麼如果執行以下程式碼:
df.shift()
就會變成如下:
index | value1 |
---|---|
A | NaN |
B | 0 |
C | 1 |
D | 2 |
看一下函式原型:
DataFrame.shift(periods=1, freq=None, axis=0)
引數
- periods:型別為int,表示移動的幅度,可以是正數,也可以是負數,預設值是1,1就表示移動一次,注意這裡移動的都是資料,而索引是不移動的,移動之後沒有對應值的,就賦值為NaN。
執行以下程式碼:
df.shift(2)
就會得到:
index | value1 |
---|---|
A | NaN |
B | NaN |
C | 0 |
D | 1 |
執行:
df.shift(-1)
會得到:
index | value1 |
---|---|
A | 1 |
B | 2 |
C | 3 |
D | NaN |
- freq: DateOffset, timedelta, or time rule string,可選引數,預設值為None,只適用於時間序列,如果這個引