選取一列或列的子集
對於由DataFrame產生的GroupBy對象，如果用一個（單個字符串）或一組（字符串數組）列名對其進行索引，就能實現選取部分列進行聚合的目的。也就是說：
df.groupby('key1')['data1']
df.groupby('key1')[['data2']]是以下代碼的語法糖：
df['data1'].groupby(df['key1'])
df[['data2']].groupby(df['key1'])尤其對於大數據集，很可能只需要對部分列進行聚合。例如，在前面那個數據集中，如果只需計算data2列的平均值並以DataFrame形式得到結果，可以這樣寫：
In [31]: df.groupby(['key1', 'key2'])[['data2']].mean()
Out[31]:
data2
key1 key2
a one 1.319920
two 0.092908
b one 0.281746
two 0.769023這種索引操作所返回的對象是一個已分組的DataFrame（如果傳入的是列表或數組）或已分組的Series（如果傳入的是標量形式的單個列名）：
In [32]: s_grouped = df.groupby(['key1', 'key2'])['data2']
In [33]: s_grouped
Out[33]: <pandas.core.groupby.SeriesGroupBy object at 0x7faa30c78da0>
In [34]: s_grouped.mean()
Out[34]:
key1 key2
a one 1.319920
two 0.092908
b one 0.281746
two 0.769023
Name: data2, dtype: float64通過字典或Series進行分組
除數組以外，分組信息還可以其他形式存在。來看另一個示例DataFrame：
In [35]: people = pd.DataFrame(np.random.randn(5, 5),
....: columns=['a', 'b', 'c', 'd', 'e'],
....: index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis'])
In [36]: people.iloc[2:3, [1, 2]] = np.nan # Add a few NA values
In [37]: people
Out[37]:
a b c d e
Joe 1.007189 -1.296221 0.274992 0.228913 1.352917
Steve 0.886429 -2.001637 -0.371843 1.669025 -0.438570
Wes -0.539741 NaN NaN -1.021228 -0.577087
Jim 0.124121 0.302614 0.523772 0.000940 1.343810
Travis -0.713544 -0.831154 -2.370232 -1.860761 -0.860757現在，假設已知列的分組關係，並希望根據分組計算列的和：
In [38]: mapping = {'a': 'red', 'b': 'red', 'c': 'blue',
....: 'd': 'blue', 'e': 'red', 'f' : 'orange'}現在，你可以將這個字典傳給groupby，來構造數組，但我們可以直接傳遞字典（我包含了鍵“f”來強調，存在未使用的分組鍵是可以的）：
In [39]: by_column = people.groupby(mapping, axis=1)
In [40]: by_column.sum()
Out[40]:
blue red
Joe 0.503905 1.063885
Steve 1.297183 -1.553778
Wes -1.021228 -1.116829
Jim 0.524712 1.770545
Travis -4.230992 -2.405455Series也有同樣的功能，它可以被看做一個固定大小的映射：
In [41]: map_series = pd.Series(mapping)
In [42]: map_series
Out[42]:
a red
b red
c blue
d blue
e red
f orange
dtype: object
In [43]: people.groupby(map_series, axis=1).count()
Out[43]:
blue red
Joe 2 3
Steve 2 3
Wes 1 2
Jim 2 3
Travis 2 3通過函數進行分組
比起使用字典或Series，使用Python函數是一種更原生的方法定義分組映射。任何被當做分組鍵的函數都會在各個索引值上被調用一次，其返回值就會被用作分組名稱。具體點說，以上一小節的示例DataFrame爲例，其索引值爲人的名字。你可以計算一個字符串長度的數組，更簡單的方法是傳入len函數：
In [44]: people.groupby(len).sum()
Out[44]:
a b c d e
3 0.591569 -0.993608 0.798764 -0.791374 2.119639
5 0.886429 -2.001637 -0.371843 1.669025 -0.438570
6 -0.713544 -0.831154 -2.370232 -1.860761 -0.860757將函數跟數組、列表、字典、Series混合使用也不是問題，因爲任何東西在內部都會被轉換爲數組：
In [45]: key_list = ['one', 'one', 'one', 'two', 'two']
In [46]: people.groupby([len, key_list]).min()
Out[46]:
a b c d e
3 one -0.539741 -1.296221 0.274992 -1.021228 -0.577087
two 0.124121 0.302614 0.523772 0.000940 1.343810
5 one 0.886429 -2.001637 -0.371843 1.669025 -0.438570
6 two -0.713544 -0.831154 -2.370232 -1.860761 -0.860757對一個列或不同的列應用不同的函數
具體的辦法是向agg傳入一個從列名映射到函數的字典：
In [71]: grouped.agg({'tip' : np.max, 'size' : 'sum'})
Out[71]:
tip size
day smoker
Fri No 3.50 9
Yes 4.73 31
Sat No 9.00 115
Yes 10.00 104
Sun No 6.00 167
Yes 6.50 49
Thur No 6.70 112
Yes 5.00 40
In [72]: grouped.agg({'tip_pct' : ['min', 'max', 'mean', 'std'],
....: 'size' : 'sum'})
Out[72]:
tip_pct size
min max mean std sum
day smoker
Fri No 0.120385 0.187735 0.151650 0.028123 9
Yes 0.103555 0.263480 0.174783 0.051293 31
Sat No 0.056797 0.291990 0.158048 0.039767 115
Yes 0.035638 0.325733 0.147906 0.061375 104
Sun No 0.059447 0.252672 0.160113 0.042347 167
Yes 0.065660 0.710345 0.187250 0.154134 49
Thur No 0.072961 0.266312 0.160298 0.038774 112
Yes 0.090014 0.241255 0.163863 0.039389 40只有將多個函數應用到至少一列時，DataFrame纔會擁有層次化的列。
你並非一定要接受GroupBy自動給出的那些列名，特別是lambda函數，它們的名稱是’’，這樣的辨識度就很低了（通過函數的name屬性看看就知道了）。因此，如果傳入的是一個由(name,function)元組組成的列表，則各元組的第一個元素就會被用作DataFrame的列名（可以將這種二元元組列表看做一個有序映射）：
In [64]: grouped_pct.agg([('foo', 'mean'), ('bar', np.std)])
Out[64]:
foo bar
day smoker
Fri No 0.151650 0.028123
Yes 0.174783 0.051293
Sat No 0.158048 0.039767
Yes 0.147906 0.061375
Sun No 0.160113 0.042347
Yes 0.187250 0.154134
Thur No 0.160298 0.038774
Yes 0.163863 0.039389apply函數
def top(df, n=5, column='tip_pct'):
....: return df.sort_values(by=column)[-n:]
In [76]: tips.groupby('smoker').apply(top)
Out[76]:
total_bill tip smoker day time size tip_pct
smoker
No 88 24.71 5.85 No Thur Lunch 2 0.236746
185 20.69 5.00 No Sun Dinner 5 0.241663
51 10.29 2.60 No Sun Dinner 2 0.252672
149 7.51 2.00 No Thur Lunch 2 0.266312
232 11.61 3.39 No Sat Dinner 2 0.291990
Yes 109 14.31 4.00 Yes Sat Dinner 2 0.279525
183 23.17 6.50 Yes Sun Dinner 4 0.280535
67 3.07 1.00 Yes Sat Dinner 1 0.325733
178 9.60 4.00 Yes Sun Dinner 2 0.416667
172 7.25 5.15 Yes Sun Dinner 2 0.710345這裏發生了什麼？top函數在DataFrame的各個片段上調用，然後結果由pandas.concat組裝到一起，並以分組名稱進行了標記。於是，最終結果就有了一個層次化索引，其內層索引值來自原DataFrame。
如果傳給apply的函數能夠接受其他參數或關鍵字，則可以將這些內容放在函數名後面一併傳入：
In [77]: tips.groupby(['smoker', 'day']).apply(top, n=1, column='total_bill')禁止分組鍵
從上面的例子中可以看出，分組鍵會跟原始對象的索引共同構成結果對象中的層次化索引。將group_keys=False傳入groupby即可禁止該效果：
In [81]: tips.groupby('smoker', group_keys=False).apply(top)
Out[81]:
total_bill tip smoker day time size tip_pct
88 24.71 5.85 No Thur Lunch 2 0.236746
185 20.69 5.00 No Sun Dinner 5 0.241663
51 10.29 2.60 No Sun Dinner 2 0.252672
149 7.51 2.00 No Thur Lunch 2 0.266312
232 11.61 3.39 No Sat Dinner 2 0.291990
109 14.31 4.00 Yes Sat Dinner 2 0.279525
183 23.17 6.50 Yes Sun Dinner 4 0.280535
67 3.07 1.00 Yes Sat Dinner 1 0.325733
178 9.60 4.00 Yes Sun Dinner 2 0.416667
172 7.25 5.15 Yes Sun Dinner 2 0.710345