第1章 準備工作
第2章 Python語法基礎，IPython和Jupyter
第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 pd
In [11]: values = pd.Series(['apple', 'orange', 'apple',
....: 'apple'] * 2)
In [12]: values
Out[12]:
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
dtype: object
In [13]: pd.unique(values)
Out[13]: array(['apple', 'orange'], dtype=object)
In [14]: pd.value_counts(values)
Out[14]:
apple 6
orange 2
dtype: int64
許多數據系統（數據倉庫、統計計算或其它應用）都發展出了特定的表征重復值的方法，以進行高效的存儲和計算。在數據倉庫中，最好的方法是使用所謂的包含不同值的維表(Dimension Table)，將主要的參數存儲為引用維表整數鍵：
In [15]: values = pd.Series([0, 1, 0, 0] * 2)
In [16]: dim = pd.Series(['apple', 'orange'])
In [17]: values
Out[17]:
0 0
1 1
2 0
3 0
4 0
5 1
6 0
7 0
dtype: int64
In [18]: dim
Out[18]:
0 apple
1 orange
dtype: object
可以使用take方法存儲原始的字符串Series：
In [19]: dim.take(values)
Out[19]:
0 apple
1 orange
0 apple
0 apple
0 apple
1 orange
0 apple
0 apple
dtype: object
這種用整數表示的方法稱為分類或字典編碼表示法。不同值得數組稱為分類、字典或數據級。本書中，我們使用分類的說法。表示分類的整數值稱為分類編碼或簡單地稱為編碼。
分類表示可以在進行分析時大大的提高性能。你也可以在保持編碼不變的情況下，對分類進行轉換。一些相對簡單的轉變例子包括：
- 重命名分類。
- 加入一個新的分類，不改變已經存在的分類的順序或位置。
pandas的分類類型
pandas有一個特殊的分類類型，用于保存使用整數分類表示法的數據。看一個之前的Series例子：
In [20]: fruits = ['apple', 'orange', 'apple', 'apple'] * 2
In [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]: df
Out[23]:
basket_id fruit count weight
0 0 apple 5 3.858058
1 1 orange 8 2.612708
2 2 apple 4 2.995627
3 3 apple 7 2.614279
4 4 apple 12 2.990859
5 5 orange 8 3.845227
6 6 apple 5 0.033553
7 7 apple 4 0.425778
這里，df['fruit']是一個Python字符串對象的數組。我們可以通過調用它，將它轉變為分類：
In [24]: fruit_cat = df['fruit'].astype('category')
In [25]: fruit_cat
Out[25]:
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
fruit_cat的值不是NumPy數組，而是一個pandas.Categorical實例：
In [26]: c = fruit_cat.values
In [27]: type(c)
Out[27]: pandas.core.categorical.Categorical
分類對象有categories和codes屬性：
In [28]: c.categories
Out[28]: Index(['apple', 'orange'], dtype='object')
In [29]: c.codes
Out[29]: array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)
你可將DataFrame的列通過分配轉換結果，轉換為分類：
In [30]: df['fruit'] = df['fruit'].astype('category')
In [31]: df.fruit
Out[31]:
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
你還可以從其它Python序列直接創建pandas.Categorical：
In [32]: my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
In [33]: my_categories
Out[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_2
Out[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_cat
Out[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]: bins
Out[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: 1000
Categories (4, interval[float64]): [(-2.95, -0.684] < (-0.684, -0.0101] < (-0.010
1, 0.63] <
(0.63, 3.928]]
雖然有用，確切的樣本分位數與分位的名稱相比，不利于生成匯總。我們可以使用labels參數qcut，實現目的：
In [46]: bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
In [47]: bins
Out[47]:
[Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]
Length: 1000
Categories (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]: results
Out[51]:
quartile count min max
0 Q1 250 -2.949343 -0.685484
1 Q2 250 -0.683066 -0.010115
2 Q3 250 -0.010032 0.628894
3 Q4 250 0.634238 3.927528
分位數列保存了原始的面元分類信息，包括排序：
In [52]: results['quartile']
Out[52]:
0 Q1
1 Q2
2 Q3
3 Q4
Name: quartile, dtype: category
Categories (4, object): [Q1 < Q2 < Q3 < Q4]
用分類提高性能
如果你是在一個特定數據集上做大量分析，將其轉換為分類可以極大地提高效率。DataFrame列的分類使用的內存通常少的多。來看一些包含一千萬元素的Series，和一些不同的分類：
In [53]: N = 10000000
In [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]: 80000080
In [58]: categories.memory_usage()
Out[58]: 10000272
轉換為分類不是沒有代價的，但這是一次性的代價：
In [59]: %time _ = labels.astype('category')
CPU times: user 490 ms, sys: 240 ms, total: 730 ms
Wall 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_s
Out[62]:
0 a
1 b
2 c
3 d
4 a
5 b
6 c
7 d
dtype: category
Categories (4, object): [a, b, c, d]
特別的cat屬性提供了分類方法的入口：
In [63]: cat_s.cat.codes
Out[63]:
0 0
1 1
2 2
3 3
4 0
5 1
6 2
7 3
dtype: int8
In [64]: cat_s.cat.categories
Out[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_s2
Out[67]:
0 a
1 b
2 c
3 d
4 a
5 b
6 c
7 d
dtype: category
Categories (5, object): [a, b, c, d, e]
雖然數據看起來沒變，新的分類將反映在它們的操作中。例如，如果有的話，value_counts表示分類：
In [68]: cat_s.value_counts()
Out[68]:
d 2
c 2
b 2
a 2
dtype: int64
In [69]: cat_s2.value_counts()
Out[69]:
d 2
c 2
b 2
a 2
e 0
dtype: int64
在大數據集中，分類經常作為節省內存和高性能的便捷工具。過濾完大DataFrame或Series之后，許多分類可能不會出現在數據中。我們可以使用remove_unused_categories方法刪除沒看到的分類：
In [70]: cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
In [71]: cat_s3
Out[71]:
0 a
1 b
4 a
5 b
dtype: category
Categories (4, object): [a, b, c, d]
In [72]: cat_s3.cat.remove_unused_categories()
Out[72]:
0 a
1 b
4 a
5 b
dtype: category
Categories (2, object): [a, b]
表12-1列出了可用的分類方法。
為建模創建虛擬變量
當你使用統計或機器學習工具時，通常會將分類數據轉換為虛擬變量，也稱為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 d
0 1 0 0 0
1 0 1 0 0
2 0 0 1 0
3 0 0 0 1
4 1 0 0 0
5 0 1 0 0
6 0 0 1 0
7 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]: df
Out[76]:
key value
0 a 0.0
1 b 1.0
2 c 2.0
3 a 3.0
4 b 4.0
5 c 5.0
6 a 6.0
7 b 7.0
8 c 8.0
9 a 9.0
10 b 10.0
11 c 11.0
按鍵進行分組：
In [77]: g = df.groupby('key').value
In [78]: g.mean()
Out[78]:
key
a 4.5
b 5.5
c 6.5
Name: value, dtype: float64
假設我們想產生一個和df['value']形狀相同的Series，但值替換為按鍵分組的平均值。我們可以傳遞函數lambda x: x.mean()進行轉換：
In [79]: g.transform(lambda x: x.mean())
Out[79]:
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
對于內置的聚合函數，我們可以傳遞一個字符串假名作為GroupBy的agg方法：
In [80]: g.transform('mean')
Out[80]:
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
與apply類似，transform的函數會返回Series，但是結果必須與輸入大小相同。舉個例子，我們可以用lambda函數將每個分組乘以2：
In [81]: g.transform(lambda x: x * 2)
Out[81]:
0 0.0
1 2.0
2 4.0
3 6.0
4 8.0
5 10.0
6 12.0
7 14.0
8 16.0
9 18.0
10 20.0
11 22.0
Name: value, dtype: float64
再舉一個復雜的例子，我們可以計算每個分組的降序排名：
In [82]: g.transform(lambda x: x.rank(ascending=False))
Out[82]:
0 4.0
1 4.0
2 4.0
3 3.0
4 3.0
5 3.0
6 2.0
7 2.0
8 2.0
9 1.0
10 1.0
11 1.0
Name: value, dtype: float64
看一個由簡單聚合構造的的分組轉換函數：
def normalize(x):
return (x - x.mean()) / x.std()
我們用transform或apply可以獲得等價的結果：
In [84]: g.transform(normalize)
Out[84]:
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
In [85]: g.apply(normalize)
Out[85]:
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
內置的聚合函數，比如mean或sum，通常比apply函數快，也比transform快。這允許我們進行一個所謂的解封（unwrapped）分組操作：
In [86]: g.transform('mean')
Out[86]:
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
In [87]: normalized = (df['value'] - g.transform('mean')) / g.transform('std')
In [88]: normalized
Out[88]:
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
解封分組操作可能包括多個分組聚合，但是矢量化操作還是會帶來收益。
分組的時間重采樣
對于時間序列數據，resample方法從語義上是一個基于內在時間的分組操作。下面是一個示例表：
In [89]: N = 15
In [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]: df
Out[92]:
time value
0 2017-05-20 00:00:00 0
1 2017-05-20 00:01:00 1
2 2017-05-20 00:02:00 2
3 2017-05-20 00:03:00 3
4 2017-05-20 00:04:00 4
5 2017-05-20 00:05:00 5
6 2017-05-20 00:06:00 6
7 2017-05-20 00:07:00 7
8 2017-05-20 00:08:00 8
9 2017-05-20 00:09:00 9
10 2017-05-20 00:10:00 10
11 2017-05-20 00:11:00 11
12 2017-05-20 00:12:00 12
13 2017-05-20 00:13:00 13
14 2017-05-20 00:14:00 14
這里，我們可以用time作為索引，然后重采樣：
In [93]: df.set_index('time').resample('5min').count()
Out[93]:
value
time
2017-05-20 00:00:00 5
2017-05-20 00:05:00 5
2017-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 value
0 a 2017-05-20 00:00:00 0.0
1 b 2017-05-20 00:00:00 1.0
2 c 2017-05-20 00:00:00 2.0
3 a 2017-05-20 00:01:00 3.0
4 b 2017-05-20 00:01:00 4.0
5 c 2017-05-20 00:01:00 5.0
6 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]: resampled
Out[98]:
value
key 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.0
b 2017-05-20 00:00:00 35.0
2017-05-20 00:05:00 110.0
2017-05-20 00:10:00 185.0
c 2017-05-20 00:00:00 40.0
2017-05-20 00:05:00 115.0
2017-05-20 00:10:00 190.0
In [99]: resampled.reset_index()
Out[99]:
key time value
0 a 2017-05-20 00:00:00 30.0
1 a 2017-05-20 00:05:00 105.0
2 a 2017-05-20 00:10:00 180.0
3 b 2017-05-20 00:00:00 35.0
4 b 2017-05-20 00:05:00 110.0
5 b 2017-05-20 00:10:00 185.0
6 c 2017-05-20 00:00:00 40.0
7 c 2017-05-20 00:05:00 115.0
8 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 way
df2 = df.copy()
df2['k'] = v
# Functional assign way
df2 = 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、創建新功能、完善文檔。
第1章 準備工作
第2章 Python語法基礎，IPython和Jupyter
第3章 Python的數據結構、函數和文件
第4章 NumPy基礎：數組和矢量計算
第5章 pandas入門
第6章 數據加載、存儲與文件格式
第7章 數據清洗和準備
第8章 數據規整：聚合、合并和重塑
第9章 繪圖和可視化
第10章 數據聚合與分組運算
第11章 時間序列
第12章 pandas高級應用
第13章 Python建模庫介紹
第14章 數據分析案例
附錄A NumPy高級應用
附錄B 更多關于IPython的內容（完）
