# `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.

The member variables to use in these generated methods are defined using PEP 526 type annotations. For example, this code:

    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

will add, among other things, a `__init__()` that looks like:

    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.

## Decoradores, clases y funciones del módulo

`@``dataclasses.``dataclass`(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=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.

  The `dataclass()` decorator examines the class to find `field`s. A `field` is defined as a class variable that has a type annotation. With two exceptions described below, nothing in `dataclass()` examines the type specified in the variable annotation.

  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.

  The `dataclass()` decorator will add various «dunder» methods to the class, described below. If any of the added methods already exist in the class, the behavior depends on the parameter, as documented below. The decorator returns the same class that it is called on; no new class is created.

  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)
      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.

  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):

  `TypeError` will be raised if a field without a default value follows a field with a default value. This is true whether this occurs in a single class, or as a result of class inheritance.

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

  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 utilizado para detectar si los parámetros `default` y `default_factory` son provistos. Este objeto centinela es utilizado debido a que `None` es un valor válido para `default`. Ningún procedimiento 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.

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

  - `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.

  - `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.

  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)

  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)

## 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

The `__init__()` method generated by `dataclass()` does not call base class `__init__()` methods. If the base class has an `__init__()` method that has to be called, it is common to call this method in a `__post_init__()` method:

    @dataclass
    class Rectangle:
        height: float
        width: float

    @dataclass
    class Square(Rectangle):
        side: float

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

Note, however, that in general the dataclass-generated `__init__()` methods don’t need to be called, since the derived dataclass will take care of initializing all fields of any base class that is a dataclass itself.

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

Uno de los dos casos donde `dataclass()` realmente inspecciona el tipo de un campo, es para determinar si dicho campo es una variable de clase como se define en PEP 526. Lo hace comprobando si el tipo del campo es `typing.ClassVar`. Si un campo es una `ClassVar`, se deja de considerar como campo y los mecanismos de las clases de datos lo ignoran. Tales pseudocampos `ClassVar` no son retornados por la función del módulo `fields()`.

## Variable de solo inicialización

El otro caso donde `dataclass()` inspecciona una anotación de tipo es para determinar si un campo es una variable de solo inicialización. Lo hace comprobando si el tipo de un campo es `dataclasses.InitVar`. Si un campo es un `InitVar`, se considera un pseudocampo llamado “campo de solo inicialización”. Como no es un campo verdadero, no es retornado por la función del módulo `fields()`. Los campos de solo inicialización se agregan como parámetros al método generado `__init__()` y se pasan al método opcional `__post_init__()`. No son utilizados de otra manera por las clases de datos.

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
        database: InitVar[DatabaseType] = 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):

## 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

> Este 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 la clase, compartirán la misma copia de `x`. Debido a que las clases de datos usan simplemente el mecanismo normal de creación de clases de Python, también comparten este comportamiento. No existe una forma genérica de que las clases de datos detecten esta condición. En su lugar, las clases de datos generarán una excepción `TypeError` si detectan un parámetro predeterminado de tipo `list`, `dict` o `set` (contenedores incorporados mutables). Esta es una solución parcial, pero protege contra muchos de los errores más 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

## Excepciones

exception `dataclasses.``FrozenInstanceError`

  Raised when an implicitly defined `__setattr__()` or `__delattr__()` is called on a dataclass which was defined with `frozen=True`. It is a subclass of `AttributeError`.