dataclasses.asdict vs vars: Localhost Lab

Intro — what this post promises

Turn dataclasses into dicts with dataclasses.asdict vs vars() / dict(__dict__) / manual fields. This lab reports ops/s on Linux localhost, plus deep-vs-shallow behavior checks.

Related links:

• xml etree vs json localhost lab
• logging formatter vs fstring localhost lab
• fractions vs float localhost lab
• math fsum vs sum localhost lab
• sqlite3 vs shelve localhost lab
• gc collect cost localhost lab
• copy copy vs dict copy localhost lab
• html parser vs regex localhost lab

Lab honesty (1 Oct 2026 IST): Python 3.13.5. Affiliates: 0. Differentiates from dataclass-replace (lab 110) and slots (lab 43) — focus is asdict deepcopy semantics vs cheap vars.

Verdict up front (n=50000): vars flat ~26244997 ops/s; asdict flat ~712136; manual ~12349533; nested asdict ~502824 vs vars ~26083074.

Arms

Seven rounds, p50.

Lab topology

n=50000 · flat Event + Nested(Event) · 7 rounds · p50
metric: ops/s = n / p50_s

Script: lab-evidence/130-dataclass-asdict-vs-vars/results/run_lab.py.

Lead table (p50 ops/s)

vars led by roughly 36.9× on the flat arm — because it does not deep-copy.

Semantics (why the gap exists)

• asdict(nested)["event"] is a dict; vars(nested)["event"] is still an Event.
• asdict tags list is a new list (asdict_new_list=True); vars shares the same list (vars_same_list=True).

If you JSON-dump for a wire format, you usually want asdict (or a dedicated serializer). If you only need a shallow attribute bag for logging filters, vars is enough — and far cheaper.

Reading it for SRE work

• Export/metrics payload → asdict (or manual + json.dumps) so nested dataclasses become JSON-safe.
• Hot path “mirror attributes” → vars / __dict__ copy; never mutate shared lists casually.
• Lab 110 covers replace; this post is dict projection cost.
• Slots instances without __dict__ break vars — know your type.

Document which projection your exporters use so on-call does not “optimize” asdict into vars and ship non-JSON Event objects.

Nested cost

Nested asdict fell to ~502824 ops/s while nested vars stayed near ~26083074. Depth multiplies asdict work; vars stays O(fields on the outer object).

Manual vs asdict

A hand-built field dict hit ~12349533 ops/s — much closer to vars than to asdict, because it still shares the tags list reference unless you copy it yourself. Use manual dicts when you want a stable, shallow export schema without recursive deepcopy. Reach for asdict when nested dataclasses must become plain dict/list trees for JSON or msgpack.

If exporters disagree (one uses vars, one uses asdict), you will debug “sometimes tags mutate upstream” pages — lock one helper in the shared library.

Pitfalls

• Treating vars output as a deep snapshot.
• Mutating vars(obj)["tags"] and surprising the dataclass.
• Using asdict in a per-request hot path without measuring.
• Forgetting slots / __dict__-less objects.

Reproduce

python3 lab-evidence/130-dataclass-asdict-vs-vars/results/run_lab.py

Evidence: summary.json, summary.txt.

Limits

One Linux box. Stdlib dataclasses only. Not pydantic/msgspec.

Takeaway

vars ~26244997 ops/s vs asdict ~712136 on flat events — pick asdict when you need nested dicts and copied containers; pick vars when a shallow view is enough.