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
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
Much like you can add support to the JSON encoder for datetime objects or Decimals, you can also provide a custom encoder subclass to serialize dataclasses: import dataclasses, json class EnhancedJSONEncoder(json.JSONEncoder): def default(self, o): if dataclasses.is_dataclass(o): return dataclasses.asdict(o) return super().default(o) json.dumps(foo, cls=EnhancedJSONEncoder)
The prefered Syntax for a typed named tuple since 3.6 is from typing import NamedTuple class Point(NamedTuple): x: int y: int = 1 # Set default value Point(3) # -> Point(x=3, y=1) Edit Starting Python 3.7, consider using dataclasses (your IDE may not yet support them for static type checking): from dataclasses import dataclass @dataclass … Read more
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
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
The way dataclasses combines attributes prevents you from being able to use attributes with defaults in a base class and then use attributes without a default (positional attributes) in a subclass. That’s because the attributes are combined by starting from the bottom of the MRO, and building up an ordered list of the attributes in … Read more
Data classes are just regular classes that are geared towards storing state, rather than containing a lot of logic. Every time you create a class that mostly consists of attributes, you make a data class. What the dataclasses module does is to make it easier to create data classes. It takes care of a lot … Read more