《利用Python進行數據分析》12章 pandas高級應用

08-16

來自專欄 Python程序員17 人贊了文章

作者：SeanCheney Python愛好者社區--專欄作者
來源：簡書

第1章準備工作
第2章 Python語法基礎，IPython和Jupyter Notebooks
第3章 Python的數據結構、函數和文件
第4章 NumPy基礎：數組和矢量計算第5章 pandas入門

第6章數據載入、存儲與文件格式
第7章數據清洗和準備
第8章數據規整：聚合、合併和重塑
第9章繪圖和可視化
第10章數據聚合與分組運算
第11章時間序列
第12章 pandas高級應用
第13章 Python建模庫介紹
第14章數據分析案例
附錄A NumPy高級應用

附錄B 更多關於IPython的內容（完）

前面的章節關注於不同類型的數據規整流程和NumPy、pandas與其它庫的特點。隨著時間的發展，pandas發展出了更多適合高級用戶的功能。本章就要深入學習pandas的高級功能。

12.1 分類數據

這一節介紹的是pandas的分類類型。我會向你展示通過使用它，提高性能和內存的使用率。我還會介紹一些在統計和機器學習中使用分類數據的工具。

背景和目的

表中的一列通常會有重複的包含不同值的小集合的情況。我們已經學過了unique和value_counts，它們可以從數組提取出不同的值，並分別計算頻率：

In [10]: import numpy as np; import pandas as pdIn [11]: values = pd.Series([apple, orange, apple, ....: apple] * 2)In [12]: valuesOut[12]: 0 apple1 orange2 apple3 apple4 apple5 orange6 apple7 appledtype: objectIn [13]: pd.unique(values)Out[13]: array([apple, orange], dtype=object)In [14]: pd.value_counts(values)Out[14]: apple 6orange 2dtype: int64

許多數據系統（數據倉庫、統計計算或其它應用）都發展出了特定的表徵重複值的方法，以進行高效的存儲和計算。在數據倉庫中，最好的方法是使用所謂的包含不同值得維表(Dimension Table)，將主要的參數存儲為引用維表整數鍵：

In [15]: values = pd.Series([0, 1, 0, 0] * 2)In [16]: dim = pd.Series([apple, orange])In [17]: valuesOut[17]: 0 01 12 03 04 05 16 07 0dtype: int64In [18]: dimOut[18]: 0 apple1 orangedtype: object

可以使用take方法存儲原始的字元串Series：

In [19]: dim.take(values)Out[19]: 0 apple1 orange0 apple0 apple0 apple1 orange0 apple0 appledtype: object

這種用整數表示的方法稱為分類或字典編碼表示法。不同值得數組稱為分類、字典或數據級。本書中，我們使用分類的說法。表示分類的整數值稱為分類編碼或簡單地稱為編碼。

分類表示可以在進行分析時大大的提高性能。你也可以在保持編碼不變的情況下，對分類進行轉換。一些相對簡單的轉變例子包括：

重命名分類。
加入一個新的分類，不改變已經存在的分類的順序或位置。

pandas的分類類型

pandas有一個特殊的分類類型，用於保存使用整數分類表示法的數據。看一個之前的Series例子：

In [20]: fruits = [apple, orange, apple, apple] * 2In [21]: N = len(fruits)In [22]: df = pd.DataFrame({fruit: fruits, ....: basket_id: np.arange(N), ....: count: np.random.randint(3, 15, size=N), ....: weight: np.random.uniform(0, 4, size=N)}, ....: columns=[basket_id, fruit, count, weight])In [23]: dfOut[23]: basket_id fruit count weight0 0 apple 5 3.8580581 1 orange 8 2.6127082 2 apple 4 2.9956273 3 apple 7 2.6142794 4 apple 12 2.9908595 5 orange 8 3.8452276 6 apple 5 0.0335537 7 apple 4 0.425778

這裡，df[fruit]是一個Python字元串對象的數組。我們可以通過調用它，將它轉變為分類：

In [24]: fruit_cat = df[fruit].astype(category)In [25]: fruit_catOut[25]: 0 apple1 orange2 apple3 apple4 apple5 orange6 apple7 appleName: fruit, dtype: categoryCategories (2, object): [apple, orange]

fruit_cat的值不是NumPy數組，而是一個pandas.Categorical實例：

In [26]: c = fruit_cat.valuesIn [27]: type(c)Out[27]: pandas.core.categorical.Categorical

分類對象有categories和codes屬性：

In [28]: c.categoriesOut[28]: Index([apple, orange], dtype=object)In [29]: c.codesOut[29]: array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)

你可將DataFrame的列通過分配轉換結果，轉換為分類：

In [30]: df[fruit] = df[fruit].astype(category)In [31]: df.fruitOut[31]:0 apple1 orange2 apple3 apple4 apple5 orange6 apple7 appleName: fruit, dtype: categoryCategories (2, object): [apple, orange]

你還可以從其它Python序列直接創建pandas.Categorical：

In [32]: my_categories = pd.Categorical([foo, bar, baz, foo, bar])In [33]: my_categoriesOut[33]: [foo, bar, baz, foo, bar]Categories (3, object): [bar, baz, foo]

如果你已經從其它源獲得了分類編碼，你還可以使用from_codes構造器：

In [34]: categories = [foo, bar, baz]In [35]: codes = [0, 1, 2, 0, 0, 1]In [36]: my_cats_2 = pd.Categorical.from_codes(codes, categories)In [37]: my_cats_2Out[37]: [foo, bar, baz, foo, foo, bar]Categories (3, object): [foo, bar, baz]

與顯示指定不同，分類變換不認定指定的分類順序。因此取決於輸入數據的順序，categories數組的順序會不同。當使用from_codes或其它的構造器時，你可以指定分類一個有意義的順序：

In [38]: ordered_cat = pd.Categorical.from_codes(codes, categories, ....: ordered=True)In [39]: ordered_catOut[39]: [foo, bar, baz, foo, foo, bar]Categories (3, object): [foo < bar < baz]

輸出[foo < bar < baz]指明『foo』位於『bar』的前面，以此類推。無序的分類實例可以通過as_ordered排序：

In [40]: my_cats_2.as_ordered()Out[40]: [foo, bar, baz, foo, foo, bar]Categories (3, object): [foo < bar < baz]

最後要注意，分類數據不需要字元串，儘管我僅僅展示了字元串的例子。分類數組可以包括任意不可變類型。

用分類進行計算

與非編碼版本（比如字元串數組）相比，使用pandas的Categorical有些類似。某些pandas組件，比如groupby函數，更適合進行分類。還有一些函數可以使用有序標誌位。

來看一些隨機的數值數據，使用pandas.qcut面元函數。它會返回pandas.Categorical，我們之前使用過pandas.cut，但沒解釋分類是如何工作的：

In [41]: np.random.seed(12345)In [42]: draws = np.random.randn(1000)In [43]: draws[:5]Out[43]: array([-0.2047, 0.4789, -0.5194, -0.5557, 1.9658])

計算這個數據的分位面元，提取一些統計信息：

In [44]: bins = pd.qcut(draws, 4)In [45]: binsOut[45]: [(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63, 3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.95, -0.684], (-0.0101, 0.63], (0.63, 3.928]]Length: 1000Categories (4, interval[float64]): [(-2.95, -0.684] < (-0.684, -0.0101] < (-0.0101, 0.63] < (0.63, 3.928]]

雖然有用，確切的樣本分位數與分位的名稱相比，不利於生成匯總。我們可以使用labels參數qcut，實現目的：

In [46]: bins = pd.qcut(draws, 4, labels=[Q1, Q2, Q3, Q4])In [47]: binsOut[47]: [Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]Length: 1000Categories (4, object): [Q1 < Q2 < Q3 < Q4]In [48]: bins.codes[:10]Out[48]: array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)

加上標籤的面元分類不包含數據面元邊界的信息，因此可以使用groupby提取一些匯總信息：

In [49]: bins = pd.Series(bins, name=quartile)In [50]: results = (pd.Series(draws) ....: .groupby(bins) ....: .agg([count, min, max]) ....: .reset_index())In [51]: resultsOut[51]: quartile count min max0 Q1 250 -2.949343 -0.6854841 Q2 250 -0.683066 -0.0101152 Q3 250 -0.010032 0.6288943 Q4 250 0.634238 3.927528

分位數列保存了原始的面元分類信息，包括排序：

In [52]: results[quartile]Out[52]:0 Q11 Q22 Q33 Q4Name: quartile, dtype: categoryCategories (4, object): [Q1 < Q2 < Q3 < Q4]

用分類提高性能

如果你是在一個特定數據集上做大量分析，將其轉換為分類可以極大地提高效率。DataFrame列的分類使用的內存通常少的多。來看一些包含一千萬元素的Series，和一些不同的分類：

In [53]: N = 10000000In [54]: draws = pd.Series(np.random.randn(N))In [55]: labels = pd.Series([foo, bar, baz, qux] * (N // 4))

現在，將標籤轉換為分類：

In [56]: categories = labels.astype(category)

這時，可以看到標籤使用的內存遠比分類多：

In [57]: labels.memory_usage()Out[57]: 80000080In [58]: categories.memory_usage()Out[58]: 10000272

轉換為分類不是沒有代價的，但這是一次性的代價：

In [59]: %time _ = labels.astype(category)CPU times: user 490 ms, sys: 240 ms, total: 730 msWall time: 726 ms

GroupBy操作明顯比分類快，是因為底層的演算法使用整數編碼數組，而不是字元串數組。

分類方法

包含分類數據的Series有一些特殊的方法，類似於Series.str字元串方法。它還提供了方便的分類和編碼的使用方法。看下面的Series：

In [60]: s = pd.Series([a, b, c, d] * 2)In [61]: cat_s = s.astype(category)In [62]: cat_sOut[62]: 0 a1 b2 c3 d4 a5 b6 c7 ddtype: categoryCategories (4, object): [a, b, c, d]

特別的cat屬性提供了分類方法的入口：

In [63]: cat_s.cat.codesOut[63]: 0 01 12 23 34 05 16 27 3dtype: int8In [64]: cat_s.cat.categoriesOut[64]: Index([a, b, c, d], dtype=object)

假設我們知道這個數據的實際分類集，超出了數據中的四個值。我們可以使用set_categories方法改變它們：

In [65]: actual_categories = [a, b, c, d, e]In [66]: cat_s2 = cat_s.cat.set_categories(actual_categories)In [67]: cat_s2Out[67]: 0 a1 b2 c3 d4 a5 b6 c7 ddtype: categoryCategories (5, object): [a, b, c, d, e]

雖然數據看起來沒變，新的分類將反映在它們的操作中。例如，如果有的話，value_counts表示分類：

In [68]: cat_s.value_counts()Out[68]: d 2c 2b 2a 2dtype: int64In [69]: cat_s2.value_counts()Out[69]: d 2c 2b 2a 2e 0dtype: int64

在打數據集中，分類經常作為節省內存和高性能的便捷工具。過濾完大DataFrame或Series之後，許多分類可能不會出現在數據中。我們可以使用remove_unused_categories方法刪除沒看到的分類：

In [70]: cat_s3 = cat_s[cat_s.isin([a, b])]In [71]: cat_s3Out[71]: 0 a1 b4 a5 bdtype: categoryCategories (4, object): [a, b, c, d]In [72]: cat_s3.cat.remove_unused_categories()Out[72]: 0 a1 b4 a5 bdtype: categoryCategories (2, object): [a, b]

表12-1列出了可用的分類方法。

表12-1 pandas的Series的分類方法

為建模創建虛擬變數

當你使用統計或機器學習工具時，通常會將分類數據轉換為虛擬變數，也稱為one-hot編碼。這包括創建一個不同類別的列的DataFrame；這些列包含給定分類的1s，其它為0。

看前面的例子：

In [73]: cat_s = pd.Series([a, b, c, d] * 2, dtype=category)

前面的第7章提到過，pandas.get_dummies函數可以轉換這個以為分類數據為包含虛擬變數的DataFrame：

In [74]: pd.get_dummies(cat_s)Out[74]: a b c d0 1 0 0 01 0 1 0 02 0 0 1 03 0 0 0 14 1 0 0 05 0 1 0 06 0 0 1 07 0 0 0 1

12.2 GroupBy高級應用

儘管我們在第10章已經深度學習了Series和DataFrame的Groupby方法，還有一些方法也是很有用的。

分組轉換和「解封」GroupBy

在第10章，我們在分組操作中學習了apply方法，進行轉換。還有另一個transform方法，它與apply很像，但是對使用的函數有一定限制：

它可以產生向分組形狀廣播標量值
它可以產生一個和輸入組形狀相同的對象
它不能修改輸入

來看一個簡單的例子：

In [75]: df = pd.DataFrame({key: [a, b, c] * 4, ....: value: np.arange(12.)})In [76]: dfOut[76]: key value0 a 0.01 b 1.02 c 2.03 a 3.04 b 4.05 c 5.06 a 6.07 b 7.08 c 8.09 a 9.010 b 10.011 c 11.0

按鍵進行分組：

In [77]: g = df.groupby(key).valueIn [78]: g.mean()Out[78]: keya 4.5b 5.5c 6.5Name: value, dtype: float64

假設我們想產生一個和df[value]形狀相同的Series，但值替換為按鍵分組的平均值。我們可以傳遞函數lambda x: x.mean()進行轉換：

In [79]: g.transform(lambda x: x.mean())Out[79]: 0 4.51 5.52 6.53 4.54 5.55 6.56 4.57 5.58 6.59 4.510 5.511 6.5Name: value, dtype: float64

對於內置的聚合函數，我們可以傳遞一個字元串假名作為GroupBy的agg方法：

In [80]: g.transform(mean)Out[80]: 0 4.51 5.52 6.53 4.54 5.55 6.56 4.57 5.58 6.59 4.510 5.511 6.5Name: value, dtype: float64

與apply類似，transform的函數會返回Series，但是結果必須與輸入大小相同。舉個例子，我們可以用lambda函數將每個分組乘以2：

In [81]: g.transform(lambda x: x * 2)Out[81]: 0 0.01 2.02 4.03 6.04 8.05 10.06 12.07 14.08 16.09 18.010 20.011 22.0Name: value, dtype: float64

再舉一個複雜的例子，我們可以計算每個分組的降序排名：

In [82]: g.transform(lambda x: x.rank(ascending=False))Out[82]: 0 4.01 4.02 4.03 3.04 3.05 3.06 2.07 2.08 2.09 1.010 1.011 1.0Name: value, dtype: float64

看一個由簡單聚合構造的的分組轉換函數：

def normalize(x): return (x - x.mean()) / x.std()

我們用transform或apply可以獲得等價的結果：

In [84]: g.transform(normalize)Out[84]: 0 -1.1618951 -1.1618952 -1.1618953 -0.3872984 -0.3872985 -0.3872986 0.3872987 0.3872988 0.3872989 1.16189510 1.16189511 1.161895Name: value, dtype: float64In [85]: g.apply(normalize)Out[85]: 0 -1.1618951 -1.1618952 -1.1618953 -0.3872984 -0.3872985 -0.3872986 0.3872987 0.3872988 0.3872989 1.16189510 1.16189511 1.161895Name: value, dtype: float64

內置的聚合函數，比如mean或sum，通常比apply函數快，也比transform快。這允許我們進行一個所謂的解封（unwrapped）分組操作：

In [86]: g.transform(mean)Out[86]: 0 4.51 5.52 6.53 4.54 5.55 6.56 4.57 5.58 6.59 4.510 5.511 6.5Name: value, dtype: float64In [87]: normalized = (df[value] - g.transform(mean)) / g.transform(std)In [88]: normalizedOut[88]: 0 -1.1618951 -1.1618952 -1.1618953 -0.3872984 -0.3872985 -0.3872986 0.3872987 0.3872988 0.3872989 1.16189510 1.16189511 1.161895Name: value, dtype: float64

解封分組操作可能包括多個分組聚合，但是矢量化操作還是會帶來收益。

分組的時間重採樣

對於時間序列數據，resample方法從語義上是一個基於內在時間的分組操作。下面是一個示例表：

In [89]: N = 15In [90]: times = pd.date_range(2017-05-20 00:00, freq=1min, periods=N)In [91]: df = pd.DataFrame({time: times, ....: value: np.arange(N)})In [92]: dfOut[92]: time value0 2017-05-20 00:00:00 01 2017-05-20 00:01:00 12 2017-05-20 00:02:00 23 2017-05-20 00:03:00 34 2017-05-20 00:04:00 45 2017-05-20 00:05:00 56 2017-05-20 00:06:00 67 2017-05-20 00:07:00 78 2017-05-20 00:08:00 89 2017-05-20 00:09:00 910 2017-05-20 00:10:00 1011 2017-05-20 00:11:00 1112 2017-05-20 00:12:00 1213 2017-05-20 00:13:00 1314 2017-05-20 00:14:00 14

這裡，我們可以用time作為索引，然後重採樣：

In [93]: df.set_index(time).resample(5min).count()Out[93]: valuetime 2017-05-20 00:00:00 52017-05-20 00:05:00 52017-05-20 00:10:00 5

假設DataFrame包含多個時間序列，用一個額外的分組鍵的列進行標記：

In [94]: df2 = pd.DataFrame({time: times.repeat(3), ....: key: np.tile([a, b, c], N), ....: value: np.arange(N * 3.)})In [95]: df2[:7]Out[95]: key time value0 a 2017-05-20 00:00:00 0.01 b 2017-05-20 00:00:00 1.02 c 2017-05-20 00:00:00 2.03 a 2017-05-20 00:01:00 3.04 b 2017-05-20 00:01:00 4.05 c 2017-05-20 00:01:00 5.06 a 2017-05-20 00:02:00 6.0

要對每個key值進行相同的重採樣，我們引入pandas.TimeGrouper對象：

In [96]: time_key = pd.TimeGrouper(5min)

我們然後設定時間索引，用key和time_key分組，然後聚合：

In [97]: resampled = (df2.set_index(time) ....: .groupby([key, time_key]) ....: .sum())In [98]: resampledOut[98]: valuekey time a 2017-05-20 00:00:00 30.0 2017-05-20 00:05:00 105.0 2017-05-20 00:10:00 180.0b 2017-05-20 00:00:00 35.0 2017-05-20 00:05:00 110.0 2017-05-20 00:10:00 185.0c 2017-05-20 00:00:00 40.0 2017-05-20 00:05:00 115.0 2017-05-20 00:10:00 190.0In [99]: resampled.reset_index()Out[99]:key time value0 a 2017-05-20 00:00:00 30.01 a 2017-05-20 00:05:00 105.02 a 2017-05-20 00:10:00 180.03 b 2017-05-20 00:00:00 35.04 b 2017-05-20 00:05:00 110.05 b 2017-05-20 00:10:00 185.06 c 2017-05-20 00:00:00 40.07 c 2017-05-20 00:05:00 115.08 c 2017-05-20 00:10:00 190.0

使用TimeGrouper的限制是時間必須是Series或DataFrame的索引。

12.3 鏈式編程技術

當對數據集進行一系列變換時，你可能發現創建的多個臨時變數其實並沒有在分析中用到。看下面的例子：

df = load_data()df2 = df[df[col2] < 0]df2[col1_demeaned] = df2[col1] - df2[col1].mean()result = df2.groupby(key).col1_demeaned.std()

雖然這裡沒有使用真實的數據，這個例子卻指出了一些新方法。首先，DataFrame.assign方法是一個df[k] = v形式的函數式的列分配方法。它不是就地修改對象，而是返回新的修改過的DataFrame。因此，下面的語句是等價的：

# Usual non-functional waydf2 = df.copy()df2[k] = v# Functional assign waydf2 = df.assign(k=v)

就地分配可能會比assign快，但是assign可以方便地進行鏈式編程：

result = (df2.assign(col1_demeaned=df2.col1 - df2.col2.mean()) .groupby(key) .col1_demeaned.std())

我使用外括弧，這樣便於添加換行符。

使用鏈式編程時要注意，你可能會需要涉及臨時對象。在前面的例子中，我們不能使用load_data的結果，直到它被賦值給臨時變數df。為了這麼做，assign和許多其它pandas函數可以接收類似函數的參數，即可調用對象（callable）。為了展示可調用對象，看一個前面例子的片段：

df = load_data()df2 = df[df[col2] < 0]

它可以重寫為：

df = (load_data() [lambda x: x[col2] < 0])

這裡，load_data的結果沒有賦值給某個變數，因此傳遞到[ ]的函數在這一步被綁定到了對象。

我們可以把整個過程寫為一個單鏈表達式：

result = (load_data() [lambda x: x.col2 < 0] .assign(col1_demeaned=lambda x: x.col1 - x.col1.mean()) .groupby(key) .col1_demeaned.std())

是否將代碼寫成這種形式只是習慣而已，將它分開成若干步可以提高可讀性。

管道方法

你可以用Python內置的pandas函數和方法，用帶有可調用對象的鏈式編程做許多工作。但是，有時你需要使用自己的函數，或是第三方庫的函數。這時就要用到管道方法。

看下面的函數調用：

a = f(df, arg1=v1)b = g(a, v2, arg3=v3)c = h(b, arg4=v4)

當使用接收、返回Series或DataFrame對象的函數式，你可以調用pipe將其重寫：

result = (df.pipe(f, arg1=v1) .pipe(g, v2, arg3=v3) .pipe(h, arg4=v4))

f(df)和df.pipe(f)是等價的，但是pipe使得鏈式聲明更容易。

pipe的另一個有用的地方是提煉操作為可復用的函數。看一個從列減去分組方法的例子：

g = df.groupby([key1, key2])df[col1] = df[col1] - g.transform(mean)

假設你想轉換多列，並修改分組的鍵。另外，你想用鏈式編程做這個轉換。下面就是一個方法：

def group_demean(df, by, cols): result = df.copy() g = df.groupby(by) for c in cols: result[c] = df[c] - g[c].transform(mean) return result

然後可以寫為：

result = (df[df.col1 < 0] .pipe(group_demean, [key1, key2], [col1]))

12.4 總結

和其它許多開源項目一樣，pandas仍然在不斷的變化和進步中。和本書中其它地方一樣，這裡的重點是放在接下來幾年不會發生什麼改變且穩定的功能。

為了深入學習pandas的知識，我建議你學習官方文檔，並閱讀開發團隊發布的更新文檔。我們還邀請你加入pandas的開發工作：修改bug、創建新功能、完善文檔。