Python Programming

🚀 Dataclasses + mutable defaults – the hidden trap and the clean fix

If you’ve ever written a class like this:

class Bag:
    def __init__(self, items=[]):
        self.items = items

you probably noticed a weird behavior: every new Bag() shares the same list. Adding an item to one bag magically appears in all the others. 😱

Why does this happen?

In Python, default argument values are evaluated only once – at function definition time. The empty list [] is created a single time and then stored in the function’s __defaults__. Every call that doesn’t supply its own items argument re‑uses that very same list object. The same rule applies to dataclasses because their generated __init__ works just like a normal function.

The dataclass‑friendly solution: field(default_factory=…)

dataclasses.field lets you specify a factory – a callable that is invoked each time a new instance is created. The factory returns a fresh object, so every instance gets its own independent mutable container.

from dataclasses import dataclass, field

@dataclass
class Bag:
    # ✅ each Bag gets its own list
    items: list = field(default_factory=list)
    # you can also use other factories, e.g. set() or dict()

How it works under the hood
- When the dataclass decorator builds Bag.__init__, it inserts items: list = field(default_factory=list).
- At call time, default_factory() is executed, producing a brand‑new list.
- The generated __init__ assigns that fresh list to self.items.

Because the factory is a callable, you can pass any function that returns the desired mutable type, even a lambda that captures external state.

Real‑world use case: building a tree of nodes

Imagine you’re modeling a simple filesystem:

from __future__ import annotations
from dataclasses import dataclass, field

@dataclass
class Node:
    name: str
    children: list[Node] = field(default_factory=list)

    def add_child(self, child: Node) -> None:
        self.children.append(child)

# Build a tiny hierarchy
root = Node("root")
root.add_child(Node("etc"))
root.add_child(Node("var"))
print(root)

If you had used children=[] directly, every Node would share the same children list, and adding a child to one node would magically appear under all others – a disaster for tree structures.

Edge case: custom factories with arguments

Sometimes you need a default that isn’t just an empty container, e.g. a list pre‑filled with a timestamp:

import datetime
from dataclasses import dataclass, field

def timestamped_list():
    # each instance gets its own list containing the creation time
    return [datetime.datetime.utcnow()]

@dataclass
class EventLog:
    entries: list[datetime.datetime] = field(default_factory=timestamped_list)

log1 = EventLog()
log2 = EventLog()
print(log1.entries, log2.entries)   # different timestamps

Because the factory is called every time a new EventLog is instantiated, each list carries its own unique data.

Quick checklist ✅

- Never use a mutable object ([], {}, set()) directly as a default value in a dataclass or function.
- Use field(default_factory=…) for dataclasses.
- For functions, replace the mutable default with None and create the object inside the body (if arg is None: arg = []).
- Remember: the factory can be any zero‑argument callable, giving you full flexibility.

💡 Takeaway: The default_factory pattern gives you the same convenience as a simple default argument, but without the shared‑state surprise. Your dataclasses will behave predictably, and you’ll avoid a whole class of subtle bugs that even seasoned developers stumble over. Happy coding! 🚀

11 viewsRams AI, 17:53