pandas clip() — cap outliers and clamp values into a valid range

$ import pandas as pd

orders = pd.DataFrame({
    "order":   ["SO-1001", "SO-1002", "SO-1003", "SO-1004", "SO-1005"],
    "revenue": [1240.00, -80.50, 980.00, 99999.00, 310.75],
})
orders["billable"] = orders["revenue"].clip(lower=0, upper=5000)
print(orders.to_string(index=False))
print("gross:", orders["revenue"].sum(), "| billable:", orders["billable"].sum())

  order  revenue  billable
SO-1001  1240.00   1240.00
SO-1002   -80.50      0.00
SO-1003   980.00    980.00
SO-1004 99999.00   5000.00
SO-1005   310.75    310.75
gross: 102449.25 | billable: 7530.75

The bread-and-butter case: an ERP export where a credit note is stored as a negative and one typo added two digits. The frame keeps all five rows and the column keeps dtype float64 — only the totals move, from 102,449.25 to 7,530.75, which is the difference between a number you can send upstairs and one you cannot. Note what clip did NOT do: the -80.50 row still exists, it is just counted as 0.00, so a later count() or size() still sees the credit note and you can still investigate it. If you wanted the row gone you would be reaching for drop(), and you would be hiding the bug rather than containing it.

$ import pandas as pd

readings = pd.DataFrame({
    "station":   ["S-01", "S-02", "S-03", "S-04"],
    "temp_c":    [-40.0, 21.4, 88.0, 22.6],
    "press_kpa": [101.3, 990.0, 101.1, 100.9],
})
readings[["temp_c", "press_kpa"]] = readings[["temp_c", "press_kpa"]].clip(
    lower={"temp_c": -30.0, "press_kpa": 95.0},
    upper={"temp_c": 60.0, "press_kpa": 110.0},
)
print(readings.to_string(index=False))

station  temp_c  press_kpa
   S-01   -30.0      101.3
   S-02    21.4      110.0
   S-03    60.0      101.1
   S-04    22.6      100.9

This is the form I keep in production scripts: one dict per direction, keyed by column name, applied to a two-column slice. -40.0 and 88.0 are outside a temperature transmitter's own range, 990.0 kPa is a pressure spike, and all three get pulled to the spec limit while the other nine readings stay untouched — 101.3 is still 101.3, not rounded, not coerced. Two details worth noticing: the dict aligns on column names with no axis argument at all, and only the sliced columns are rewritten, so the station codes are physically outside the assignment. That is what makes this reviewable — the limits are data, not a chain of .loc masks.

$ import pandas as pd

tickets = pd.DataFrame({
    "ticket":          ["T-501", "T-502", "T-503", "T-504"],
    "first_reply_min": [-3, 95, 18, 240],
    "sla_min":         [15, 60, 30, 120],
})
tickets["counted_min"] = tickets["first_reply_min"].clip(lower=0, upper=tickets["sla_min"])
print(tickets.to_string(index=False))
print("SLA breaches after counting:", (tickets["first_reply_min"] > tickets["sla_min"]).sum())

ticket  first_reply_min  sla_min  counted_min
 T-501               -3       15            0
 T-502               95       60           60
 T-503               18       30           18
 T-504              240      120          120
SLA breaches after counting: 2

Here the ceiling is not a constant, it is another column, so each row gets its own limit: a 240-minute reply on a 120-minute SLA is counted as 120, and a reply before the clock started (-3) is counted as 0 instead of quietly crediting the agent. Series-against-Series needs no axis — alignment is on the index — so this composes with groupby and with merge results. The printed line underneath is the habit that keeps you honest: after clamping, `first_reply_min > sla_min` still finds the 2 rows that breached, because clip contained the duration without erasing the fact.

$ import pandas as pd

now = pd.Timestamp("2026-10-11 09:00:00")
log = pd.DataFrame({
    "meter": ["M-0412", "M-0413", "M-0414", "M-0415"],
    "last_seen": pd.to_datetime([
        "2026-10-11 08:12:00",
        "2026-10-12 14:03:00",
        None,
        "2026-10-10 23:40:00",
    ]),
})
log["last_seen_capped"] = log["last_seen"].clip(upper=now)
print(log.to_string(index=False))
print("capped rows:", (log["last_seen"] != log["last_seen_capped"]).sum())

 meter           last_seen    last_seen_capped
M-0412 2026-10-11 08:12:00 2026-10-11 08:12:00
M-0413 2026-10-12 14:03:00 2026-10-11 09:00:00
M-0414                 NaT                 NaT
M-0415 2026-10-10 23:40:00 2026-10-10 23:40:00
capped rows: 2

clip is not a numeric method, it is a comparison method, so datetimes work the same way: a meter whose clock ran into tomorrow gets pulled back to now, and rows that were already in the past are untouched. NaT stays NaT — clip never fills, so .dropna() and .fillna() downstream still see the two rows with no timestamp. Two notes for real logs: both bounds must be scalars or a single array, and if you swap them the min/max reorder quietly fixes it rather than complaining; and this is the line that makes "no future timestamps" enforceable in a test instead of a convention.