itemgetter vs lambda: Sort Key Lab

Intro — what this post promises

Sorting with key=: is operator.itemgetter / attrgetter worth it over a lambda? This lab times key extraction alone and full list.sort on tuples, dicts, and small objects on Linux localhost.

Related links:

• sorted vs heapq vs bisect localhost lab
• dataclass vs slots vs dict localhost lab
• set vs list membership localhost lab
• lru_cache hit vs miss localhost lab
• itertools vs python loops localhost lab
• array vs list ints localhost lab
• copy vs deepcopy localhost lab
• perf_counter vs time localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. N=50,000. Affiliates: 0. Sort arms copy the list each run so input order stays fair.

Verdict up front: extract — tuple itemgetter ~57M/s vs map(lambda…) ~36M (~1.61×). Sort gaps shrink: tuple itemgetter vs lambda ~1.11×; attrgetter vs lambda ~1.07×. Prefer itemgetter for clarity + a free few percent; Timsort dominates wall time.

Arms

Lab topology

N = 50000 random rows
Extract: build list of keys
Sort: xs = data[:]; xs.sort(key=…)
Metric: p50 ops/s (elements)

Script: lab-evidence/59-itemgetter-vs-lambda-sort/results/run_lab.py.

Lead table — extract only (p50)

Lead table — full sort (p50)

Reading it

• itemgetter / attrgetter are C callables — they beat a Python lambda on the extract microbench (~1.6× / ~1.16×).
• Sort is mostly Timsort — the key function still runs O(n) times, but the relative gap compresses to roughly 6–11% here.
• Bare t[1] beats itemgetter on extract — itemgetter shines as a reusable key= object, not as a replacement for a one-line index in a comprehension.
• methodcaller was the slowest extract path (~46 ns); fine for clarity, not a speed pick.

Pitfalls

1. Optimizing key= before profiling sort size — N=50k is ~10 ms either way.
2. Multi-field keys — itemgetter(1, 2) still wins vs a tuple-building lambda (same pattern).
3. Mutating during sort — undefined; this lab copies first.
4. Assuming lambda is “slow” in absolute terms — nanoseconds, not milliseconds, per call.

When to pick what

Reproduce

python3 lab-evidence/59-itemgetter-vs-lambda-sort/results/run_lab.py

Evidence: /workspace/lab-evidence/59-itemgetter-vs-lambda-sort/results/.

Closing

itemgetter is a small, real win. On this box extract tuple itemgetter ~1.6× a lambda map; full sort still ~1.11× / attrgetter ~1.07× over lambda. Use operator helpers for hot key= paths; don’t rewrite a 1 ms sort for a 5% key shave.