GroupBy: Split-Apply-Combine

df["runs"].sum() gives one total for the whole league. But the real questions are per team: "How many runs did each team score?", "Which franchise has the best average?". You could filter each team one by one (df[df["team"] == "MI"]…) — but with 10 teams and 17 seasons that becomes hundreds of lines. groupby() does it in one line.

Definition

groupby() groups the rows of a DataFrame by the values of one or more key columns, so that an operation (usually an aggregate) can be run separately on each group. The process is called split-apply-combine.

• Key — the column whose values decide the groups (team). Every distinct value becomes one group.
• Split — rows with the same key value are put together (all MI rows, all CSK rows…).
• Apply — a function (sum, mean, …) runs on each group independently.
• Combine — the per-group answers are glued into a new Series/DataFrame whose index is the group keys.

Split-apply-combine diagram

              SPLIT                    APPLY (sum runs)        COMBINE
 player team runs      CSK: Dhoni 161  ┐
 Kohli  RCB  741            Jadeja 280 ┘ -> 441               team
 Rohit  MI   417       GT : Gill   890   -> 890                CSK      441
 Dhoni  CSK  161  -->  MI : Rohit  417  ┐                -->   GT       890
 Gill   GT   890            Bumrah  15  │ -> 1037              MI      1037
 Jadeja CSK  280            Surya  605  ┘                      RCB     1471
 Bumrah MI    15       RCB: Kohli  741  ┐
 Faf    RCB  730            Faf    730  ┘ -> 1471
 Surya  MI   605

Syntax

df.groupby(by, sort=True, as_index=True, dropna=True, observed=True)
df.groupby("team")["runs"].sum()              # one column  -> Series
df.groupby("team")[["runs", "wickets"]].sum() # many columns -> DataFrame
df.groupby(["season", "team"])["runs"].sum()  # many keys   -> MultiIndex

Example — the GroupBy object is lazy

g = df.groupby("team")
print(g)
print(g.ngroups)
print(g.groups)

<pandas.api.typing.DataFrameGroupBy object at 0x00000145AF369FD0>
4
{'CSK': [2, 4], 'GT': [3], 'MI': [1, 5, 7], 'RCB': [0, 6]}

How it works: groupby() alone computes nothing visible — it returns a DataFrameGroupBy object that remembers which row labels belong to which group (.groups). Only when you call an aggregate does the apply + combine happen. (The memory address will be different on your machine.)

Example — one key, one or more columns

print(df.groupby("team")["runs"].sum())
print(df.groupby("team")[["runs", "wickets"]].sum())

team
CSK     441
GT      890
MI     1037
RCB    1471
Name: runs, dtype: int64
      runs  wickets
team
CSK    441       20
GT     890        0
MI    1037       20
RCB   1471        0

How it works: single brackets ["runs"] select one column → the result is a Series. Double brackets [["runs", "wickets"]] select a list → the result is a DataFrame. Keys are sorted alphabetically (sort=True). Add .sort_values(ascending=False) to rank teams by total.

Note (pandas 3): df.groupby("team").mean() raises TypeError: dtype 'str' does not support operation 'mean' because the player column is text. Select number columns first, or use .mean(numeric_only=True).

Example — as_index=False keeps the key as a column

print(df.groupby("team", as_index=False)["runs"].sum())

  team  runs
0  CSK   441
1   GT   890
2   MI  1037
3  RCB  1471

This is identical to df.groupby("team")["runs"].sum().reset_index(). Use it when you want a flat table (e.g. to merge or export next).

Example — group by many columns

scores = pd.DataFrame({
    "season": [2023, 2023, 2023, 2023, 2024, 2024, 2024, 2024],
    "team":   ["MI", "CSK", "MI", "CSK", "MI", "CSK", "MI", "CSK"],
    "player": ["Rohit", "Gaikwad", "Surya", "Dube", "Rohit", "Gaikwad", "Surya", "Dube"],
    "runs":   [332, 590, 605, 418, 417, 583, 345, 396],
})
r = scores.groupby(["season", "team"])["runs"].sum()
print(r)
print(r.loc[(2024, "MI")])

season  team
2023    CSK     1008
        MI       937
2024    CSK      979
        MI       762
Name: runs, dtype: int64
762

How it works: with a list of keys, every unique combination (2023-CSK, 2023-MI, …) is one group. The result has a MultiIndex (two index levels). Read one value with a tuple: r.loc[(2024, "MI")]. r.unstack() turns the inner level into columns (a mini pivot table — see the Pivot & Reshape chapter).

Example — get_group() and looping over groups

print(df.groupby("team").get_group("MI"))

for team, group in df.groupby("team"):
    print(team, "->", len(group), "players, total runs", group["runs"].sum())

   player team  runs  wickets  matches
1   Rohit   MI   417        0       14
5  Bumrah   MI    15       20       13
7   Surya   MI   605        0       16
CSK -> 2 players, total runs 441
GT -> 1 players, total runs 890
MI -> 3 players, total runs 1037
RCB -> 2 players, total runs 1471

How it works: get_group(key) returns the sub-DataFrame of one group (for many keys pass a tuple: get_group((2024, "CSK"))). Iterating a GroupBy yields (key, sub_dataframe) pairs — useful for printing or custom reports, but for calculations prefer the built-in aggregates (they are much faster than a Python loop).

Other handy group methods

Common mistakes

• ❌ print(df.groupby("team")) and expecting a table. ✅ Call an aggregate: df.groupby("team")["runs"].sum().
• ❌ df.groupby("team").mean() on a frame with text columns. ✅ Select number columns or pass numeric_only=True.
• ❌ Forgetting the result's index is the key, then trying result["team"]. ✅ Use as_index=False or .reset_index().
• ❌ Writing a for loop with df[df["team"] == t] for every team. ✅ One groupby call does all teams at once.
• ❌ Losing rows with a missing key without noticing. ✅ dropna=False keeps a NaN group.

Interview tip

Q: Explain split-apply-combine. A: groupby splits the rows into groups by the key's values, applies a function (aggregate, transform or filter) to each group independently, then combines the results into one object indexed by the group keys. It replaces manual loops over filtered subsets.