Pandas進階筆記 （一） Groupby 重難點總結
如果Pandas只是能把一些資料變成 dataframe 這樣優美的格式，那麼Pandas絕不會成為叱吒風雲的資料分析中心元件。因為在資料分析過程中，描述資料是通過一些列的統計指標實現的，分析結果也需要由具體的分組行為，對各組橫向縱向對比。
GroupBy 就是這樣的一個有力武器。事實上，SQL語言在Pandas出現的幾十年前就成為了高階資料分析人員的標準工具，很大一部分原因正是因為它有標準的SELECT xx FROM xx WHERE condition GROUP BY xx HAVING condition 正規化。
感謝 Wes Mckinney及其團隊，除了SQL之外，我們多了一個更靈活、適應性更強的工具，而非困在SQL Shell或Python裡步履沉重。
【示例】將一段SQL語句用Pandas表達
SQL
SELECT Column1, Column2, mean(Column3), sum(Column4)
FROM SomeTable
WHERE Condition 1
GROUP BY Column1, Column2
HAVING Condition2
Pandas
df [Condition1].groupby([Column1, Column2], as_index=False).agg({Column3: "mean", Column4: "sum"}).filter(Condition2)
Group By: split - apply - combine
GroupBy可以分解為三個步驟：
- Splitting: 把資料按主鍵劃分為很多個小組
- Applying: 對每個小組獨立地使用函式
- Combining: 把所得到的結果組合
那麼，這一套行雲流水的動作是如何完成的呢？
- Splitting 由
groupby實現
- Applying 由
agg、apply、transform、filter實現具體的操作
- Combining 由
concat等實現
其中，在apply這一步，通常由以下四類操作：
- Aggregation:做一些統計性的計算
- Apply：做一些資料轉換
- Transformation:做一些資料處理方面的變換
- Filtration:做一些組級別的過濾
注意，這裡討論的apply,agg,transform,filter方法都是限制在 pandas.core.groupby.DataFrameGroupBy裡面，不能跟 pandas.core.groupby.DataFrame混淆。
先匯入需要用到的模組
import numpy as np
import pandas as pd
import sys, traceback
from itertools import chainPart 1: Groupby 詳解
df_0 = pd.DataFrame({'A': list(chain(*[['foo', 'bar']*4])),
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': np.random.randn(8),
'D': np.random.randn(8)})df_0| A | B | C | D | |
|---|---|---|---|---|
| 0 | foo | one | 1.145852 | 0.210586 |
| 1 | bar | one | -1.343518 | -2.064735 |
| 2 | foo | two | 0.544624 | 1.125505 |
| 3 | bar | three | 1.090288 | -0.296160 |
| 4 | foo | two | -1.854274 | 1.348597 |
| 5 | bar | two | -0.246072 | -0.598949 |
| 6 | foo | one | 0.348484 | 0.429300 |
| 7 | bar | three | 1.477379 | 0.917027 |
Talk 1：建立一個Groupby物件時應注意的問題
Good Practice
df_01 = df_0.copy()
df_01.groupby(["A", "B"], as_index=False, sort=False).agg({"C": "sum", "D": "mean"})| A | B | C | D | |
|---|---|---|---|---|
| 0 | foo | one | 1.494336 | 0.319943 |
| 1 | bar | one | -1.343518 | -2.064735 |
| 2 | foo | two | -1.309649 | 1.237051 |
| 3 | bar | three | 2.567667 | 0.310433 |
| 4 | bar | two | -0.246072 | -0.598949 |
Poor Practice
df_02 = df_0.copy()
df_02.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"}).reset_index()| A | B | C | D | |
|---|---|---|---|---|
| 0 | bar | one | -1.343518 | -2.064735 |
| 1 | bar | three | 2.567667 | 0.310433 |
| 2 | bar | two | -0.246072 | -0.598949 |
| 3 | foo | one | 1.494336 | 0.319943 |
| 4 | foo | two | -1.309649 | 1.237051 |
- 直接使用
as_index=False引數是一個好的習慣，因為如果dataframe非常巨大（比如達到GB以上規模）時，先生成一個Groupby物件，然後再呼叫reset_index()會有額外的時間消耗。 - 在任何涉及資料的操作中，排序都是非常"奢侈的"。如果只是單純的分組，不關心順序，在建立Groupby物件的時候應當關閉排序功能，因為這個功能預設是開啟的。尤其當你在較大的大資料集上作業時更當注意這個問題。
- 值得注意的是：groupby會按照資料在原始資料框內的順序安排它們在每個新組內的順序。這與是否指定排序無關。
如果要得到一個多層索引的資料框，使用預設的as_index=True即可，例如下面的例子：
df_03 = df_0.copy()
df_03.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"})
| C | D | ||
|---|---|---|---|
| A | B | ||
| bar | one | -1.343518 | -2.064735 |
| three | 2.567667 | 0.310433 | |
| two | -0.246072 | -0.598949 | |
| foo | one | 1.494336 | 0.319943 |
| two | -1.309649 | 1.237051 |
注意，as_index僅當做aggregation操作時有效，如果是其他操作，例如transform，指定這個引數是無效的
df_04 = df_0.copy()
df_04.groupby(["A", "B"], as_index=True).transform(lambda x: x * x)
| C | D | |
|---|---|---|
| 0 | 1.312976 | 0.044347 |
| 1 | 1.805040 | 4.263130 |
| 2 | 0.296616 | 1.266761 |
| 3 | 1.188727 | 0.087711 |
| 4 | 3.438331 | 1.818714 |
| 5 | 0.060552 | 0.358740 |
| 6 | 0.121441 | 0.184298 |
| 7 | 2.182650 | 0.840938 |
可以看到，我們得到了一個和df_0一樣長度的新dataframe，同時我們還希望A,B能成為索引，但這並沒有生效。
Talk 2：使用 pd.Grouper
pd.Grouper 比 groupby更強大、更靈活，它不僅支援普通的分組，還支援按照時間進行升取樣或降取樣分組
df_1 = pd.read_excel("dataset\sample-salesv3.xlsx")
df_1["date"] = pd.to_datetime(df_1["date"])
df_1.head()
| account number | name | sku | quantity | unit price | ext price | date | |
|---|---|---|---|---|---|---|---|
| 0 | 740150 | Barton LLC | B1-20000 | 39 | 86.69 | 3380.91 | 2014-01-01 07:21:51 |
| 1 | 714466 | Trantow-Barrows | S2-77896 | -1 | 63.16 | -63.16 | 2014-01-01 10:00:47 |
| 2 | 218895 | Kulas Inc | B1-69924 | 23 | 90.70 | 2086.10 | 2014-01-01 13:24:58 |
| 3 | 307599 | Kassulke, Ondricka and Metz | S1-65481 | 41 | 21.05 | 863.05 | 2014-01-01 15:05:22 |
| 4 | 412290 | Jerde-Hilpert | S2-34077 | 6 | 83.21 | 499.26 | 2014-01-01 23:26:55 |
【例子】計算每個月的ext price總和
df_1.set_index("date").resample("M")["ext price"].sum()
date
2014-01-31 185361.66
2014-02-28 146211.62
2014-03-31 203921.38
2014-04-30 174574.11
2014-05-31 165418.55
2014-06-30 174089.33
2014-07-31 191662.11
2014-08-31 153778.59
2014-09-30 168443.17
2014-10-31 171495.32
2014-11-30 119961.22
2014-12-31 163867.26
Freq: M, Name: ext price, dtype: float64df_1.groupby(pd.Grouper(key="date", freq="M"))["ext price"].sum()
date
2014-01-31 185361.66
2014-02-28 146211.62
2014-03-31 203921.38
2014-04-30 174574.11
2014-05-31 165418.55
2014-06-30 174089.33
2014-07-31 191662.11
2014-08-31 153778.59
2014-09-30 168443.17
2014-10-31 171495.32
2014-11-30 119961.22
2014-12-31 163867.26
Freq: M, Name: ext price, dtype: float64兩種寫法都得到了相同的結果，並且看上去第二種寫法似乎有點兒難以理解。再看一個例子
【例子】計算每個客戶每個月的ext price總和
df_1.set_index("date").groupby("name")["ext price"].resample("M").sum().head(20)
name date
Barton LLC 2014-01-31 6177.57
2014-02-28 12218.03
2014-03-31 3513.53
2014-04-30 11474.20
2014-05-31 10220.17
2014-06-30 10463.73
2014-07-31 6750.48
2014-08-31 17541.46
2014-09-30 14053.61
2014-10-31 9351.68
2014-11-30 4901.14
2014-12-31 2772.90
Cronin, Oberbrunner and Spencer 2014-01-31 1141.75
2014-02-28 13976.26
2014-03-31 11691.62
2014-04-30 3685.44
2014-05-31 6760.11
2014-06-30 5379.67
2014-07-31 6020.30
2014-08-31 5399.58
Name: ext price, dtype: float64df_1.groupby(["name", pd.Grouper(key="date",freq="M")])["ext price"].sum().head(20)
name date
Barton LLC 2014-01-31 6177.57
2014-02-28 12218.03
2014-03-31 3513.53
2014-04-30 11474.20
2014-05-31 10220.17
2014-06-30 10463.73
2014-07-31 6750.48
2014-08-31 17541.46
2014-09-30 14053.61
2014-10-31 9351.68
2014-11-30 4901.14
2014-12-31 2772.90
Cronin, Oberbrunner and Spencer 2014-01-31 1141.75
2014-02-28 13976.26
2014-03-31 11691.62
2014-04-30 3685.44
2014-05-31 6760.11
2014-06-30 5379.67
2014-07-31 6020.30
2014-08-31 5399.58
Name: ext price, dtype: float64這次，第二種寫法遠比第一種寫法清爽、便於理解。這種按照特定欄位和時間取樣的混合分組，請優先考慮用pd.Grouper
Talk 3: 如何訪問組
如果只是做完拆分動作，沒有做後續的apply，得到的是一個groupby物件。這裡討論下如何訪問拆分出來的組
主要方法為：
groupsget_group- 迭代遍歷
df_2 = pd.DataFrame({'X': ['A', 'B', 'A', 'B'], 'Y': [1, 4, 3, 2]})
df_2
| X | Y | |
|---|---|---|
| 0 | A | 1 |
| 1 | B | 4 |
| 2 | A | 3 |
| 3 | B | 2 |
- 使用
groups方法可以看到所有的組
df_2.groupby("X").groups
{'A': Int64Index([0, 2], dtype='int64'),
'B': Int64Index([1, 3], dtype='int64')}- 使用
get_group方法可以訪問到指定的組
df_2.groupby("X", as_index=True).get_group(name="A")
| X | Y | |
|---|---|---|
| 0 | A | 1 |
| 2 | A | 3 |
注意，get_group方法中，name引數只能傳遞單個str，不可以傳入list，儘管Pandas中的其他地方常常能看到這類傳參。如果是多列做主鍵的拆分，可以傳入tuple。
- 迭代遍歷
for name, group in df_2.groupby("X"):
print(name)
print(group,"\n")
A
X Y
0 A 1
2 A 3
B
X Y
1 B 4
3 B 2
這裡介紹一個小技巧，如果你得到一個<pandas.core.groupby.groupby.DataFrameGroupBy object物件，想要將它還原成其原本的 dataframe ，有一個非常簡便的方法值得一提:
gropbyed_object.apply(lambda x: x)
囿於篇幅，就不對API逐個解釋了，這裡僅指出最容易忽視也最容易出錯的三個引數
| 引數 | 注意事項 |
|---|---|
| level | 僅作用於層次化索引的資料框時有效 |
| as_index | 僅對資料框做 agg 操作時有效， |
| group_keys | 僅在呼叫 apply 時有效 |
Part 2: Apply 階段詳解
拆分完成後，可以對各個組做一些的操作，總體說來可以分為以下四類：
- aggregation
- apply
- transform
- filter
先總括地對比下這四類操作
- 任何能將一個
Series壓縮成一個標量值的都是agg操作，例如求和、求均值、求極值等統計計算 - 對資料框或者
groupby物件做變換，得到子集或一個新的資料框的操作是apply或transform
- 對聚合結果按標準過濾的操作是
filter
apply 和 transform有那麼一點相似，下文會重點剖析二者
Talk 4：agg VS apply
agg和apply都可以對特定列的資料傳入函式，並且依照函式進行計算。但是區別在於，agg更加靈活高效，可以一次完成操作。而apply需要輾轉多次才能完成相同操作。
df_3 = pd.DataFrame({"name":["Foo", "Bar", "Foo", "Bar"], "score":[80,80,95,70]})
df_3
| name | score | |
|---|---|---|
| 0 | Foo | 80 |
| 1 | Bar | 80 |
| 2 | Foo | 95 |
| 3 | Bar | 70 |
我們需要計算出每個人的總分、最高分、最低分
（1）使用apply方法
df_3.groupby("name", sort=False).score.apply(lambda x: x.sum())
name
Foo 175
Bar 150
Name: score, dtype: int64df_3.groupby("name", sort=False).score.apply(lambda x: x.max())
name
Foo 95
Bar 80
Name: score, dtype: int64df_3.groupby("name", sort=False).score.apply(lambda x: x.min())
name
Foo 80
Bar 70
Name: score, dtype: int64顯然，我們輾轉操作了3次，並且還需要額外一次操作（將所得到的三個值粘合起來）
（2）使用agg方法
df_3.groupby("name", sort=False).agg({"score": [np.sum, np.max, np.min]})
| score | |||
|---|---|---|---|
| sum | amax | amin | |
| name | |||
| Foo | 175 | 95 | 80 |
| Bar | 150 | 80 | 70 |
小結 agg一次可以對多個列獨立地呼叫不同的函式，而apply一次只能對多個列呼叫相同的一個函式。
Talk 5：transform VS agg
transform作用於資料框自身，並且返回變換後的值。返回的物件和原物件擁有相同數目的行，但可以擴充套件列。注意返回的物件不是就地修改了原物件，而是建立了一個新物件。也就是說原物件沒變。
df_4 = pd.DataFrame({'A': range(3), 'B': range(1, 4)})
df_4
| A | B | |
|---|---|---|
| 0 | 0 | 1 |
| 1 | 1 | 2 |
| 2 | 2 | 3 |
df_4.transform(lambda x: x + 1)
| A | B | |
|---|---|---|
| 0 | 1 | 2 |
| 1 | 2 | 3 |
| 2 | 3 | 4 |
可以對資料框先分組，然後對各組賦予一個變換，例如元素自增1。下面這個例子意義不大，可以直接做變換。
df_2.groupby("X").transform(lambda x: x + 1)
| Y | |
|---|---|
| 0 | 2 |
| 1 | 5 |
| 2 | 4 |
| 3 | 3 |
下面舉一個更實際的例子
df_5 = pd.read_csv(r"dataset\tips.csv")
df_5.head()
| total_bill | tip | sex | smoker | day | time | size | |
|---|---|---|---|---|---|---|---|
| 0 | 16.99 | 1.01 | Female | No | Sun | Dinner | 2 |
| 1 | 10.34 | 1.66 | Male | No | Sun | Dinner | 3 |
| 2 | 21.01 | 3.50 | Male | No | Sun | Dinner | 3 |
| 3 | 23.68 | 3.31 | Male | No | Sun | Dinner | 2 |
| 4 | 24.59 | 3.61 | Female | No | Sun | Dinner | 4 |
現在我們想知道每天，各數值列的均值
對比以下 agg 和 transform 兩種操作
df_5.groupby("day").aggregate("mean")
| total_bill | tip | size | |
|---|---|---|---|
| day | |||
| Fri | 17.151579 | 2.734737 | 2.105263 |
| Sat | 20.441379 | 2.993103 | 2.517241 |
| Sun | 21.410000 | 3.255132 | 2.842105 |
| Thur | 17.682742 | 2.771452 | 2.451613 |
df_5.groupby('day').transform(lambda x : x.mean()).total_bill.unique()
array([21.41 , 20.44137931, 17.68274194, 17.15157895])觀察得知，兩種操作是相同的，都是對各個小組求均值。所不同的是，agg方法僅返回4行（即壓縮後的統計值），而transform返回一個和原資料框同樣長度的新資料框。
Talk 6：transform VS apply
transform 和 apply 的不同主要體現在兩方面：
apply對於每個組，都是同時在所有列上面呼叫函式；而transform是對每個組，依次在每一列上呼叫函式
- 由上面的工作方法決定了：
apply可以返回標量、Series、dataframe——取決於你在什麼上面呼叫了apply方法；而transform只能返回一個類似於陣列的序列，例如一維的Series、array、list，並且最重要的是，要和原始組有同樣的長度，否則會引發錯誤。
【例子】通過列印物件的型別來對比兩種方法的工作物件
df_6 = pd.DataFrame({'State':['Texas', 'Texas', 'Florida', 'Florida'],
'a':[4,5,1,3], 'b':[6,10,3,11]})
df_6
| State | a | b | |
|---|---|---|---|
| 0 | Texas | 4 | 6 |
| 1 | Texas | 5 | 10 |
| 2 | Florida | 1 | 3 |
| 3 | Florida | 3 | 11 |
def inspect(x):
print(type(x))
print(x)
df_6.groupby("State").apply(inspect)
<class 'pandas.core.frame.DataFrame'>
State a b
2 Florida 1 3
3 Florida 3 11
<class 'pandas.core.frame.DataFrame'>
State a b
2 Florida 1 3
3 Florida 3 11
<class 'pandas.core.frame.DataFrame'>
State a b
0 Texas 4 6
1 Texas 5 10從列印結果我們清晰地看到兩點：apply 每次作用的物件是一個 dataframe，其次第一個組被計算了兩次，這是因為pandas會通過這種機制來對比是否有更快的方式完成後面剩下組的計算。
df_6.groupby("State").transform(inspect)
<class 'pandas.core.series.Series'>
2 1
3 3
Name: a, dtype: int64
<class 'pandas.core.series.Series'>
2 3
3 11
Name: b, dtype: int64
<class 'pandas.core.frame.DataFrame'>
a b
2 1 3
3 3 11
<class 'pandas.core.series.Series'>
0 4
1 5
Name: a, dtype: int64
<class 'pandas.core.series.Series'>
0 6
1 10
Name: b, dtype: int64從列印結果我們也清晰地看到兩點：transform每次只計算一列；會出現計算了一個組整體的情況，這有點令人費解，待研究。
從上面的對比，我們直接得到了一個有用的警示：不要傳一個同時涉及到多列的函式給transform方法，因為那麼做只會得到錯誤。例如下面的程式碼所示：
def subtract(x):
return x["a"] - x["b"]
try:
df_6.groupby("State").transform(subtract)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
formatted_lines = traceback.format_exc().splitlines()
print(formatted_lines[-1])
KeyError: ('a', 'occurred at index a')另一個警示則是：在使用 transform 方法的時候，不要去試圖修改返回結果的長度，那樣不僅會引發錯誤，而且traceback的資訊非常隱晦，很可能你需要花很長時間才能真正意識到錯誤所在。
def return_more(x):
return np.arange(3)
try:
df_6.groupby("State").transform(return_more)
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
formatted_lines = traceback.format_exc().splitlines()
print(formatted_lines[-1])
ValueError: Length mismatch: Expected axis has 6 elements, new values have 4 elements這個報錯資訊有點彆扭，期待返回6個元素，但是返回的結果只有4個元素；其實，應該說預期的返回為4個元素，但是現在卻返回6個元素，這樣比較容易理解錯誤所在。
最後，讓我們以一條有用的經驗結束這個talk：如果你確信自己想要的操作時同時作用於多列，並且速度最好還很快，請不要用transform方法，Talk9有一個這方面的好例子。
Talk 7：agg 用法總結
（1）一次對所有列呼叫多個函式
df_0.groupby("A").agg([np.sum, np.mean, np.min])
| C | D | |||||
|---|---|---|---|---|---|---|
| sum | mean | amin | sum | mean | amin | |
| A | ||||||
| bar | 0.978077 | 0.244519 | -1.343518 | -2.042817 | -0.510704 | -2.064735 |
| foo | 0.184686 | 0.046172 | -1.854274 | 3.113988 | 0.778497 | 0.210586 |
（2）一次對特定列呼叫多個函式
df_0.groupby("A")["C"].agg([np.sum, np.mean, np.min])
| sum | mean | amin | |
|---|---|---|---|
| A | |||
| bar | 0.978077 | 0.244519 | -1.343518 |
| foo | 0.184686 | 0.046172 | -1.854274 |
（3）對不同列呼叫不同函式
df_0.groupby("A").agg({"C": [np.sum, np.mean], "D": [np.max, np.min]})
| C | D | |||
|---|---|---|---|---|
| sum | mean | amax | amin | |
| A | ||||
| bar | 0.978077 | 0.244519 | 0.917027 | -2.064735 |
| foo | 0.184686 | 0.046172 | 1.348597 | 0.210586 |
df_0.groupby("A").agg({"C": "sum", "D": "min"})
| C | D | |
|---|---|---|
| A | ||
| bar | 0.978077 | -2.064735 |
| foo | 0.184686 | 0.210586 |
（4）對同一列呼叫不同函式，並且直接重新命名
df_0.groupby("A")["C"].agg([("Largest", "max"), ("Smallest", "min")])
| Largest | Smallest | |
|---|---|---|
| A | ||
| bar | 1.477379 | -1.343518 |
| foo | 1.145852 | -1.854274 |
（5）對多個列呼叫同一個函式
agg_keys = {}.fromkeys(["C", "D"], "sum")
df_0.groupby("A").agg(agg_keys)
| C | D | |
|---|---|---|
| A | ||
| bar | 0.978077 | -2.042817 |
| foo | 0.184686 | 3.113988 |
（6）注意agg會忽略缺失值，這在計數時需要加以注意
df_7 = pd.DataFrame({"ID":["A","A","A","B","B"], "Num": [1,np.nan, 1,1,1]})
df_7
| ID | Num | |
|---|---|---|
| 0 | A | 1.0 |
| 1 | A | NaN |
| 2 | A | 1.0 |
| 3 | B | 1.0 |
| 4 | B | 1.0 |
df_7.groupby("ID").agg({"Num":"count"})
| Num | |
|---|---|
| ID | |
| A | 2 |
| B | 2 |
注意：Pandas 中的 count,sum,mean,median,std,var,min,max等函式都用C語言優化過。所以，還是那句話，如果你在大資料集上使用agg，最好使用這些函式而非從numpy那裡借用np.sum等方法，一個緩慢的程式是由每一步的緩慢積累而成的。
Talk 8：Filtration 易錯點剖析
通常，在對一個 dataframe 分組並且完成既定的操作之後，可以直接返回結果，也可以視需求對結果作一層過濾。這個過濾一般都是指 filter 操作，但是務必要理解清楚自己到底需要對組作過濾還是對組內的每一行作過濾。這個Talk就來討論過濾這個話題。
【例子】找出每門課程考試分數低於這門課程平均分的學生
df_8 = pd.DataFrame({"Subject": list(chain(*[["Math"]*3,["Computer"]*3])),
"Student": list(chain(*[["Chan", "Ida", "Ada"]*2])),
"Score": [80,90,85,90,85,95]})
df_8
| Subject | Student | Score | |
|---|---|---|---|
| 0 | Math | Chan | 80 |
| 1 | Math | Ida | 90 |
| 2 | Math | Ada | 85 |
| 3 | Computer | Chan | 90 |
| 4 | Computer | Ida | 85 |
| 5 | Computer | Ada | 95 |
這樣一個需求是否適合用 filter 來處理呢？我們試試看：
try:
df_8.groupby("Subject").filter(lambda x: x["Score"] < x["Score"].mean())
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
formatted_lines = traceback.format_exc().splitlines()
print(formatted_lines[-1])
TypeError: filter function returned a Series, but expected a scalar bool顯然不行，因為 filter 實際上做的事情是要麼留下這個組，要麼過濾掉這個組。我們在這裡弄混淆的東西，和我們初學 SQL時弄混 WHERE 和 HAVING 是一回事。就像需要記住 HAVING 是一個組內語法一樣，請記住 filter 是一個組內方法。
我們先解決這個例子，正確的做法如下:
df_8.groupby("Subject").apply(lambda g: g[g.Score < g.Score.mean()])
| Subject | Student | Score | ||
|---|---|---|---|---|
| Subject | ||||
| Computer | 4 | Computer | Ida | 85 |
| Math | 0 | Math | Chan | 80 |
而關於 filter，我們援引官方文件上的例子作為對比
df_9 = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
'foo', 'bar'],
'B' : [1, 2, 3, 4, 5, 6],
'C' : [2.0, 5., 8., 1., 2., 9.]})
df_9
| A | B | C | |
|---|---|---|---|
| 0 | foo | 1 | 2.0 |
| 1 | bar | 2 | 5.0 |
| 2 | foo | 3 | 8.0 |
| 3 | bar | 4 | 1.0 |
| 4 | foo | 5 | 2.0 |
| 5 | bar | 6 | 9.0 |
df_9.groupby('A').filter(lambda x: x['B'].mean() > 3.)
| A | B | C | |
|---|---|---|---|
| 1 | bar | 2 | 5.0 |
| 3 | bar | 4 | 1.0 |
| 5 | bar | 6 | 9.0 |
Part 3：groupby 應用舉例
Talk 9：組內缺失值填充
df_10 = pd.DataFrame({"ID":["A","A","A","B","B","B"], "Num": [100,np.nan,300,np.nan,500,600]})
df_10
| ID | Num | |
|---|---|---|
| 0 | A | 100.0 |
| 1 | A | NaN |
| 2 | A | 300.0 |
| 3 | B | NaN |
| 4 | B | 500.0 |
| 5 | B | 600.0 |
df_10.groupby("ID", as_index=False).Num.transform(lambda x: x.fillna(method="ffill")).transform(lambda x: x.fillna(method="bfill"))
| Num | |
|---|---|
| 0 | 100.0 |
| 1 | 100.0 |
| 2 | 300.0 |
| 3 | 500.0 |
| 4 | 500.0 |
| 5 | 600.0 |
如果dataframe比較大（超過1GB）,transform + lambda方法會比較慢，可以用下面這個方法，速度約比上面的組合快100倍。
df_10.groupby("ID",as_index=False).ffill().groupby("ID",as_index=False).bfill()
| ID | Num | |
|---|---|---|
| 0 | A | 100.0 |
| 1 | A | 100.0 |
| 2 | A | 300.0 |
| 3 | B | 500.0 |
| 4 | B | 500.0 |
| 5 | B | 600.0 |
參考資料：
https://stackoverflow.com/questions/21828398/what-is-the-difference-between-pandas-agg-and-apply-function
https://stackoverflow.com/questions/44864655/pandas-difference-between-apply-and-aggregate-functions
https://stackoverflow.com/questions/27517425/apply-vs-transform-on-a-group-object
https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html
相關推薦
Pandas進階筆記 （一） Groupby 重難點總結
如果Pandas只是能把一些資料變成 dataframe 這樣優美的格式，那麼Pandas絕不會成為叱吒風雲的資料分析中心元件。因為在資料分析過程中，描述資料是通過一些列的統計指標實現的，分析結果也需要由具體的分組行為，對各組橫向縱向對比。 GroupBy 就是這樣的一個有力武器。事實上，SQL語言在Pand
Python3入門與進階筆記（一）：基本型別
Python的基本型別Number：數字int 和 float python3中的整型只有int，小數只有float.。type函式可以用來檢視型別。 /表示小數除法，例如2/2=1.0，type(2/2)是float。 //表示整數除法，
【SSH進階之路】Struts + Spring + Hibernate 進階開端（一）
height 一段 ioc 效率 陽光大道 面向對象的思想 text ase 們的 Long Long ago。就聽說過SSH。起初還以為是一個東東，詳細內容更是不詳，總認為高端大氣上檔次，經過學習之後才發現，不不過高大上，更是低調奢華有內涵，經過一段時間的
Spring Boot學習進階筆記（五）-添加定時任務
imp 配置 ren 時間 report rate enable lin enables 一、在Spring [email protected]/* */，啟用定時任務的配置。@SpringBootApplication@EnableSchedulingpubl
python進階學習（一）
分享 target for buffer yun lena hello pri true 同樣是《python基礎教程（第二版）》的內容，只是後面內容學起來，相比前面會比較有趣，也更加實用，所以，將“基礎”改為“進階”。 python 電子書分享地址：http://yu
python進階學習（一）--多線程編程
不用 才會 睡眠 關鍵字參數 war 信息 target 函數傳遞 消息隊列 1. 多線程 概念：簡單地說操作系統可以同時執行多個不用程序。例如：一邊用瀏覽器上網，一邊在聽音樂，一邊在用筆記軟件記筆記。 並發：指的是任務數多余cpu核數，通過操作系統的各種任務調度算
Angularjs進階筆記（2）-自定義指令中的數據綁定
粘貼 文章 發送 制作 取值 不同的 過多 簡單 也會 Angularjs進階筆記（2）-自定義指令中的數據綁定 有關自定義指令的scope參數，網上很多文章都在講這3種綁定方式實現的效果是什麽，但幾乎沒有人講到底怎麽使用，本篇希望聊聊到底怎麽用這個話題。 一. 自定義
Python入門+進階筆記（2）——Python基本類型
python入門 [ ] ber 布爾 入門 十六進制 運算 轉義 基本 數字（number） Python3中有int（整型）、float（浮點型） 二進制：以0b開頭；八進制：以0o開頭；十六進制：以0x開頭。 bin:其他進制的數轉為二進制的數；int：其他進制的數
Leetcode進階----學習（一）【兩數相加、無重複字元的最長字串】
①兩數相加 給定兩個非空連結串列來表示兩個非負整數。位數按照逆序方式儲存，它們的每個節點只儲存單個數字。將兩數相加返回一個新的連結串列。 你可以假設除了數字 0 之外，這兩個數字都不會以零開頭。 示例： 輸入：(2 -> 4 -> 3) + (5 -> 6 ->
Java多執行緒之進階篇（一）
一、執行緒池 1.1 執行緒池的建立 1.1.1 ThreadPoolExecutor 1.1.2 執行緒池的分類
Python3入門與進階筆記（三）：迴圈
表示式的優先順序： 例： a=1 b=2 c=2 not a or b + 2 == c + 2 結果為 True，等價於 ( ( not a ) or ( b + 2 ) ) == ( c + 2 )迴圈
伊始--淺談C++程式設計師進階歷程（一）
最近看了一篇《回答阿里社招面試如何準備，順便談談對於Java程式猿學習當中各個階段的建議》，心中有一些感觸。 在看這篇文章前幾周，還挺迷茫的。不知不覺也工作了很久，雖然在上班期間，每天或多或少地都在寫程式碼，但是很多都是僅僅增加熟練度，或者說是將別人現有的
Python進階筆記（3）_ 模組和包
匯入模組 要使用一個模組，我們必須首先匯入該模組。Python使用import 語句匯入一個模組。例如，匯入系統自帶的模組 math：import math 你可以認為 math 就是一個指向已匯入模組的變數，通過該變數，我們可以訪問 math 模組中所定義的所有公開的函式
【JVM】程式設計師進階JVM（一）——Java記憶體區域
一、前言 這篇部落格起，小編會向一個更加深層次、逼格滿滿的區域進發——JVM。 可以說JVM不是一個新鮮的東西，但是做java的都會了解JVM，都聽過JVM。有的時候我們寫的程式碼執行跟JVM也有關係。 二、JVM介紹
林大媽的JavaScript進階知識（一）：物件與記憶體
JavaScript中的基本資料型別 在JS中，有6種基本資料型別： string number boolean null undefined Symbol（ES6） 除去這六種基本資料型別以外，其他的所有變數資料型別都是Object。基本型別的操作在JS底層中是這樣實現的： // 1. 申請一塊記憶體，
PHP多進程系列筆記（一）
could 僵屍進程 代碼 得到 擴展 系統 需要 all RR 本系列文章將向大家講解pcntl_*系列函數，從而更深入的理解進程相關知識。 PCNTL在PHP中進程控制支持默認是關閉的。您需要使用 --enable-pcntl 配置選項重新編譯PHP的 CGI或CLI
React學習筆記之react進階篇（1）
ava 不能 success 字符 style 使用 -s 布爾 一次 1.組件的state（狀態） 1.選擇合適的state state所代表的一個組件UI呈現的完整狀態集又可以分成兩類數據：用作渲染組件時使用到的數據的來源以及用作組件UI展現形式的判斷依據。 示
React學習筆記之react進階篇（2）
-s state ops category strong tro 服務 ive 周期 2.組件與服務器通信 組件的生命周期分為三個階段：掛載階段->更新階段->卸載階段，本文主要集中講述掛載和更新階段組件如何和服務器進行通信。 1.組件掛載階段通信
pandas學習筆記（一）
大數據 技術分享 貢獻 如何 name 自定義 內存 ren nbsp Pandas是一款開放源碼的BSD許可的Python庫，為Python編程語言提供了高性能，易於使用的數據結構和數據分析工具。Pandas用於廣泛的領域，包括金融，經濟，統計，分析等學術和商業領域。在本
《代碼閱讀》讀書筆記（一）
需求 的人 一行 編碼 重要 流動 使用 分析 缺少 《代碼閱讀》讀書筆記(一) 《代碼閱讀》（《Code Reading The Open Source Perspective》）Diomidis Spinellis 著 ---------------------