dataclasses — Clases de datos

Código fuente: Lib/dataclasses.py

Este módulo provee un decorador y funciones para añadir métodos especiales automáticamente, como __init__() y __repr__() por ejemplo, a clases definidas por el usuario. Fue originalmente descrito en PEP 557.

Las variables miembro a utilizar en estos métodos generados son definidas teniendo en cuenta anotaciones de tipo PEP 526. Por ejemplo, en este código:

from dataclasses import dataclass

@dataclass
class InventoryItem:
    """Class for keeping track of an item in inventory."""
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

Añadirá, además de otros métodos, un método __init__() con la siguiente estructura:

def __init__(self, name: str, unit_price: float, quantity_on_hand: int = 0):
    self.name = name
    self.unit_price = unit_price
    self.quantity_on_hand = quantity_on_hand

Es importante observar que este método es añadido a la clase automáticamente; está implícito en la definición de InventoryItem implementada arriba.

Nuevo en la versión 3.7.

Contenidos del módulo

@dataclasses.dataclass(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False)

Esta función es un decorator utilizado para añadir a las clases los métodos especiales generados, como se describe a continuación.

El decorador dataclass() examina la clase para encontrar fields. Un field (“campo”) se define como una variable de clase que tiene una anotación de variable. A excepción de los dos casos descritos debajo, nada en dataclass() examina el tipo especificado en la anotación de variable.

El orden de los campos en los métodos generados es el mismo en el que se encuentran en la definición de la clase.

El decorador dataclass() añade varios métodos «dunder» (abreviación de double underline) a la clase, descritos a continuación. Si alguno de los métodos añadidos ya existe en la definición de la clase, el comportamiento dependerá del parámetro, como se documenta abajo. El decorador retorna la misma clase con la que es llamado, no crea una nueva.

Si dataclass() es llamado como un simple decorador sin parámetros, actúa con los valores por defecto documentados aquí. Específicamente, los siguientes tres usos de dataclass() son equivalentes:

@dataclass
class C:
    ...

@dataclass()
class C:
    ...

@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False,
           match_args=True, kw_only=False, slots=False)
class C:
   ...

Los parámetros de dataclass() son:

  • init: Si es verdadero (valor por defecto), el método __init__() será generado.

    Si la clase ya define __init__(), este parámetro es ignorado.

  • repr: Si es verdadero (valor por defecto), el método __repr__() es generado. La cadena de representación generada tendrá el nombre de la clase junto al nombre y la representación de cada uno de sus campos, en el mismo orden en el que están definidos en la clase. Es posible indicar que ciertos campos no sean incluidos en la representación. Por ejemplo: InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10).

    Si la clase ya define __repr__(), este parámetro es ignorado.

  • eq: Si es verdadero (por defecto), el método __eq__() es generado. Este método compara entre instancias de la clase representando cada una de ellas mediante una tupla, siendo los elementos de la misma los campos de la clase ubicados en el mismo orden en el que fueron definidos (dos tuplas son iguales si, y sólo si, sus campos son iguales).

    Si la clase ya define __eq__(), este parámetro es ignorado.

  • order: Si es verdadero (False es el valor por defecto), los métodos __lt__(), __le__(), __gt__() y __ge__() serán generados. Estos métodos comparan la clase como si fuera una tupla con sus campos, en orden. Ambas instancias en la comparación deben ser del mismo tipo. Si order es verdadero y eq falso, se lanza una excepción ValueError.

    Si la clase ya define __lt__(), __le__(), __gt__() o __ge__(), se lanza una excepción TypeError.

  • unsafe_hash: Si es False (por defecto), se genera el método __hash__() de acuerdo a los valores de eq y frozen definidos.

    __hash__() es utilizado por la función incorporada hash() y cuando los objetos definidos por la clase son añadidos a colecciones hash, como por ejemplo diccionarios y conjuntos. Definir el método __hash__() en una clase implica que sus instancias son inmutables. La mutabilidad es una propiedad compleja, ya que depende de cómo el programador utilice el objeto, la existencia y comportamiento de __eq__() y del valor asignado a las flags eq y frozen en el decorador dataclass().

    Por defecto, dataclass() no añade de forma implícita el método __hash__() a menos que sea seguro hacerlo. Tampoco añade o cambia un método __hash__() previamente definido de forma explícita. Definir el atributo de clase __hash__ = None tiene un significado específico en Python, descrito en la documentación dedicada a __hash__().

    Si __hash__() no está definido explícitamente, o si está configurado como None, entonces dataclass() puede agregar un método implícito __hash__(). Aunque no se recomienda, puede forzar un dataclass() a crear un método __hash__() con unsafe_hash=True. Este podría ser el caso si su clase es lógicamente inmutable pero, no obstante, puede mutar. Este es un caso de uso especializado y debe considerarse detenidamente.

    A continuación se explican las reglas que se aplican en la creación implícita del método __hash__(). Observar que no es compatible definir explícitamente un método __hash__() en su clase de datos y al mismo tiempo asignar unsafe_hash=True; esto lanza una excepción TypeError.

    Si eq y frozen son ambos verdaderos, dataclass() genera por defecto un método hash() por ti. En el caso que eq sea verdadero y frozen falso, a __hash__() se le asigna None, en consecuencia será unhashable (lo cual es deseable, ya que es mutable). Si eq es falso, __hash__() permanece sin cambios, por lo que en este caso se hará uso del método hash() heredado de la superclase (lo que implica que si la superclase es object, se aplicará el hashing basado en el id de los objetos).

  • frozen: Si es verdadero (el valor por defecto es False), cualquier intento de asignación a un campo de la clase lanza una excepción. Esto emula el comportamiento de las instancias congeladas (frozen) de sólo lectura. Si __setattr__() o __delattr__() son definidos en la clase, se lanzará una excepción TypeError. Esto es ampliado más abajo.

  • match_args: si es verdadero (el valor predeterminado es True), la tupla __match_args__ se creará a partir de la lista de parámetros para el método __init__() generado (incluso si no se genera __init__(), consulte más arriba). Si es falso, o si __match_args__ ya está definido en la clase, no se generará __match_args__.

Nuevo en la versión 3.10.

  • kw_only: si es verdadero (el valor predeterminado es False), todos los campos se marcarán solo como palabra clave. Si un campo está marcado como solo de palabra clave, el único efecto es que el parámetro __init__() generado a partir de un campo de solo palabra clave debe especificarse con una palabra clave cuando se llama a __init__(). No hay ningún efecto sobre ningún otro aspecto de las clases de datos. Consulte la entrada del glosario parameter para obtener más detalles. Consulte también la sección KW_ONLY.

Nuevo en la versión 3.10.

  • slots: si es verdadero (el valor predeterminado es False), se generará el atributo __slots__ y se devolverá una nueva clase en lugar de la original. Si __slots__ ya está definido en la clase, se genera TypeError.

Nuevo en la versión 3.10.

Los fields pueden especificar un valor por defecto opcionalmente, simplemente usando la sintaxis normal de Python:

@dataclass
class C:
    a: int       # 'a' has no default value
    b: int = 0   # assign a default value for 'b'

En este ejemplo, tanto a como b serán incluidos en el método __init__() agregado, el cual será definido como sigue:

def __init__(self, a: int, b: int = 0):

Si, en la definición de una clase, a un campo con valor por defecto le sigue un campo sin valor por defecto será lanzada una excepción TypeError. Esto se aplica también a la implementación de una clase única o como resultado de herencia de clases.

dataclasses.field(*, default=MISSING, default_factory=MISSING, init=True, repr=True, hash=None, compare=True, metadata=None, kw_only=MISSING)

Para casos de uso común, estas funcionalidades son suficientes. Sin embargo, existen otras características de las clases de datos que requieren información adicional en ciertos campos. Para satisfacer esta necesidad, es posible reemplazar cualquier valor por defecto de un campo mediante una llamada a la función field(). Por ejemplo:

@dataclass
class C:
    mylist: list[int] = field(default_factory=list)

c = C()
c.mylist += [1, 2, 3]

Como se muestra arriba, el valor MISSING es un objeto centinela que se usa para detectar si el usuario proporciona algunos parámetros. Este centinela se utiliza porque None es un valor válido para algunos parámetros con un significado distinto. Ningún código debe utilizar directamente el valor MISSING.

Los parámetros de field() son:

  • default: Si es provisto, este será el valor por defecto para este campo. Es necesario que sea definido ya que la propia llamada a field() reemplaza la posición normal del valor por defecto.

  • default_factory: Si es provisto, debe ser un objeto invocable sin argumentos, el cual será llamado cuando el valor por defecto de este campo sea necesario. Además de otros propósitos, puede ser utilizado para especificar campos con valores por defecto mutables, como se explica a continuación. Especificar tanto default como default_factory resulta en un error.

  • init: Si es verdadero (por defecto), este campo es incluido como parámetro del método __init__() generado.

  • repr: Si es verdadero (por defecto), este campo es incluido en la cadena de caracteres que retorna el método __repr__() generado.

  • hash: Su valor puede ser de tipo booleano o None. Si es verdadero, este campo es incluido en el método __hash__() generado. Si es None (por defecto), utiliza el valor de compare: normalmente éste es el comportamiento esperado. Un campo debería ser considerado para el hash si es compatible con operaciones de comparación. Está desaconsejado establecer este valor en algo que no sea None.

    Una posible razón para definir hash=False y compare=True podría ser el caso en el que computar el valor hash para dicho campo es costoso pero el campo es necesario para los métodos de comparación, siempre que existan otros campos que contribuyen al valor hash del tipo. Incluso si un campo se excluye del hash, se seguirá utilizando a la hora de comparar.

  • compare: Si es verdadero (por defecto), este campo es incluido en los métodos de comparación generados (__eq__(), __gt__() y otros).

  • metadata: Puede ser un mapeo o None. None es tratado como un diccionario vacío. Este valor es envuelto en MappingProxyType() para que sea de sólo lectura y visible en el objeto Field. No es utilizado por las clases de datos, mas bien es provisto como un mecanismo de extensión de terceros. Varios terceros pueden tener su propia clave para utilizar como espacio de nombres en metadata.

  • kw_only: si es verdadero, este campo se marcará como solo palabra clave. Se utiliza cuando se calculan los parámetros del método __init__() generado.

Nuevo en la versión 3.10.

Si el valor por defecto de un campo es especificado por una llamada a field(), los atributos de clase para este campo serán reemplazados por los especificados en el valor default. Si el valor de default no es provisto, el atributo de clase será eliminado. La idea es que, después que la ejecución del decorador dataclass(), todos los atributos de la clase contengan los valores por defecto de cada campo, como si fueran definidos uno por uno. Por ejemplo, luego de:

@dataclass
class C:
    x: int
    y: int = field(repr=False)
    z: int = field(repr=False, default=10)
    t: int = 20

El atributo de clase C.z será 10, el atributo de clase C.t será 20 y los atributos de clase C.x y C.y no serán definidos.

class dataclasses.Field

Los objetos Field describen cada campo definido. Estos objetos son creados internamente y son retornados por el método fields() definido en este módulo (explicado más abajo). Los usuarios no deben instanciar un objeto Field directamente. Sus atributos documentados son:

  • name: El nombre del campo.

  • type: El tipo del campo.

  • default, default_factory, init, repr, hash, compare y metadata tienen los mismos valores y significados respecto a la declaración de field() (ver arriba).

Pueden existir otros atributos, pero son privados y no deberían ser considerados ni depender de ellos.

dataclasses.fields(class_or_instance)

Retorna una tupla de objetos Field que definen los campos para esta clase de datos. Acepta tanto una clase de datos como una instancia de esta. Lanza una excepción TypeError si se le pasa cualquier otro objeto. No retorna pseudocampos, que son ClassVar o InitVar.

dataclasses.asdict(obj, *, dict_factory=dict)

Converts the dataclass obj to a dict (by using the factory function dict_factory). Each dataclass is converted to a dict of its fields, as name: value pairs. dataclasses, dicts, lists, and tuples are recursed into. Other objects are copied with copy.deepcopy().

Example of using asdict() on nested dataclasses:

@dataclass
class Point:
     x: int
     y: int

@dataclass
class C:
     mylist: list[Point]

p = Point(10, 20)
assert asdict(p) == {'x': 10, 'y': 20}

c = C([Point(0, 0), Point(10, 4)])
assert asdict(c) == {'mylist': [{'x': 0, 'y': 0}, {'x': 10, 'y': 4}]}

To create a shallow copy, the following workaround may be used:

dict((field.name, getattr(obj, field.name)) for field in fields(obj))

asdict() raises TypeError if obj is not a dataclass instance.

dataclasses.astuple(obj, *, tuple_factory=tuple)

Converts the dataclass obj to a tuple (by using the factory function tuple_factory). Each dataclass is converted to a tuple of its field values. dataclasses, dicts, lists, and tuples are recursed into. Other objects are copied with copy.deepcopy().

Continuando con el ejemplo anterior:

assert astuple(p) == (10, 20)
assert astuple(c) == ([(0, 0), (10, 4)],)

To create a shallow copy, the following workaround may be used:

tuple(getattr(obj, field.name) for field in dataclasses.fields(obj))

astuple() raises TypeError if obj is not a dataclass instance.

dataclasses.make_dataclass(cls_name, fields, *, bases=(), namespace=None, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False)

Crea una nueva clase de datos con el nombre cls_name, con los campos definidos en fields, con las clases base dadas en bases e inicializada con el espacio de nombres dado en namespace. fields es un iterable que cumple con una de estas formas: name, (name, type) o (name, type, Field). Si solo name es proporcionado, typing.Any es usado para type. Los valores init, repr, eq, order, unsafe_hash y frozen tienen el mismo significado que en la función dataclass().

Esta función no es estrictamente necesaria debido a que cualquier mecanismo de Python para crear una nueva clase con __annotations__ puede usar la función dataclass() para convertir esa clase en una clase de datos. Esta función se proporciona simplemente por comodidad. Por ejemplo:

C = make_dataclass('C',
                   [('x', int),
                     'y',
                    ('z', int, field(default=5))],
                   namespace={'add_one': lambda self: self.x + 1})

Es equivalente a:

@dataclass
class C:
    x: int
    y: 'typing.Any'
    z: int = 5

    def add_one(self):
        return self.x + 1
dataclasses.replace(obj, /, **changes)

Creates a new object of the same type as obj, replacing fields with values from changes. If obj is not a Data Class, raises TypeError. If values in changes do not specify fields, raises TypeError.

El objeto recién retornado es creado llamando al método __init__() de la clase de datos. Esto asegura que __post_init__(), si existe, también será llamado.

Las variables de solo inicialización sin valores predeterminados, si existen, deben especificarse en la llamada a replace() para que puedan pasarse a __init__() y __post_init__().

Es un error que changes contenga cualquier campo que esté definido como init=False. Una excepción ValueError se lanzará en este caso.

Tenga en cuenta cómo funcionan los campos init=False durante una llamada a replace(). No se copian del objeto de origen, sino que, de inicializarse, lo hacen en __post_init__(). Se espera que los campos init=False se utilicen en contadas ocasiones y con prudencia. Si se utilizan, podría ser conveniente tener constructores de clase alternativos, o quizás un método personalizado replace() (o con un nombre similar) que maneje la copia de instancias.

dataclasses.is_dataclass(obj)

Retorna True si su parámetro es una clase de datos o una instancia de una, en caso contrario retorna False.

Si se necesita conocer si una clase es una instancia de dataclass (y no una clase de datos en si misma), se debe agregar una verificación adicional para not isinstance(obj, type):

def is_dataclass_instance(obj):
    return is_dataclass(obj) and not isinstance(obj, type)
dataclasses.MISSING

Un valor centinela que significa que falta un default o default_factory.

dataclasses.KW_ONLY

Un valor centinela utilizado como anotación de tipo. Cualquier campo después de un pseudocampo con el tipo de KW_ONLY se marca como campos de solo palabras clave. Tenga en cuenta que, de lo contrario, un pseudocampo de tipo KW_ONLY se ignora por completo. Esto incluye el nombre de dicho campo. Por convención, se utiliza un nombre de _ para un campo KW_ONLY. Los campos de solo palabras clave significan parámetros __init__() que deben especificarse como palabras clave cuando se crea una instancia de la clase.

En este ejemplo, los campos y y z se marcarán como campos de solo palabras clave:

@dataclass
class Point:
  x: float
  _: KW_ONLY
  y: float
  z: float

p = Point(0, y=1.5, z=2.0)

En una sola clase de datos, es un error especificar más de un campo cuyo tipo es KW_ONLY.

Nuevo en la versión 3.10.

exception dataclasses.FrozenInstanceError

Se genera cuando se llama a un __setattr__() o __delattr__() definido implícitamente en una clase de datos que se definió con frozen=True. Es una subclase de AttributeError.

Procesamiento posterior a la inicialización

El código del método generado __init__() llamará a un método llamado __post_init__(), si __post_init__() está definido en la clase. Normalmente se llamará como self.__post_init__(). Sin embargo, si se define algún campo InitVar, también se pasarán a __post_init__() en el orden en que se definieron en la clase. Si no se genera el método __init__(), entonces __post_init__() no se llamará automáticamente.

Entre otros usos, esto permite inicializar valores de campo que dependen de uno o más campos. Por ejemplo:

@dataclass
class C:
    a: float
    b: float
    c: float = field(init=False)

    def __post_init__(self):
        self.c = self.a + self.b

El método __init__() generado por dataclass() no llama a los métodos __init__() de la clase base. Si la clase base tiene un método __init__() que debe llamarse, es común llamar a este método en un método __post_init__():

@dataclass
class Rectangle:
    height: float
    width: float

@dataclass
class Square(Rectangle):
    side: float

    def __post_init__(self):
        super().__init__(self.side, self.side)

Sin embargo, tenga en cuenta que, en general, no es necesario llamar a los métodos __init__() generados por la clase de datos, ya que la clase de datos derivada se encargará de inicializar todos los campos de cualquier clase base que sea una clase de datos en sí.

Consulta la sección sobre variables de solo inicialización que hay a continuación para conocer las posibles formas de pasar parámetros a __post_init__(). También vea la advertencia sobre cómo replace() maneja los campos init = False.

Variables de clase

One of the few places where dataclass() actually inspects the type of a field is to determine if a field is a class variable as defined in PEP 526. It does this by checking if the type of the field is typing.ClassVar. If a field is a ClassVar, it is excluded from consideration as a field and is ignored by the dataclass mechanisms. Such ClassVar pseudo-fields are not returned by the module-level fields() function.

Variable de solo inicialización

Another place where dataclass() inspects a type annotation is to determine if a field is an init-only variable. It does this by seeing if the type of a field is of type dataclasses.InitVar. If a field is an InitVar, it is considered a pseudo-field called an init-only field. As it is not a true field, it is not returned by the module-level fields() function. Init-only fields are added as parameters to the generated __init__() method, and are passed to the optional __post_init__() method. They are not otherwise used by dataclasses.

Por ejemplo, supongamos que se va a inicializar un campo desde una base de datos, de no proporcionarse un valor al crear la clase:

@dataclass
class C:
    i: int
    j: int | None = None
    database: InitVar[DatabaseType | None] = None

    def __post_init__(self, database):
        if self.j is None and database is not None:
            self.j = database.lookup('j')

c = C(10, database=my_database)

En este caso, fields() retornará objetos Field para i y j, pero no para database.

Instancias congeladas

No es posible crear objetos verdaderamente inmutables en Python. Sin embargo, se puede emular la inmutabilidad pasando frozen=True al decorador dataclass(). En este caso, las clases de datos añadirán los métodos __setattr__() y __delattr__() a la clase. Estos métodos lanzarán una excepción FrozenInstanceError cuando sean llamados.

Hay una pequeña penalización de rendimiento cuando se usa frozen=True, esto se debe a que __init__() no puede usar una asignación simple para inicializar campos, viéndose obligado a usar object.__setattr__().

Herencia

Cuando la clase de datos está siendo creada por el decorador dataclass(), revisa todas las clases base de la clase en el MRO invertido (es decir, comenzando en object) y, para cada clase de datos que encuentra, agrega los campos de esa clase base a un mapeo ordenado. Después de agregar todos los campos de la clase base, agrega sus propios campos al mapeo. Todos los métodos generados utilizarán este mapeo ordenado calculado combinando los campos. Como los campos están en orden de inserción, las clases derivadas anulan las clases base. Un ejemplo:

@dataclass
class Base:
    x: Any = 15.0
    y: int = 0

@dataclass
class C(Base):
    z: int = 10
    x: int = 15

La lista final de campos es, en orden, x, y, z. El tipo final de x es int, como se especifica en la clase C.

El método __init__() generado para C se verá como:

def __init__(self, x: int = 15, y: int = 0, z: int = 10):

Reordenar los parámetros de solo palabras clave en __init__()

Una vez que se calculan los parámetros necesarios para __init__(), todos los parámetros de solo palabras clave se mueven después de todos los parámetros normales (no solo de palabras clave). Este es un requisito de cómo se implementan los parámetros de solo palabras clave en Python: deben ir después de los parámetros que no son solo de palabras clave.

En este ejemplo, Base.y, Base.w y D.t son campos de solo palabras clave, y Base.x y D.z son campos regulares:

@dataclass
class Base:
    x: Any = 15.0
    _: KW_ONLY
    y: int = 0
    w: int = 1

@dataclass
class D(Base):
    z: int = 10
    t: int = field(kw_only=True, default=0)

El método __init__() generado para C se verá como:

def __init__(self, x: Any = 15.0, z: int = 10, *, y: int = 0, w: int = 1, t: int = 0):

Tenga en cuenta que los parámetros se han reordenado a partir de cómo aparecen en la lista de campos: los parámetros derivados de los campos regulares son seguidos por los parámetros derivados de los campos de solo palabras clave.

El orden relativo de los parámetros de solo palabras clave se mantiene en la lista de parámetros __init__() reordenada.

Funciones fábrica por defecto

Si un field() especifica una default_factory, se llama sin argumentos cuando se necesita un valor predeterminado para el campo. Por ejemplo, para crear una nueva instancia de una lista, debe usarse:

mylist: list = field(default_factory=list)

Si un campo está excluido de __init__() (usando init = False) y el campo también especifica default_factory, entonces la función de fábrica predeterminada siempre se llamará desde la función generada __init__(). Esto sucede porque no existe otra forma de darle al campo un valor inicial.

Valores por defecto mutables

Python almacena los valores miembros por defecto en atributos de clase. Considera este ejemplo, sin usar clases de datos:

class C:
    x = []
    def add(self, element):
        self.x.append(element)

o1 = C()
o2 = C()
o1.add(1)
o2.add(2)
assert o1.x == [1, 2]
assert o1.x is o2.x

Tenga en cuenta que, tal como cabe esperar, las dos instancias de la clase C comparten la misma variable de clase x.

Usando clases de datos, si este código fuera válido:

@dataclass
class D:
    x: List = []
    def add(self, element):
        self.x += element

generaría un código similar a:

class D:
    x = []
    def __init__(self, x=x):
        self.x = x
    def add(self, element):
        self.x += element

assert D().x is D().x

Esto tiene el mismo problema que el ejemplo original usando la clase C. Es decir, dos instancias de la clase D que no especifican un valor para x al crear una instancia de clase compartirán la misma copia de x. Debido a que las clases de datos solo usan la creación normal de clases de Python, también comparten este comportamiento. No existe una forma general de que las clases de datos detecten esta condición. En cambio, el decorador dataclass() lanzará un TypeError si detecta un parámetro predeterminado de tipo list, dict o set. Esta es una solución parcial, pero protege contra muchos errores comunes.

Usar las funciones fábrica por defecto es una forma de crear nuevas instancias de tipos mutables como valores por defecto para campos:

@dataclass
class D:
    x: list = field(default_factory=list)

assert D().x is not D().x

Descriptor-typed fields

Fields that are assigned descriptor objects as their default value have the following special behaviors:

  • The value for the field passed to the dataclass’s __init__ method is passed to the descriptor’s __set__ method rather than overwriting the descriptor object.

  • Similarly, when getting or setting the field, the descriptor’s __get__ or __set__ method is called rather than returning or overwriting the descriptor object.

  • To determine whether a field contains a default value, dataclasses will call the descriptor’s __get__ method using its class access form (i.e. descriptor.__get__(obj=None, type=cls). If the descriptor returns a value in this case, it will be used as the field’s default. On the other hand, if the descriptor raises AttributeError in this situation, no default value will be provided for the field.

class IntConversionDescriptor:
  def __init__(self, *, default):
    self._default = default

  def __set_name__(self, owner, name):
    self._name = "_" + name

  def __get__(self, obj, type):
    if obj is None:
      return self._default

    return getattr(obj, self._name, self._default)

  def __set__(self, obj, value):
    setattr(obj, self._name, int(value))

@dataclass
class InventoryItem:
  quantity_on_hand: IntConversionDescriptor = IntConversionDescriptor(default=100)

i = InventoryItem()
print(i.quantity_on_hand)   # 100
i.quantity_on_hand = 2.5    # calls __set__ with 2.5
print(i.quantity_on_hand)   # 2

Note that if a field is annotated with a descriptor type, but is not assigned a descriptor object as its default value, the field will act like a normal field.