Get Python code reviewed for idiomaticity, not just correctness

Review this code for idiomaticity — assume it already works. Your job is to say where it doesn't read like Python an experienced developer would write, and why the idiomatic version is actually better, not just different or shorter.

CODE
def get_config(name, cache={}):\n    if cache.get(name) == None:\n        cache[name] = load_from_disk(name)\n    return cache[name]

TARGET PYTHON VERSION
3.12 — flag anything that's idiomatic for an older version but has a cleaner equivalent available now (e.g. pre-3.10 code that could use structural pattern matching, or manual dict-default handling that could use dict.setdefault, defaultdict, or the walrus operator where it genuinely improves clarity rather than just being clever).

STYLE GUIDE
follows Black formatting and Ruff's default rule set; no third-party lint config beyond that

TEAM CONTEXT
A team of mostly backend Java developers new to Python; prefer explicit code over dense one-liners.

REVIEW CATEGORIES
1. Pythonic idioms — list, dict, or set comprehensions where a manual loop is just building a collection; enumerate or zip instead of manual indexing; context managers for anything with cleanup; pathlib.Path instead of os.path string joining.
2. Truthiness and comparisons — "if not x" versus "if x is None" used correctly, since they are not interchangeable for empty collections versus None; "is" and "is not" for None and singleton checks; never "== None".
3. Mutability bugs — mutable default arguments, accidental aliasing, modifying a list while iterating over it.
4. Error handling style — specific exception types over a bare except with no type, using exceptions for genuinely exceptional cases rather than control flow, not catching and re-raising without adding information.
5. Naming and structure — does a function do one thing; is a "utils" grab-bag hiding what should be several named functions.
6. Iteration and laziness — a generator or itertools-based approach where the code builds a full intermediate list just to iterate over it once and discard it; unnecessary calls to list() or sorted() on something that only needed to be iterated once.

OUTPUT FORMAT
For each finding: category, the line or snippet, what's non-idiomatic about it, the idiomatic rewrite, and one sentence on why it's actually better, not just shorter. If a "clever" one-liner would be less readable than the original, say so explicitly and leave it — idiomatic doesn't mean maximally compact. Weigh every finding against A team of mostly backend Java developers new to Python; prefer explicit code over dense one-liners. — a rewrite that's more idiomatic in isolation but harder for this specific team to maintain is a finding worth flagging as optional, not mandatory.
End with a verdict: how many findings per category, and whether the code is idiomatic enough to ship as-is or needs the listed changes first, stated plainly enough that a reviewer skimming only the verdict still knows what to do next.