Counting & Distributions

Some of the most common analysis questions are just counting: "Which team won the most matches?", "What % of captains chose to field after winning the toss?", "How many different winners were there?". In the IPL notebook (06) Munna used exactly these: ipl["winner"].value_counts() and groupby(...).count().

Our match data for this topic (one winner is missing — a no-result):

m = pd.DataFrame({
    "season": [2022, 2022, 2022, 2023, 2023, 2023, 2023, 2024, 2024, 2024],
    "winner": ["GT", "RR", "GT", "CSK", "GT", "CSK", "MI", "KKR", "KKR", None],
    "toss_decision": ["field", "bat", "field", "field", "bat", "field", "field", "bat", "field", "field"],
})
print(m)

   season winner toss_decision
0    2022     GT         field
1    2022     RR           bat
2    2022     GT         field
3    2023    CSK         field
4    2023     GT           bat
5    2023    CSK         field
6    2023     MI         field
7    2024    KKR           bat
8    2024    KKR         field
9    2024    NaN         field

Definition

value_counts() returns a Series containing the count of each unique value, sorted from most to least frequent; with normalize=True it returns proportions (fractions that add up to 1) instead of counts.

nunique() returns the number of distinct (unique) values, ignoring NaN by default.

On a GroupBy, size() counts the rows in each group, while count() counts the non-missing values of each column in each group.

• Unique value — each different value ("GT", "CSK"…) becomes one index label of the result.
• Distribution — the table of "value → how often" tells you how the data is spread across categories.
• Proportion — count ÷ total non-missing values. Multiply by 100 for a percentage.

Syntax

Series.value_counts(normalize=False, sort=True, ascending=False, bins=None, dropna=True)
DataFrame.value_counts(subset=None, normalize=False, sort=True, ascending=False, dropna=True)
Series.nunique(dropna=True)
DataFrame.nunique(axis=0, dropna=True)
df.groupby(key).size()
df.groupby(key).count()

Example — counts and percentages

print(m["winner"].value_counts())
print((m["winner"].value_counts(normalize=True) * 100).round(1))

winner
GT     3
CSK    2
KKR    2
RR     1
MI     1
Name: count, dtype: int64
winner
GT     33.3
CSK    22.2
KKR    22.2
RR     11.1
MI     11.1
Name: proportion, dtype: float64

How it works: the unique winners become the index (named after the column, winner) and the Series is named count — or proportion with normalize=True. The missing winner is ignored, so the proportions are out of 9, not 10 (3/9 = 33.3%).

Note: since pandas 2.0 the result Series is named count / proportion and its index is named after the original column. Older tutorials show the column name as the Series name.

Example — including NaN, and turning the result into a table

print(m["winner"].value_counts(dropna=False))
print(m["winner"].value_counts().reset_index())

winner
GT     3
CSK    2
KKR    2
RR     1
MI     1
NaN    1
Name: count, dtype: int64
  winner  count
0     GT      3
1    CSK      2
2    KKR      2
3     RR      1
4     MI      1

.head(1) gives the most frequent value; value_counts(ascending=True) the rarest first; sort=False keeps first-appearance order.

Example — counting combinations

print(m[["season", "toss_decision"]].value_counts())

season  toss_decision
2023    field            3
2022    field            2
2024    field            2
2022    bat              1
2023    bat              1
2024    bat              1
Name: count, dtype: int64

DataFrame.value_counts() counts each unique row combination. The same idea per group is m.groupby("season")["winner"].value_counts(), and with normalize=True you get the share within each season:

print(m.groupby("season")["toss_decision"].value_counts(normalize=True).round(2))

season  toss_decision
2022    field            0.67
        bat              0.33
2023    field            0.75
        bat              0.25
2024    field            0.67
        bat              0.33
Name: proportion, dtype: float64

Example — nunique() and unique()

print(m["winner"].nunique())
print(m["winner"].nunique(dropna=False))
print(m["winner"].unique())
print(m.nunique())
print(m.groupby("season")["winner"].nunique())

5
6
<StringArray>
['GT', 'RR', 'CSK', 'MI', 'KKR', nan]
Length: 6, dtype: str
season           3
winner           5
toss_decision    2
dtype: int64
season
2022    2
2023    3
2024    1
Name: winner, dtype: int64

How it works: unique() lists the distinct values (in order of appearance, including nan); nunique() just counts them (excluding NaN unless dropna=False). Grouped, it answers "how many different winners per season?".

Note (pandas 3): unique() on a text column returns a StringArray with dtype str instead of a NumPy object array. Use .tolist() if you need a plain list.

Example — size() vs count()

print(m.groupby("season").size())
print(m.groupby("season").count())

season
2022    3
2023    4
2024    3
dtype: int64
        winner  toss_decision
season
2022         3              3
2023         4              4
2024         2              3

How it works: 2024 has 3 matches (size) but only 2 known winners (count skips the NaN). size() returns one Series (rows per group); count() returns one column per column.

Comparison

Careful: DataFrame.size (an attribute, no brackets) is rows × columns — m.size is 30 — not the number of rows. Use len(m) or m.shape[0] for rows.

Common mistakes

• ❌ Reading value_counts(normalize=True) as percentages. ✅ They are fractions; multiply by 100.
• ❌ Forgetting that NaN is excluded and the shares are of non-missing values only. ✅ Use dropna=False to see it.
• ❌ Using groupby().count() to count matches when some columns have NaN. ✅ Use groupby().size() for row counts.
• ❌ m.size to get the number of rows. ✅ len(m).

Interview tip

Q: How do you get the percentage share of each category in a column? A: df["col"].value_counts(normalize=True) * 100. Add dropna=False if missing values should count as a category.