apply() on a DataFrame

On a DataFrame, apply does not work value-by-value. It hands your function a whole column or a whole row at a time. That is exactly what you need when a decision depends on several columns — "a player is a Match Winner if he scored 100+ runs or took 8+ wickets". This is the main pattern from video "08b apply()" and notebook 12.

   player  runs  balls  wickets
0   Virat   120     70        0
1   Rohit    45     50        0
2   Dhoni    75     60        0
3  Bumrah    10     12       10
4  Jadeja    50     35        6

Definition

DataFrame.apply(func, axis=0) calls func once for each column (axis=0, the default) or once for each row (axis=1). Each call receives that column or row as a Series. If every call returns a single value, the result is a Series; if every call returns a Series (or list-like with result_type="expand"), the result is a DataFrame.

• axis=0 → per column — the function receives a column Series (index = row labels). Think "go down the rows". Typical use: a summary per column.
• axis=1 → per row — the function receives a row Series (index = column names), so you write row["runs"], row["wickets"]. Typical use: a new value per row built from several columns.
• Series in, value or Series out — what you return decides the shape of the result.

axis=0  (default)                  axis=1
func(column) for each column       func(row) for each row
   runs balls wkts                    runs balls wkts
    ↓    ↓    ↓                   →  120   70    0   → func(row 0)
   120   70    0                  →   45   50    0   → func(row 1)
    45   50    0                  →   75   60    0   → func(row 2)
result: 1 value per column         result: 1 value per row

Syntax

df.apply(func, axis=0, raw=False, result_type=None, args=(), **kwargs)

Example — axis=0: one result per column

import pandas as pd

df = pd.DataFrame({
    "player": ["Virat", "Rohit", "Dhoni", "Bumrah", "Jadeja"],
    "runs": [120, 45, 75, 10, 50],
    "balls": [70, 50, 60, 12, 35],
    "wickets": [0, 0, 0, 10, 6],
})
nums = df[["runs", "balls", "wickets"]]
print(nums.apply(max))
print(nums.apply(lambda col: col.max() - col.min()))

runs       120
balls       70
wickets     10
dtype: int64
runs       110
balls       58
wickets     10
dtype: int64

How it works: with the default axis=0 the function ran 3 times — once for the runs column, once for balls, once for wickets. Each call returned one number, so the result is a Series indexed by column name. (We selected only numeric columns because max - min makes no sense for player names.)

If the function returns a whole column, you get a DataFrame of the same shape back — a quick way to scale every column:

print(nums.apply(lambda col: col / col.max()).round(2))

   runs  balls  wickets
0  1.00   1.00      0.0
1  0.38   0.71      0.0
2  0.62   0.86      0.0
3  0.08   0.17      1.0
4  0.42   0.50      0.6

Example — axis=1: one result per row (the course pattern)

def impact(row):
    if row["runs"] >= 100 or row["wickets"] >= 8:
        return "Match Winner"
    elif row["runs"] >= 50 or row["wickets"] >= 4:
        return "Good"
    else:
        return "Average"

df["impact"] = df.apply(impact, axis=1)
print(df)

   player  runs  balls  wickets        impact
0   Virat   120     70        0  Match Winner
1   Rohit    45     50        0       Average
2   Dhoni    75     60        0          Good
3  Bumrah    10     12       10  Match Winner
4  Jadeja    50     35        6          Good

How it works: with axis=1 pandas passes each row as a Series whose index is the column names, so row["runs"] and row["wickets"] work. The function ran 5 times (once per player) and the 5 labels became the new impact column. This is the right tool when the logic mixes several columns with if/elif/else.

Example — return a Series to create several columns at once

def stats(row):
    return pd.Series({
        "strike_rate": round(row["runs"] / row["balls"] * 100, 1),
        "points": row["runs"] + row["wickets"] * 20,
    })

print(df.apply(stats, axis=1))

   strike_rate  points
0        171.4   120.0
1         90.0    45.0
2        125.0    75.0
3         83.3   210.0
4        142.9   170.0

How it works: each row returned a 2-item Series, so pandas stacked them into a 2-column DataFrame. Attach it with df.join(df.apply(stats, axis=1)). Notice points came out as float (120.0): a returned Series holding a float and an int is upcast to float64. Use .astype({"points": int}) if that matters.

Example — result_type: list results

If the function returns a list, pandas by default keeps each list as a single object. result_type="expand" spreads it into columns, and "broadcast" repeats a single value across the original columns:

print(nums.apply(lambda row: [row["runs"], row["balls"]], axis=1))
print(nums.apply(lambda row: [row["runs"], row["balls"]], axis=1, result_type="expand"))
print(nums.apply(lambda row: row.max(), axis=1, result_type="broadcast"))

0    [120, 70]
1     [45, 50]
2     [75, 60]
3     [10, 12]
4     [50, 35]
dtype: object
     0   1
0  120  70
1   45  50
2   75  60
3   10  12
4   50  35
   runs  balls  wickets
0   120    120      120
1    50     50       50
2    75     75       75
3    12     12       12
4    50     50       50

Example — extra arguments

def points(row, run_w, wkt_w):
    return row["runs"] * run_w + row["wickets"] * wkt_w

print(df.apply(points, axis=1, args=(1, 25)))

0    120
1     45
2     75
3    260
4    200
dtype: int64

When NOT to use apply(axis=1)

axis=1 calls a Python function once per row and builds a Series object for each row — it is the slowest common pattern in pandas. For plain arithmetic, write the column expression directly:

df["points"] = df["runs"] + df["wickets"] * 20          # vectorised — fast
df["points"] = df.apply(lambda r: r["runs"] + r["wickets"] * 20, axis=1)  # same result, slow

For if/else labels, np.where / np.select (see Conditional Columns) are vectorised alternatives. Keep apply(axis=1) for genuinely complex row logic on small-to-medium data.

Common mistakes

• ❌ Forgetting axis=1 and writing row["runs"] — with the default axis=0 the function receives columns, so col["runs"] raises KeyError: 'runs'. ✅ df.apply(func, axis=1) for row logic.
• ❌ Applying a numeric function to a DataFrame that still has text columns. ✅ Select numeric columns first: df[["runs", "balls"]].apply(...) or df.select_dtypes("number").
• ❌ raw=True and then row["runs"]. ✅ With raw=True the row is a NumPy array — use positions, or keep raw=False.
• ❌ Using apply(axis=1) for simple column maths on 1 million rows. ✅ Use vectorised column expressions.

Comparison — axis=0 vs axis=1

Interview tip

Q: In df.apply(f, axis=1), what does f receive, and why is it slow? A: Each row, as a Series whose index is the column names. It is slow because pandas creates a new Series object and calls a Python function for every single row — a Python-level loop — whereas vectorised column operations run in one compiled loop.