apply() on a Series

Pandas has ready-made methods for common jobs — sum(), round(), .str.upper(), and so on. But real analysis always needs some custom logic that pandas does not ship with: "give each batter a rating — Excellent for 100+, Good for 50+, otherwise Average". You could write a for loop, but pandas gives you a cleaner tool: apply(). You write the logic once, as a normal Python function, and pandas calls it for every value.

This is the topic of video "08b apply()" and notebook 12 of the course.

Definition

Series.apply(func) calls the function func once for every element of the Series, passing the element as the first argument, and collects the return values into a new Series with the same index. The original Series is not changed.

• Once for every element — if the Series has 5 values, your function runs 5 times, each time receiving one plain value (an int, a str, a float…).
• Same index — the result lines up with the original, so you can store it straight into a new column: df["rating"] = df["runs"].apply(rating).
• New Series — apply never modifies the data in place; you must assign the result.
• If your function returns a Series instead of a single value, pandas builds a DataFrame (one column per key) — see the third example.

Syntax

series.apply(func, args=(), *, by_row="compat", **kwargs)

Note (pandas 3): older tutorials show Series.apply(func, convert_dtype=False). The convert_dtype parameter was removed in pandas 3 — if you need a specific dtype, call .astype(...) on the result.

Example — a custom rating for every score

import pandas as pd

runs = pd.Series([120, 45, 75, 30, 95],
                 index=["Virat", "Rohit", "Dhoni", "Gill", "Rahul"], name="runs")

def rating(r):
    if r >= 100:
        return "Excellent"
    elif r >= 50:
        return "Good"
    else:
        return "Average"

print(runs.apply(rating))

Virat    Excellent
Rohit      Average
Dhoni         Good
Gill       Average
Rahul         Good
Name: runs, dtype: str

How it works: pandas called rating(120), rating(45), rating(75)… one by one and put the 5 answers into a new Series. The index (player names) and the name runs are kept. Because the function returned text, the result has the pandas 3 str dtype.

Note: pass the function name — apply(rating) — not apply(rating()). With brackets you would call the function yourself (with no argument) and get an error.

Example — extra arguments with args and keywords

Sometimes the function needs more than the value. args (a tuple) and keyword arguments are forwarded to your function:

def add_bonus(r, bonus, cap=150):
    return min(r + bonus, cap)

print(runs.apply(add_bonus, args=(40,)))
print(runs.apply(add_bonus, args=(40,), cap=130))

Virat    150
Rohit     85
Dhoni    115
Gill      70
Rahul    135
Name: runs, dtype: int64
Virat    130
Rohit     85
Dhoni    115
Gill      70
Rahul    130
Name: runs, dtype: int64

How it works: for Virat, pandas calls add_bonus(120, 40) → min(160, 150) = 150. In the second call it calls add_bonus(120, 40, cap=130) → 130. Note the comma in args=(40,) — without it, (40) is just the number 40, not a tuple.

Example — built-ins, ufuncs and returning several values

apply accepts any callable: built-in functions like len, string methods like str.upper, and NumPy functions:

import numpy as np

names = pd.Series(["virat kohli", "rohit sharma", "ms dhoni"])
print(names.apply(len))
print(names.apply(lambda s: s.split()[-1].title()))
print(runs.apply(np.sqrt).round(2))

0    11
1    12
2     8
dtype: int64
0     Kohli
1    Sharma
2     Dhoni
dtype: str
Virat    10.95
Rohit     6.71
Dhoni     8.66
Gill      5.48
Rahul     9.75
Name: runs, dtype: float64

If the function returns a Series, every key becomes a column and you get a DataFrame back:

print(runs.apply(lambda r: pd.Series({"tens": r // 10, "units": r % 10})))

       tens  units
Virat    12      0
Rohit     4      5
Dhoni     7      5
Gill      3      0
Rahul     9      5

Tip: runs.apply(np.sqrt) works, but np.sqrt(runs) gives the same answer much faster because it is vectorised (one C loop instead of one Python call per value). Use apply for logic that has no built-in vectorised version — like the if/elif/else rating above.

apply vs map vs vectorised code on a Series

Common mistakes

• ❌ df["runs"].apply(rating()) ✅ df["runs"].apply(rating) — pass the function, don't call it.
• ❌ args=(40) ✅ args=(40,) — args must be a tuple.
• ❌ Expecting runs.apply(...) to change runs. ✅ Assign it: df["rating"] = df["runs"].apply(rating).
• ❌ Using apply for simple maths (apply(lambda x: x * 2)). ✅ Write s * 2 — it is clearer and many times faster.

Interview tip

Q: What is the difference between Series.apply and Series.map? A: Both run element-wise. apply only takes a callable but can forward extra arguments (args, kwargs) and can expand a returned Series into a DataFrame. map also accepts a dict or Series for look-up style replacement, and has na_action="ignore" to skip missing values.