資料來源：https://github.com/BrambleXu/pydata-notebook
前面的章節(jié)關注于不同類型的數(shù)據(jù)規(guī)整流程和NumPy领炫、pandas與其它庫的特點。隨著時間的發(fā)展我碟，pandas發(fā)展出了更多適合高級用戶的功能看尼。本章就要深入學習pandas的高級功能熬粗。
12.1 分類數(shù)據(jù)
這一節(jié)介紹的是pandas的分類類型捡多。我會向你展示通過使用它，提高性能和內存的使用率蓉坎。我還會介紹一些在統(tǒng)計和機器學習中使用分類數(shù)據(jù)的工具。
背景和目的
表中的一列通常會有重復的包含不同值的小集合的情況胡嘿。我們已經學過了unique和value_counts蛉艾，它們可以從數(shù)組提取出不同的值，并分別計算頻率：
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
許多數(shù)據(jù)系統(tǒng)（數(shù)據(jù)倉庫衷敌、統(tǒng)計計算或其它應用）都發(fā)展出了特定的表征重復值的方法勿侯，以進行高效的存儲和計算。在數(shù)據(jù)倉庫中缴罗，最好的方法是使用所謂的包含不同值的維表(Dimension Table)助琐，將主要的參數(shù)存儲為引用維表整數(shù)鍵：
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
這種用整數(shù)表示的方法稱為分類或字典編碼表示法。不同值得數(shù)組稱為分類面氓、字典或數(shù)據(jù)級兵钮。本書中蛆橡，我們使用分類的說法。表示分類的整數(shù)值稱為分類編碼或簡單地稱為編碼掘譬。
分類表示可以在進行分析時大大的提高性能泰演。你也可以在保持編碼不變的情況下，對分類進行轉換屁药。一些相對簡單的轉變例子包括：
- 重命名分類粥血。
- 加入一個新的分類，不改變已經存在的分類的順序或位置酿箭。
pandas的分類類型
pandas有一個特殊的分類類型，用于保存使用整數(shù)分類表示法的數(shù)據(jù)趾娃＄缘眨看一個之前的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字符串對象的數(shù)組抬闷。我們可以通過調用它妇蛀，將它轉變?yōu)榉诸悾?/p>
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數(shù)組，而是一個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序列直接創(chuàng)建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]
與顯示指定不同，分類變換不認定指定的分類順序炕泳。因此取決于輸入數(shù)據(jù)的順序纵诞，categories數(shù)組的順序會不同。當使用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]
最后要注意籽腕，分類數(shù)據(jù)不需要字符串嗡呼，盡管我僅僅展示了字符串的例子。分類數(shù)組可以包括任意不可變類型皇耗。
用分類進行計算
與非編碼版本（比如字符串數(shù)組）相比南窗，使用pandas的Categorical有些類似。某些pandas組件郎楼，比如groupby函數(shù)万伤，更適合進行分類。還有一些函數(shù)可以使用有序標志位箭启。
來看一些隨機的數(shù)值數(shù)據(jù)壕翩，使用pandas.qcut面元函數(shù)。它會返回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])
計算這個數(shù)據(jù)的分位面元北救，提取一些統(tǒng)計信息：
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]]
雖然有用，確切的樣本分位數(shù)與分位的名稱相比芜抒，不利于生成匯總珍策。我們可以使用labels參數(shù)qcut，實現(xiàn)目的：
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)
加上標簽的面元分類不包含數(shù)據(jù)面元邊界的信息宅倒，因此可以使用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
分位數(shù)列保存了原始的面元分類信息攘宙，包括排序：
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]
用分類提高性能
如果你是在一個特定數(shù)據(jù)集上做大量分析，將其轉換為分類可以極大地提高效率拐迁。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))
現(xiàn)在线召，將標簽轉換為分類：
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使用分類操作明顯更快缓淹，是因為底層的算法使用整數(shù)編碼數(shù)組哈打，而不是字符串數(shù)組。
分類方法
包含分類數(shù)據(jù)的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')
假設我們知道這個數(shù)據(jù)的實際分類集立轧，超出了數(shù)據(jù)中的四個值。我們可以使用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]
雖然數(shù)據(jù)看起來沒變丙挽，新的分類將反映在它們的操作中肺孵。例如，如果有的話颜阐，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
在大數(shù)據(jù)集中平窘，分類經常作為節(jié)省內存和高性能的便捷工具。過濾完大DataFrame或Series之后凳怨，許多分類可能不會出現(xiàn)在數(shù)據(jù)中瑰艘。我們可以使用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列出了可用的分類方法。
為建模創(chuàng)建虛擬變量
當你使用統(tǒng)計或機器學習工具時肤舞，通常會將分類數(shù)據(jù)轉換為虛擬變量紫新，也稱為one-hot編碼。這包括創(chuàng)建一個不同類別的列的DataFrame李剖；這些列包含給定分類的1s芒率，其它為0。
看前面的例子：
In [73]: cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')
前面的第7章提到過篙顺，pandas.get_dummies函數(shù)可以轉換這個分類數(shù)據(jù)為包含虛擬變量的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很像材彪，但是對使用的函數(shù)有一定限制：
- 它可以產生向分組形狀廣播標量值
- 它可以產生一個和輸入組形狀相同的對象
- 它不能修改輸入
來看一個簡單的例子：
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观挎，但值替換為按鍵分組的平均值。我們可以傳遞函數(shù)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
對于內置的聚合函數(shù)段化，我們可以傳遞一個字符串假名作為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的函數(shù)會返回Series，但是結果必須與輸入大小相同穗泵。舉個例子普气，我們可以用lambda函數(shù)將每個分組乘以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
看一個由簡單聚合構造的的分組轉換函數(shù)：
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
內置的聚合函數(shù)佃延，比如mean或sum，通常比apply函數(shù)快夷磕，也比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
解封分組操作可能包括多個分組聚合，但是矢量化操作還是會帶來收益坐桩。
分組的時間重采樣
對于時間序列數(shù)據(jù)尺棋，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 鏈式編程技術
當對數(shù)據(jù)集進行一系列變換時内斯，你可能發(fā)現(xiàn)創(chuàng)建的多個臨時變量其實并沒有在分析中用到∠裉洌看下面的例子：
df = load_data()
df2 = df[df['col2'] < 0]
df2['col1_demeaned'] = df2['col1'] - df2['col1'].mean()
result = df2.groupby('key').col1_demeaned.std()
雖然這里沒有使用真實的數(shù)據(jù)俘闯，這個例子卻指出了一些新方法。首先忽冻，DataFrame.assign方法是一個df[k] = v形式的函數(shù)式的列分配方法真朗。它不是就地修改對象，而是返回新的修改過的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函數(shù)可以接收類似函數(shù)的參數(shù)琼锋，即可調用對象（callable）。為了展示可調用對象祟昭，看一個前面例子的片段：
df = load_data()
df2 = df[df['col2'] < 0]
它可以重寫為：
df = (load_data()
[lambda x: x['col2'] < 0])
這里缕坎，load_data的結果沒有賦值給某個變量，因此傳遞到[ ]的函數(shù)在這一步被綁定到了對象篡悟。
我們可以把整個過程寫為一個單鏈表達式：
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函數(shù)和方法搬葬，用帶有可調用對象的鏈式編程做許多工作荷腊。但是，有時你需要使用自己的函數(shù)急凰，或是第三方庫的函數(shù)女仰。這時就要用到管道方法。
看下面的函數(shù)調用：
a = f(df, arg1=v1)
b = g(a, v2, arg3=v3)
c = h(b, arg4=v4)
當使用接收抡锈、返回Series或DataFrame對象的函數(shù)式疾忍，你可以調用pipe將其重寫：
result = (df.pipe(f, arg1=v1)
.pipe(g, v2, arg3=v3)
.pipe(h, arg4=v4))
f(df)和df.pipe(f)是等價的，但是pipe使得鏈式聲明更容易床三。
pipe的另一個有用的地方是提煉操作為可復用的函數(shù)一罩。看一個從列減去分組方法的例子：
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仍然在不斷的變化和進步中。和本書中其它地方一樣莲组，這里的重點是放在接下來幾年不會發(fā)生什么改變且穩(wěn)定的功能诊胞。
為了深入學習pandas的知識，我建議你學習官方文檔，并閱讀開發(fā)團隊發(fā)布的文檔更新撵孤。我們還邀請你加入pandas的開發(fā)工作：修改bug迈着、創(chuàng)建新功能、完善文檔邪码。
