Python dataclass inheritance with class variables

Question

Consider the following example code

from dataclasses import dataclass, field
from typing import ClassVar


@dataclass
class Base:
    x: str = field(default='x', init=False)


@dataclass
class A(Base):
    name: str


@dataclass
class B(Base):
    name: str


a = A('test_a')
b = B('test_b')

a.x = 'y'
a.x  # prints 'y'
b.x  # prints 'x'

which prints 'y' and 'x' as expected.

Now I'd like to make x a ClassVar of type dict:

from dataclasses import dataclass, field
from typing import ClassVar, Dict


@dataclass
class Base:
    x: ClassVar[Dict[str, str]] = field(default={'x': 'x'}, init=False)


@dataclass
class A(Base):
    name: str


@dataclass
class B(Base):
    name: str


a = A('test_a')
b = B('test_b')

a.x['y'] = 'y'
a.x
b.x

However, now the output is

a.x => {'x': 'x', 'y': 'y'}
b.x => {'x': 'x', 'y': 'y'}

I'd expect that only a.x gets modified and b.x stays at the default init value `{'x': 'x'}.

If the field would not be a ClassVar then I could use the default_factory=dict but that doesn't work in combination with ClassVar since it returns the error

 Field cannot have a default factory

default={'x': 'x'} means that all instances using the default value share a reference to the same dictionary. If you can't use default_factory instead this seems unavoidable. — jonrsharpe
– jonrsharpe, Commented Jan 4, 2021 at 10:29
@jonrsharpe Update with the error I get from using default_factory, it doesn't seem to be compatible — wasp256
– wasp256, Commented Jan 4, 2021 at 10:34

Arne · Accepted Answer · 2021-01-06 15:13:22Z

Class variables are shared between the parent and all child classes, so what you seem to want (a class variable that is declared in a parent, but child classes get their own copy they can manipulate) is conceptually impossible.

If you want to do it properly, you have to re-declare the class variable in every child:

from dataclasses import dataclass
from typing import ClassVar, Dict


@dataclass
class Base:
    x: ClassVar[Dict[str, str]] = {'x': 'x'}


@dataclass
class A(Base):
    x: ClassVar[Dict[str, str]] = {'x': 'x'}
    name: str


@dataclass
class B(Base):
    x: ClassVar[Dict[str, str]] = {'x': 'x'}
    name: str

a = A('test_a')
b = B('test_b')

a.x['y'] = 'y'
a.x
b.x

Which now gives

a.x => {'x': 'x', 'y': 'y'}
b.x => {'x': 'x'}

But if that is too cumbersome or impractical, I have this nifty footgun for you. Rather than using ClassVars, it just programs your requirements explicitly into the base class as a function, and makes it look like an attribute with the @property decorator:

from dataclasses import dataclass
from typing import Dict


@dataclass
class Base:

    @property
    def x(self) -> Dict[str, str]:
        cls = type(self)
        # first call per child class instance will initialize a proxy
        if not hasattr(cls, "_x"):
            setattr(cls, "_x", {"x": "x"})  # store the actual state of "x" in "_x"
        return getattr(cls, "_x")


@dataclass
class A(Base):
    name: str


@dataclass
class B(Base):
    name: str


a_1 = A('test_a_1')
a_2 = A('test_a_2')
b = B('test_b')

a_1.x['y'] = 'y'
a_1.x
a_2.x
b.x

This correctly shares x only among child-class instances as well, but without you needing to write an additional line into each new child:

a.x => {'x': 'x', 'y': 'y'}
a_1.x => {'x': 'x', 'y': 'y'}
b.x => {'x': 'x'}

One caveat is that, unlike with ClassVars, you can't call a property on the class without having an instance, e.g. A.x won't work. But it seems you weren't trying to do that anyway.

sahasrara62 · Accepted Answer · 2021-01-04 10:55:33Z

1

maybe using __post_init__ you can solve this

@dataclass
class Base:
    # x: ClassVar[Dict[str, str]] = field(default=dict(val), init=False)
    def __post_init__(self) :
        self.x = {'x':'x'}

answered Jan 4, 2021 at 10:55

sahasrara62

11.4k3 gold badges35 silver badges48 bronze badges

Comments

Marcel Wilson · Accepted Answer · 2025-05-09 21:41:26Z

This is possible utilizing __init_subclass__ to set the variable on each of the subclasses. It is called when initializing the subclass itself (not the instance).

from dataclasses import dataclass
from typing import ClassVar, Dict


@dataclass
class Base:
    x: ClassVar[Dict[str, str]]
    def __init_subclass__(cls):
        cls.x = {'x': 'x'}

@dataclass
class A(Base):
    name: str


@dataclass
class B(Base):
    name: str

a = A('test_a')
b = B('test_b')

a.x['y'] = 'y'
print(a.x)
print(b.x)

output:

{'x': 'x', 'y': 'y'}
{'x': 'x'}

Collectives™ on Stack Overflow

Python dataclass inheritance with class variables

3 Answers 3

Comments

Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Related