Dataclasses - How to create classes without having to write so much?

There is a short way to build a class with a default implementation of the methods you mention. To illustrate its use, we will take as an example a Dietetic Clinic that needs to keep a record of patients with name, sex and current weight.

dataclass library

The dataclasses library is standard since Python 3.7, although it can be used in Python 3.6 by installing thedataclasses . This gives us the decorator dataclass that we prepend to the class declaration. With that, the declaration itself is reduced to listing its attributes, each with its type according to PEP 526 -- Syntax for Variable Annotations

from dataclasses import dataclass

@dataclass
class Paciente:
    nombre: str
    peso: float
    sexo: str

(you can use Anyas type when the attribute is of indeterminate type).

and with this we already have implementing the method __init__, the setters and getters for each attribute and also the method behind the function repr.

pac1 = Paciente(nombre="Juan", peso=113.2, sexo="M")
pac2 = Paciente("Maria", 90, "F")
print(pac1) => Paciente(nombre='Juan', peso=113.2, sexo='M')
print(pac2) => Paciente(nombre='Maria', peso=90, sexo='F')

The method __init__declares its named parameters in the same order as they appear in the class declaration. Objects can be instantiated by passing parameters by position or by name. In this case, the generated statement is:

def __init__(self, nombre: str, peso: int, sexo: str):
    ...

default values

It is possible to indicate default values ​​for each attribute. This is done by typing the "=" sign followed by a valid expression for the attribute type.

Let's make the default gender for patients "F":

class Paciente:
    nombre: str
    peso: float
    sexo: str = "F"

pac2 = Paciente("Maria", 90)
print(pac2) => Paciente(nombre='Maria', peso=90, sexo='F')

Attributes without default values ​​must be written first, followed by all those with default.

Sort and Compare

For the purposes of scheduling fitness classes, you need to sort and classify patients by weight. For that we normally add to the class the comparison methods __eq__, __lt__, etc., but it is something that dataclassescan do it for us.

To generate the comparison methods, dataclassesconsider the object as a tuple of attributes (in the order of their declaration) that is compared against the tuple representing the other object (of the same class). The comparison follows the rules of tuple comparison.

So if we want to compare patients by weight, the attribute pesomust be the first in the declaration. We also need to tell the decorator to generate the necessary comparison methods. For this, we pass the parameter order=Trueto the decorator

@dataclass(order=True)
class Paciente:
    peso: float
    nombre: str
    sexo: str = "F"

pac1 = Paciente(nombre="Juan", peso=113.2, sexo="M")
pac2 = Paciente(90, "Maria")
print(pac1 < pac2) => False

The decorator accepts several named parameters (shown with their default):

@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)

where:

• initgenerate method__init__
• reprgenerate method__repr__
• eq generate method__eq__
• orderGenerate methods__lt__(), __le__(), __gt__(), __ge__()__
• frozenMakes the class immutable.

own methods

Nothing prevents you from adding your own methods to the class. For example, the standard implementation of stris limited to calling repr, which is not ideal. Let's do our own implementation:

@dataclass(order=True)
class Paciente:
    peso: float
    nombre: str
    sexo: str = "F"

    def __str__(self):
        return f"{self.nombre}, {self.peso} kgs"

pac1 = Paciente(nombre="María", peso=98.3)
print(str(pac1)) => "María, 98.3 kgs"

Attribute Settings

The method fieldallows us to set a particular attribute of the class. With this, the complete declaration of an attribute is:

nombre: tipo = field(default=MISSING, default_factory=MISSING, repr=True, hash=None, init=True, compare=True, metadata=None)

(All parameters are optional)

The parameter initdetermines whether the field will be initialized via __init__or is an internally generated field. Likewise, reprit marks whether the field should be included when calling __repr__and comparewhether it should be included when generating comparisons __lt__, __gt__, etc.

The parameter appears assigned with a magicdefault variable MISSING. This is used so that "has no default" can be distinguished from "default is None".

Alternatively, the default value can be determined by a parameterless function specified in "default_factory". This is called each time an object is created, and must supply the appropriate default value.

Let's expand our class to include a list of weekly weights. We want the attribute not to be included as a creation parameter, to force it to always be initialized with an empty list.

The declaration

class Paciente:
    peso: float
    nombre: str
    sexo: str = "F"
    semanal: list = []  # Error!!!

is syntactically invalid, and prevents us from the common mistake of unintentionally sharing a list among all objects of the Patient class. The correct way is to use the parameter default_factoryto indicate how to generate a new list for each patient:

from dataclasses import dataclass, field

@dataclass(order=True)
class Paciente:
    peso: float
    nombre: str
    sexo: str = "F"
    semanal: list = field(default_factory=list, init=False)

and then

pac1 = Paciente(nombre="María", peso=98.3)
pac1.semanal.append(97.4)
pac1.semanal.append(96.5)
print(pac1.semanal) => [97.4, 96.5]

utility methods

The methods asdictand astupleallow to obtain the object as a dictionary or a tuple, respectively:

from dataclasses import dataclass, field, asdict, astuple

@dataclass(order=True)
class Paciente:
    peso: float
    nombre: str
    sexo: str = "F"
    semanal: list = field(default_factory=list, init=False)

pac1 = Paciente(nombre="María", peso=98.3)
print(asdict(pac1)) => {'peso': 98.3, 'nombre': 'María', 'sexo': 'F', 'semanal': []}
print(astuple(pac1)) => (98.3, 'María', 'F', [])

The generated method __init__by default executes the method __post_init__()if it is defined. The idea is to be able to complete the initialization after it __init__receives its parameters.

Let's add code to our class that initializes the list of weekly weights with the person's starting weight.

from dataclasses import dataclass, field, asdict, astuple

@dataclass(order=True)
class Paciente:
    peso: float
    nombre: str
    sexo: str = "F"
    semanal: list = field(default_factory=list, init=False)

    def __post_init__(self):
        self.semanal.append(self.peso)

pac1 = Paciente(nombre="María", peso=98.3)
print(asdict(pac1)) => {'peso': 98.3, 'nombre': 'María', 'sexo': 'F', 'semanal': [98.3]}
print(astuple(pac1)) => (98.3, 'María', 'F', [98.3])

I hope they have been useful to you.