itertools vs Python loops Lab

Intro — what this post promises

Is itertools “always faster” than a for loop? This lab compares chain, islice, and accumulate to equivalent pure-Python loops on N=500,000 ints on Linux localhost — plus the anti-pattern of concatenating lists first.

Related links:

• copy vs deepcopy localhost lab
• lru_cache hit vs miss localhost lab
• python re vs str methods localhost lab
• string concat vs join localhost lab
• set vs list membership localhost lab
• json vs orjson vs msgpack localhost lab
• struct pack vs to_bytes localhost lab
• sorted vs heapq vs bisect localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. Work is summing/+= over range — not I/O. Affiliates: 0. ops/s = elements consumed ÷ p50 wall.

Verdict up front: chain ≈ two loops (0.95×). Materializing list(a)+list(b) is the loser (~1.99× slower than chain). islice beats enumerate+break (1.83×), but range(K) is still fastest if you can skip the parent iterator. accumulate ≈ manual running sum; bare sum(range) is the throughput king when you only need the total.

Arms

Lab topology

N = 500000; K = 50000 for islice arms
5 repeats, p50 wall → ops/s (elements/s)

Script: lab-evidence/55-itertools-vs-python-loops/results/run_lab.py.

Lead table — elements/s (p50)

Reading it

• chain is about clarity, not a free speedup vs two loops (~peer). It does beat building one big list first.
• islice wins when the source is a long iterator you cannot rewrite as range(K). The enumerate+break tax is real (~1.8×).
• accumulate vs manual is a wash (~1.06×). Prefer it for API/composition; don’t expect magic.
• sum() is in another class (~126M/s) — use it when you only need the aggregate.

Pitfalls

1. Materializing then iterating — list(a)+list(b) doubled the time here.
2. islice when range(K) works — skip the wrapper.
3. Assuming C itertools always wins — tight Python loops on range are already fast.
4. Comparing to sum unfairly — different result shape (scalar vs sequence of prefixes).

When to pick what

Reproduce

python3 lab-evidence/55-itertools-vs-python-loops/results/run_lab.py

Evidence: /workspace/lab-evidence/55-itertools-vs-python-loops/results/.

Closing

itertools is not automatically faster — it is often as fast, and safer than materializing. On this box chain ≈ two loops; list concat is ~0.5× slower. islice is ~1.8× enumerate+break. accumulate ≈ manual; sum(range) is ~126M/s when you only need the total. Choose for laziness and API — measure if the loop is hot.