合并數(shù)據(jù)集

• pandas.merge 可根據(jù)一個或多個鍵將不同 DataFrame 中的行連接起來。
• pandas.concat 可以沿著一條軸將多個對象堆疊到一起
• 實例方法 combine_first 可以用一個對象中的值填充另一個對象中對應(yīng)位置的缺失值

使用鍵參數(shù)的 DataFrame 合并

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True) 用于通過一個或多個鍵將兩個數(shù)據(jù)集的行連接起來，類似于 SQL 中的 JOIN。該函數(shù)的典型應(yīng)用場景是，針對同一個主鍵存在兩張包含不同字段的表，現(xiàn)在我們想把他們整合到一張表里。在此典型情況下，結(jié)果集的行數(shù)并沒有增加，列數(shù)則為兩個元數(shù)據(jù)的列數(shù)和減去連接鍵的數(shù)量。

• on=None 用于顯示指定列名（鍵名），如果該列在兩個對象上的列名不同，則可以通過 left_on=None, right_on=None 來分別指定?；蛘呦胫苯邮褂眯兴饕鳛檫B接鍵的話，就將 left_index=False, right_index=False 設(shè)為 True。

• how='inner' 參數(shù)指的是當(dāng)左右兩個對象中存在不重合的鍵時，取結(jié)果的方式：inner 代表交集；outer 代表并集；left 和 right 分別為取一邊。

• suffixes=('_x','_y') 指的是當(dāng)左右對象中存在除連接鍵外的同名列時，結(jié)果集中的區(qū)分方式，可以各加一個小尾巴。

• 對于多對多連接，結(jié)果采用的是行的笛卡爾積。

示例：

>>> df1 = DataFrame({'key':['a','a','b','b'],'data1':range(4)})>>> df2 = DataFrame({'key':['b','b','c','c'],'data2':range(4)})>>> pd.merge(df1,df2)   data1 key  data20      2   b      01      2   b      12      3   b      03      3   b      1[4 rows x 3 columns]>>> pd.merge(df1,df2,how='left')   data1 key  data20      0   a    NaN1      1   a    NaN2      2   b      03      2   b      14      3   b      05      3   b      1[6 rows x 3 columns]>>> pd.merge(df1,df2,left_index=True,right_index=True)   data1 key_x  data2 key_y0      0     a      0     b1      1     a      1     b2      2     b      2     c3      3     b      3     c[4 rows x 4 columns]

DataFrame 還有一個方法：.join(self, other, on=None, how='left', lsuffix='', rsuffix='', sort=False)，它能更方便地實現(xiàn)按索引合并。它還可以用于合并多個帶有相同或相似索引的 DataFrame 對象，而不管他們之間有沒有重疊的列。值得注意的是它的參數(shù)里 lsuffix='' , rsuffix='' 并沒有給出默認值，所以當(dāng)你的對象中有列重疊（columns overlap）時需要顯示指定 suffix 參數(shù)，否則會報 ValueError：

>>> df1.join(df2,rsuffix='_2')   data1 key  data2 key_20      0   a      0     b1      1   a      1     b2      2   b      2     c3      3   b      3     c[4 rows x 4 columns]

軸向連接

merge 算是一種整合的話，軸向連接 pd.concat() 就是單純地把兩個表拼在一起，這個過程也被稱作連接（concatenation）、綁定（binding）或堆疊（stacking）。

因此可以想見，這個函數(shù)的關(guān)鍵參數(shù)應(yīng)該是 axis，用于指定連接的軸向。在默認的 axis=0 情況下，pd.concat([obj1,obj2]) 函數(shù)的效果與 obj1.append(obj2) 是相同的；而在 axis=1 的情況下，pd.concat([df1,df2],axis=1) 的效果與 pd.merge(df1,df2,left_index=True,right_index=True,how='outer') 是相同的。可以理解為 concat 函數(shù)使用索引作為“連接鍵”。

本函數(shù)的全部參數(shù)為：pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False)。

• objs 就是需要連接的對象集合，一般是列表或字典；axis=0 是連接軸向

• join='outer' 參數(shù)作用于當(dāng)另一條軸的 index 不重疊的時候，只有 'inner' 和 'outer' 可選（順帶展示 ignore_index=True 的用法）：

  >>> df1 = DataFrame({'a':range(3),'b':range(3)})>>> df2 = DataFrame({'a':range(4)})>>> pd.concat([df1,df2])   a   b0  0   01  1   12  2   20  0 NaN1  1 NaN2  2 NaN3  3 NaN[7 rows x 2 columns]>>> pd.concat([df1,df2],join='inner',ignore_index=True)   a0  01  12  23  04  15  26  3[7 rows x 1 columns]

• join_axes=None 參數(shù)用于詳細制定其他軸上使用的索引，優(yōu)先級可以覆蓋 join 參數(shù)，join_axes 的類型是一個列表，其中的元素為其他軸的 index 。比如上例兩條命令等價于這樣：pd.concat([df1,df2],join_axes=[['a','b']]) 、 pd.concat([df1,df2],join_axes=[['a']])

• keys=None 參數(shù)的作用是在結(jié)果集中對源數(shù)據(jù)進行區(qū)分。前例中可以看到，結(jié)果集中的項無法區(qū)分來源，因此使用一個列表型的 keys 參數(shù)可以在連接軸上創(chuàng)建一個層次化索引；另一個隱式使用 keys 參數(shù)的方法是傳入 objs 參數(shù)時使用字典，字典的鍵就會被當(dāng)做 keys。

  >>> s1a    0b    1dtype: int64>>> s2c    2d    3e    4dtype: int64>>> pd.concat([s1,s2],keys=['one','two'])one  a    0     b    1two  c    2     d    3     e    4dtype: int64>>> pd.concat({'one':s1,'two':s2})one  a    0     b    1two  c    2     d    3     e    4dtype: int64

• levels=None 和 names=None 參數(shù)與 keys 參數(shù)有關(guān)，這里 pass；verify_integrity=False 參數(shù)用于檢查結(jié)果對象新連接軸上的索引是否有重復(fù)項，有的話引發(fā) ValueError，可以看到這個參數(shù)的作用與 ignore_index 是互斥的。

合并重疊數(shù)據(jù)

obj.combine_first(other) 方法的作用是使用 other 中的數(shù)據(jù)去填補 obj 中的 NA 值，就像打補丁。而且可以自動對齊。

>>> s1 = Series(range(5))>>> s2 = Series(range(1,5),index=range(1,5))>>> s1[2] = np.nan#設(shè)置一個 NA>>> s10     01     12   NaN3     34     4dtype: float64>>> s21    12    23    34    4dtype: int32>>> s1.combine_first(s2)0    01    12    23    34    4dtype: float64

重塑和軸向旋轉(zhuǎn)

有許多用于重新排列表格數(shù)據(jù)的基礎(chǔ)運算。這些函數(shù)稱為重塑（reshape）或軸向旋轉(zhuǎn)（pivot）運算。

重塑層次化索引

層次化索引為 DataFrame 數(shù)據(jù)的重排任務(wù)提供了一種具有良好一致性的方式。重塑層次化索引通過以下兩個方法完成：

• .stack() 將列 “壓縮” 為行的下級層次化索引
• .unstack() stack 的逆操作——將層次化的行索引 “展開” 為列

示例：

>>> hdf           opening  closingsh 600000        0        1   600001        2        3sz 000001        4        5   000002        6        7[4 rows x 2 columns]>>> hdf.unstack()    opening                          closing                             000001  000002  600000  600001   000001  000002  600000  600001sh      NaN     NaN       0       2      NaN     NaN       1       3sz        4       6     NaN     NaN        5       7     NaN     NaN[2 rows x 8 columns]>>> hdf.stack()sh  600000  opening    0            closing    1    600001  opening    2            closing    3sz  000001  opening    4            closing    5    000002  opening    6            closing    7dtype: int32

可見，如果是普通的多列 DataFrame ，調(diào)用一次 stack 后就會變成 Series 了。

默認情況下，unstack 操作的是最內(nèi)層（stack 亦如此）。傳入分層級別的編號或 name 即可對其他級別進行操作。

>>> hdf.unstack(0)#展開外層        opening      closing                 sh  sz       sh  sz000001      NaN   4      NaN   5000002      NaN   6      NaN   7600000        0 NaN        1 NaN600001        2 NaN        3 NaN[4 rows x 4 columns]>>> hdf.index.names=['Exchange','code']#分層命名>>> hdf.unstack('Exchange')          opening      closing    Exchange       sh  sz       sh  szcode                              000001        NaN   4      NaN   5000002        NaN   6      NaN   7600000          0 NaN        1 NaN600001          2 NaN        3 NaN[4 rows x 4 columns]>>> hdf.unstack('code')          opening                          closing                        code       000001  000002  600000  600001   000001  000002  600000  600001Exchange                                                                  sh            NaN     NaN       0       2      NaN     NaN       1       3sz              4       6     NaN     NaN        5       7     NaN     NaN[2 rows x 8 columns]

將 “長格式” 轉(zhuǎn)換為 “寬格式”

時間序列數(shù)據(jù)通常都是以所謂的 “長格式”（long） 或 “堆疊格式”（stacked）存儲在數(shù)據(jù)庫或 CSV 中的：

>>> ldata          date     item     value0   1959-03-31  realgdp  2710.3491   1959-03-31     infl     0.0002   1959-03-31    unemp     5.8003   1959-06-30  realgdp  2778.8014   1959-06-30     infl     2.3405   1959-06-30    unemp     5.1006   1959-09-30  realgdp  2775.4887   1959-09-30     infl     2.7408   1959-09-30    unemp     5.3009   1959-12-31  realgdp  2785.20410  1959-12-31     infl     0.27011  1959-12-31    unemp     5.600[12 rows x 3 columns]

這個 item 其實只包含三個字段——realgdp、infl 和 unemp，但每一個字段都單獨存儲為一行。這樣做的好處是在數(shù)據(jù)庫中維護了一個動態(tài)的 item 字段，以后如果 item 的項有增刪的話，也不必改變表結(jié)構(gòu)。但這種做法的冗余信息過多，而且操作起來很麻煩，需要額外輸入很多命令，因此在處理數(shù)據(jù)前先將其 “展開” 為 “寬格式” 就顯得很有必要。

這項任務(wù)其實在上一節(jié)中就已經(jīng)給出了解決方法，不過本節(jié)要介紹的是一種 “快捷方式”——obj.pivot(index=None, columns=None, values=None) 方法。三個參數(shù)都應(yīng)是來自 obj 的列名，或列對象。分別用于指定結(jié)果對象的 index、columns 和 values 屬性。

>>> ldata.pivot('date','item','value')item        infl   realgdp  unempdate                             1959-03-31  0.00  2710.349    5.81959-06-30  2.34  2778.801    5.11959-09-30  2.74  2775.488    5.31959-12-31  0.27  2785.204    5.6[4 rows x 3 columns]

數(shù)據(jù)轉(zhuǎn)換

除了前面介紹的數(shù)據(jù)重排外，另一種重要操作是過濾、清理以及其他的轉(zhuǎn)換工作

移除重復(fù)數(shù)據(jù)

移除重復(fù)數(shù)據(jù)操作有兩個方法可用

• obj.duplicated() 本方法返回一個布爾型 Series，將重復(fù)的行標(biāo)記為 True
• obj.drop_duplicates() 本方法直接返回一個去除了重復(fù)行的新對象

這兩個方法默認都會檢查所有的列，如果想僅針對某一（些）列進行檢查的話，可以傳入 cols 參數(shù)，指定需要檢查的列。

方法默認將第一個出現(xiàn)的值保留，還有一個 take_last=False 參數(shù)，可將其改為 True 以保留最后的值。

利用函數(shù)或映射進行數(shù)據(jù)轉(zhuǎn)換

Series 或 DataFrame 的列都可以調(diào)用一個 .map() 方法。該方法接受一個函數(shù)或字典作為參數(shù)，并將之應(yīng)用于對象的每一個元素，最后返回一個包含所有結(jié)果的 Series。

>>> ser = Series(range(5))>>> ser0    01    12    23    34    4dtype: int32>>> ser.map(str).map(lambda x:x+'!')0    0!1    1!2    2!3    3!4    4!dtype: object>>> ser.map(lambda x:str(x)+'!')0    0!1    1!2    2!3    3!4    4!dtype: object

一個例子寫了兩遍是為了展示 map 方法的嵌套用法。

替換值

fillna 方法填充缺失值可以看做值替換的一種特殊情況，map也可以用來修改對象的數(shù)據(jù)子集，而 .replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad', axis=None) 方法則提供了實現(xiàn)該功能的一種更簡單、更靈活的方式。

to_replace 參數(shù)可以是：str, regex, list, dict, Series, numeric, or None；value 參數(shù)可以是：scalar, dict, list, str, regex, default None。其他參數(shù)的特殊用法請使用 help 查看。

>>> ser.replace([1,2],'x')0    01    x2    x3    34    4dtype: object

重命名軸索引

前面應(yīng)該提到過，pandas 對象的 index 參數(shù)是不可變（immutable）的，即不可以直接對其元素進行賦值操作。但你卻可以對其使用 obj.index.map() 方法。

也可以直接對數(shù)組對象調(diào)用 obj.rename(index=None,columns=None) 方法。這里的 index 和 columns 參數(shù)并不是 index 對象，而是一個函數(shù)或字典：

>>> ldata[:3]         date     item     value0  1959-03-31  realgdp  2710.3491  1959-03-31     infl     0.0002  1959-03-31    unemp     5.800[3 rows x 3 columns]>>> ldata[:3].rename(columns=str.title)         Date     Item     Value0  1959-03-31  realgdp  2710.3491  1959-03-31     infl     0.0002  1959-03-31    unemp     5.800[3 rows x 3 columns]

離散化和面元劃分

為了便于分析，連續(xù)數(shù)據(jù)常常被離散化或拆分為 “面元”（bin）。這個過程要使用到 pandas 的 cut 函數(shù)：

cut(x, bins, right=True, labels=None, retbins=False, precision=3, include_lowest=False)

核心參數(shù)為 x 和 bins，x 為被切對象，應(yīng)當(dāng)是個一維的類數(shù)組結(jié)構(gòu)；bins 參數(shù)可以是序列、整數(shù)或標(biāo)量。

• 序列：按序列的元素間隔劃分 x，返回 x 各個元素的分組情況

  >>> bins = [0,3,6,9]>>> ser = Series(np.random.randint(1,10,6))>>> ser0    51    52    13    44    35    4dtype: int32>>> cats = pd.cut(ser,bins,labels=['small','middle','large'])>>> cats middle middle  small middle  small middleLevels (3): Index(['small', 'middle', 'large'], dtype=object)

• 整數(shù)：以 x 的上下界等長劃分，可用 precision 參數(shù)調(diào)節(jié)精度。

  >>> ser = Series([2,6,7,3,8])>>> pd.cut(ser,3,precision=1) (2, 4] (4, 6] (6, 8] (2, 4] (6, 8]Levels (3): Index(['(2, 4]', '(4, 6]', '(6, 8]'], dtype=object)

right=True 參數(shù)用于控制序列型 bins 的邊界，默認為右包含。labels 參數(shù)可以給 bins 添加代號。

最后我們來看一下 cut 函數(shù)返回的這個對象：

>>> type(cats)>>> cats.labelsarray([1, 1, 0, 1, 0, 1], dtype=int64)>>> cats.levelsIndex(['small', 'middle', 'large'], dtype='object')>>> pd.value_counts(cats)middle    4small     2dtype: int64

Categorical 對象是一個枚舉型的序列對象，它的可選值都顯示在 levels 屬性里。

另一個 pd.qcut() 函數(shù)與 cut 類似，但它可以根據(jù)樣本的分位數(shù)對數(shù)據(jù)進行面元劃分：

>>> ser = np.random.randint(0,100,1000)>>> cats = pd.qcut(ser,10)>>> pd.value_counts(cats)(61, 70]      112(41, 52]      104[0, 9]        104(20.8, 31]    103(77, 88]      102(31, 41]      100(88, 99]       97(9, 20.8]      96(52, 61]       94(70, 77]       88dtype: int64

cut 與 qcut 的更多用法會在數(shù)據(jù)聚合與分組篇中提及。

檢測和過濾異常值

異常值（outlier）的過濾或變換運算在很大程度上就是數(shù)組運算。如下一個 （1000,4）的標(biāo)準(zhǔn)正態(tài)分布數(shù)組

>>> data = DataFrame(np.random.randn(1000,4))>>> data.describe()                 0            1            2            3count  1000.000000  1000.000000  1000.000000  1000.000000mean     -0.002069    -0.004543    -0.019383     0.015766std       1.015236     1.007477     1.036879     0.989083min      -3.344487    -3.305229    -2.980726    -3.57346025%      -0.712828    -0.643239    -0.720927    -0.62815150%       0.019140     0.019844    -0.048479     0.03835175%       0.675520     0.669538     0.714605     0.691746max       3.572161     3.178061     3.114121     3.946495[8 rows x 4 columns]

假設(shè)要找出某一列中絕對值大小超過 3 的項：

>>> col = data[3]>>> col[np.abs(col)>3]385   -3.573460692    3.034318763    3.946495Name: 3, dtype: float64

要選出全部含有 “絕對值超過 3 的值” 的行，可以利用布爾型索引和 any 方法：

>>> data[(np.abs(data)>3).any(1)]            0         1         2         3122  0.989242 -0.458811  3.114121  1.562819215  3.572161  0.187996 -0.687865  1.378730216  3.265406 -0.263109  0.682896 -0.637152381 -3.344487 -0.622073  1.107529 -0.196075385 -2.111132 -0.863913 -1.103775 -3.573460426  0.210532 -3.208607  1.092182 -0.255276452  3.203703 -0.992268 -1.396385 -2.701209457 -1.361164  3.178061 -0.115614  0.709487692  0.578040  1.480447 -1.927734  3.034318763 -1.481627  1.136522  0.283987  3.946495920  1.901519 -3.305229 -0.220002 -0.333692[11 rows x 4 columns]

以下命令會將 data 的值全部限制在 [-3,3] 之間，通過將異常值替換為 -3 和 3 的方式。

>>> data[np.abs(data)>3] = np.sign(data)*3>>> data.describe()                 0            1            2            3count  1000.000000  1000.000000  1000.000000  1000.000000mean     -0.002766    -0.004207    -0.019497     0.015359std       1.010851     1.005330     1.036540     0.983736min      -3.000000    -3.000000    -2.980726    -3.000000  #!25%      -0.712828    -0.643239    -0.720927    -0.62815150%       0.019140     0.019844    -0.048479     0.03835175%       0.675520     0.669538     0.714605     0.691746max       3.000000     3.000000     3.000000     3.000000  #![8 rows x 4 columns]

np.sign() 函數(shù)可以返回一個由 -1 和 1 組成的數(shù)組，表示原始值的符號。

隨機采樣

隨機采樣的基本思路是：先利用 np.random 模塊隨機生成一個需要的索引，然后利用這個索引去源數(shù)據(jù)里過濾取值。隨機采樣的兩個常用函數(shù)為

• np.random.randint(start, end, size) 這個函數(shù)一般用于實現(xiàn) “可重取” 的隨機采樣，因為返回的數(shù)組中的元素可重復(fù)，而且 size 可變

  >>> bag = np.array([5,7,-1,6,4])>>> sampler = np.random.randint(0,len(bag),size=10)>>> bag.take(sampler)array([5, 5, 7, 5, 7, 5, 6, 7, 7, 4])>>> bag[sampler]array([5, 5, 7, 5, 7, 5, 6, 7, 7, 4])

• np.random.permutation(x) 函數(shù)用于隨機排列一個序列類型。x 參數(shù)接受整數(shù)或類序列類型，實際處理過程中都是按序列來處理的——整型 x 會當(dāng)做 range(x) 來處理。本函數(shù)會隨機重排（shuffle）接收到的序列參數(shù)并返回一個新結(jié)果，顯然這是一個 “不可重取” 的抽樣，且 size 最大即為 len(x)。

  >>> df = DataFrame(np.arange(20).reshape(5,4))>>> sampler = np.random.permutation(5)>>> samplerarray([2, 1, 0, 4, 3])>>> df    0   1   2   30   0   1   2   31   4   5   6   72   8   9  10  113  12  13  14  154  16  17  18  19[5 rows x 4 columns]>>> df.reindex(sampler)    0   1   2   32   8   9  10  111   4   5   6   70   0   1   2   34  16  17  18  193  12  13  14  15[5 rows x 4 columns]>>> df.take(sampler)    0   1   2   32   8   9  10  111   4   5   6   70   0   1   2   34  16  17  18  193  12  13  14  15[5 rows x 4 columns]>>> df.ix[sampler]    0   1   2   32   8   9  10  111   4   5   6   70   0   1   2   34  16  17  18  193  12  13  14  15[5 rows x 4 columns]

因為 sampler 是一個數(shù)組類型，所以用它在源數(shù)據(jù)中取值的方式有很多 ↑，如果不想全部取樣的話，給 sampler 加個切片就可以了。

轉(zhuǎn)換指標(biāo)/啞變量

pd.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False) 函數(shù)可用來將分類變量（Categorical variable）轉(zhuǎn)換為 “啞變量矩陣”（dummy matrix）或稱 “指標(biāo)矩陣”（indicator matrix）。更加便捷的是，data 參數(shù)并不限于 categorical 類型，而是可以直接使用一個類 Series 對象，比如 DataFrame 的列。本函數(shù)返回的是一個以 data 元素為列名的 1、0 矩陣。

>>> ser = Series(['b','b','a','c','a','b'],name='key')>>> ser0    b1    b2    a3    c4    a5    bName: key, dtype: object>>> pd.get_dummies(ser)   a  b  c0  0  1  01  0  1  02  1  0  03  0  0  14  1  0  05  0  1  0[6 rows x 3 columns]

將本函數(shù)直接應(yīng)用于 DataFrame 的列上，再與原數(shù)據(jù)剩余部分連接：

>>> df = DataFrame({'key':['b','b','a','c','a','b'],'value':range(6)})>>> df  key  value0   b      01   b      12   a      23   c      34   a      45   b      5[6 rows x 2 columns]>>> pd.get_dummies(df['key']).join(df['value'])   a  b  c  value0  0  1  0      01  0  1  0      12  1  0  0      23  0  0  1      34  1  0  0      45  0  1  0      5[6 rows x 4 columns]

字符串操作

在對字符串元素進行規(guī)整化操作時，使用 .map() 方法的一個弊端是需要小心繞過 NA 值。為了解決這個問題，Series 直接提供了一些能夠跳過 NA 值的字符串操作方法，全部通過 ser.str.xxx() 來訪問。這些方法一般也都支持正則表達式。

>>> data = Series({'Dave':'dav@google.com','Steve':'steve@gmail.com',               'Rov':'rob@gmail.com','Wes':np.nan})>>> dataDave      dav@google.comRov        rob@gmail.comSteve    steve@gmail.comWes                  NaNdtype: object>>> data.str.contains('gmail')Dave     FalseRov       TrueSteve     TrueWes        NaNdtype: object>>> pattern = '([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\\.([A-Z]{2,4})'>>> import re>>> data.str.findall(pattern,flags=re.IGNORECASE)Dave      [(dav, google, com)]Rov        [(rob, gmail, com)]Steve    [(steve, gmail, com)]Wes                        NaNdtype: object

有兩個辦法可以實現(xiàn)矢量化的元素獲取操作：要么使用 str.get，要么在 str 屬性上使用索引。

>>> matches = data.str.match(pattern,flags=re.IGNORECASE)>>> matches.str.get(1)Dave     googleRov       gmailSteve     gmailWes         NaNdtype: object>>> matches.str[0]Dave       davRov        robSteve    steveWes        NaNdtype: object

其他一些矢量化的字符串方法有：