bytes vs bytearray: Mutate/Copy Lab

Intro — what this post promises

When does bytes immutability force copies that bytearray avoids? This lab times append / extend / join, one-byte mutation, and 4 KiB copy/slice paths on Linux localhost.

Related links:

• 01shoppercove.comarray vs list ints localhost lab
• 02shoppercove.comstruct.pack vs to_bytes localhost lab
• 03shoppercove.comstring concat vs join localhost lab
• 04shoppercove.comcopy vs deepcopy localhost lab
• 05shoppercove.comfrozenset vs set membership localhost lab
• 06shoppercove.comcontextlib vs try/finally localhost lab
• 07shoppercove.comenum vs constants localhost lab
• 08shoppercove.comperf_counter vs time localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. Affiliates: 0. Note: on this CPython, b[:] is the same object as b (bytes_slice_is_same_object=True) — slice is not a defensive copy for bytes.

Verdict up front: bytearray.append ~36M/s vs bytes + one byte ~8.0M (~4.4×). Chunked b + chunk ~338× behind bytearray extend; b"".join ≈ extend (~1.06×). Mutating one byte in a 64 KB buffer: bytearray index assign ~107× a bytes rebuild-via-concat.

Arms

Lab topology

append loops: 20k × 1 byte; chunk loops: 5k × 64 bytes
mutate: 50k edits on 64KB buffer
copy: 20k × 4096-byte buffers
metric: p50 ops/s

Script: lab-evidence/63-bytes-vs-bytearray/results/run_lab.py.

Lead table — build / append (p50)

Mutate — when copy dominates

One-byte edit on 64 KB: rebuild copies ~64 KB each time (~3923 ns) vs in-place assign (~37 ns) — ~107×.

Copy / slice (4 KiB)

b[:] looking “fast” here is partly because it returns the same object — not a copy. Need isolation? Use bytes(b) / bytearray(b) / memoryview deliberately.

Reading it

• Never grow bytes with + in a loop — chunked concat was ~338× slower than extend; join fixes immutable builds.
• bytearray for mutate-in-place protocols — parsers, checksums, ring buffers.
• bytes for sharing / hashing / dict keys — immutable and hashable.
• Copy cost scales with size — the 64 KB rebuild arm is the honesty check.

Pitfalls

1. b[:] as a defensive copy — may be identity on CPython bytes.
2. Quadratic b = b + chunk — join or bytearray instead.
3. Sharing a bytearray across threads/tasks without sync — mutation races.
4. Converting bytearray→bytes every step — reintroduces copies.

When to pick what

Reproduce

python3 lab-evidence/63-bytes-vs-bytearray/results/run_lab.py

Evidence: /workspace/lab-evidence/63-bytes-vs-bytearray/results/.

Closing

Immutability copies; bytearray mutates. On this box append beat one-byte concat ~4.4×, chunked concat trailed extend by ~338×, and a 64 KB one-byte rebuild trailed index assign by ~107×. Use join when you must stay on bytes; use bytearray when the buffer must change.