Cleaning the argument list before passing it to the constructor is probably the best way to go about it. I’d advice against writing your own __init__ function though, since the dataclass’ __init__ does a couple of other convenient things that you’ll lose by overriding it. Also, since the argument-cleaning logic is very tightly bound to … Read more
The simple solution is to just implement the default arguments in __post_init__() only! @dataclass class Specs2: a: str b: str c: str def __post_init__(self): if self.b is None: self.b = ‘Bravo’ if self.c is None: self.c=”Charlie” (Code is not tested. If I got some detail wrong, it wouldn’t be the first time)
In most cases where you would have used __dict__ without dataclasses, you should probably keep using __dict__, maybe with a copy call. asdict does a lot of extra work that you may not actually want. Here’s what it does. First, from the docs: Each dataclass is converted to a dict of its fields, as name: … Read more
To create a class variable, annotate the field as a typing.ClassVar or not at all. from typing import ClassVar from dataclasses import dataclass @dataclass class Foo: ivar: float = 0.5 cvar: ClassVar[float] = 0.5 nvar = 0.5 foo = Foo() Foo.ivar, Foo.cvar, Foo.nvar = 1, 1, 1 print(Foo().ivar, Foo().cvar, Foo().nvar) # 0.5 1 1 print(foo.ivar, … Read more
The type hint of dataclass attributes is never obeyed in the sense that types are enforced or checked. Mostly static type checkers like mypy are expected to do this job, Python won’t do it at runtime, as it never does. If you want to add manual type checking code, do so in the __post_init__ method: … Read more
The dataclasses.replace function returns a new copy of the object. Without passing in any changes, it will return a copy with no modification: >>> import dataclasses >>> @dataclasses.dataclass … class Dummy: … foo: int … bar: int … >>> dummy = Dummy(1, 2) >>> dummy_copy = dataclasses.replace(dummy) >>> dummy_copy.foo = 5 >>> dummy Dummy(foo=1, bar=2) … Read more
The napoleon-style docstrings as they are described in the sphinx docs (see the ExampleError class for their take on it) explicitly touch on your case: The __init__ method may be documented in either the class level docstring, or as a docstring on the __init__ method itself. And if you do not want this behavior, you … Read more
Inspecting __annotations__ gives you the raw annotations, but those don’t necessarily correspond to a dataclass’s field types. Things like ClassVar and InitVar show up in __annotations__, even though they’re not fields, and inherited fields don’t show up. Instead, call dataclasses.fields on the dataclass, and inspect the field objects: field_types = {field.name: field.type for field in … Read more
It sure does work: from dataclasses import dataclass @dataclass class Test: _name: str=”schbell” @property def name(self) -> str: return self._name @name.setter def name(self, v: str) -> None: self._name = v t = Test() print(t.name) # schbell t.name = “flirp” print(t.name) # flirp print(t) # Test(_name=”flirp”) In fact, why should it not? In the end, what … Read more
Instead of checking for type equality, you should use isinstance. But you cannot use a parametrized generic type (typing.List[int]) to do so, you must use the “generic” version (typing.List). So you will be able to check for the container type but not the contained types. Parametrized generic types define an __origin__ attribute that you can … Read more