Nota
¡Ayúdanos a traducir la documentación oficial de Python al Español! Puedes encontrar más información en Como contribuir. Ayuda a acercar Python a más personas de habla hispana.
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, weakref_slot=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 encontrarfields
. Unfield
(“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 endataclass()
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 dedataclass()
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, weakref_slot=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. Siorder
es verdadero yeq
falso, se lanza una excepciónValueError
.Si la clase ya define
__lt__()
,__le__()
,__gt__()
o__ge__()
, se lanza una excepciónTypeError
.unsafe_hash
: Si esFalse
(por defecto), se genera el método__hash__()
de acuerdo a los valores deeq
yfrozen
definidos.__hash__()
es utilizado por la función incorporadahash()
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 flagseq
yfrozen
en el decoradordataclass()
.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 comoNone
, entoncesdataclass()
puede agregar un método implícito__hash__()
. Aunque no se recomienda, puede forzar undataclass()
a crear un método__hash__()
conunsafe_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 asignarunsafe_hash=True
; esto lanza una excepciónTypeError
.Si
eq
yfrozen
son ambos verdaderos,dataclass()
genera por defecto un métodohash()
por ti. En el caso queeq
sea verdadero yfrozen
falso, a__hash__()
se le asignaNone
, en consecuencia será unhashable (lo cual es deseable, ya que es mutable). Sieq
es falso,__hash__()
permanece sin cambios, por lo que en este caso se hará uso del métodohash()
heredado de la superclase (lo que implica que si la superclase esobject
, se aplicará el hashing basado en el id de los objetos).frozen
: Si es verdadero (el valor por defecto esFalse
), 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ónTypeError
. Esto es ampliado más abajo.match_args
: si es verdadero (el valor predeterminado esTrue
), 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
: If true (the default value isFalse
), then all fields will be marked as keyword-only. If a field is marked as keyword-only, then the only effect is that the__init__()
parameter generated from a keyword-only field must be specified with a keyword when__init__()
is called. There is no effect on any other aspect of dataclasses. See the parameter glossary entry for details. Also see theKW_ONLY
section.
Nuevo en la versión 3.10.
slots
: si es verdadero (el valor predeterminado esFalse
), 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 generaTypeError
.
Nuevo en la versión 3.10.
Distinto en la versión 3.11: Si un nombre de campo ya está incluido en las
__slots__
de una clase base, no se incluirá en las__slots__
generadas para evitar que se sobreescriban. Por lo tanto, no utilice__slots__
para recuperar los nombres de campo de una clase de datos. Utilicefields()
en su lugar. Para poder determinar las ranuras heredadas, la clase base__slots__
puede ser cualquier iterable, pero no un iterador.weakref_slot
: Si es verdadero (por defecto esFalse
), añade una ranura llamada «__weakref__», que es necesaria para generar una instancia referenciable de forma débil. Es un error especificarweakref_slot=True
sin especificar tambiénslots=True
.
Nuevo en la versión 3.11.
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
comob
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 porqueNone
es un valor válido para algunos parámetros con un significado distinto. Ningún código debe utilizar directamente el valorMISSING
.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 afield()
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 tantodefault
comodefault_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 oNone
. Si es verdadero, este campo es incluido en el método__hash__()
generado. Si esNone
(por defecto), utiliza el valor decompare
: 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 seaNone
.Una posible razón para definir
hash=False
ycompare=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 enMappingProxyType()
para que sea de sólo lectura y visible en el objetoField
. 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 valordefault
. Si el valor dedefault
no es provisto, el atributo de clase será eliminado. La idea es que, después que la ejecución del decoradordataclass()
, 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 claseC.t
será20
y los atributos de claseC.x
yC.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étodofields()
definido en este módulo (explicado más abajo). Los usuarios no deben instanciar un objetoField
directamente. Sus atributos documentados son:name
: El nombre del campo.type
: El tipo del campo.default
,default_factory
,init
,repr
,hash
,compare
ymetadata
tienen los mismos valores y significados respecto a la declaración defield()
(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ónTypeError
si se le pasa cualquier otro objeto. No retorna pseudocampos, que sonClassVar
oInitVar
.
- dataclasses.asdict(obj, *, dict_factory=dict)¶
Converts the dataclass
obj
to a dict (by using the factory functiondict_factory
). Each dataclass is converted to a dict of its fields, asname: value
pairs. dataclasses, dicts, lists, and tuples are recursed into. Other objects are copied withcopy.deepcopy()
.Ejemplo de uso de
asdict()
en clases de datos anidadas:@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()
raisesTypeError
ifobj
is not a dataclass instance.
- dataclasses.astuple(obj, *, tuple_factory=tuple)¶
Converts the dataclass
obj
to a tuple (by using the factory functiontuple_factory
). Each dataclass is converted to a tuple of its field values. dataclasses, dicts, lists, and tuples are recursed into. Other objects are copied withcopy.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()
raisesTypeError
ifobj
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, weakref_slot=False)¶
Creates a new dataclass with name
cls_name
, fields as defined infields
, base classes as given inbases
, and initialized with a namespace as given innamespace
.fields
is an iterable whose elements are each eithername
,(name, type)
, or(name, type, Field)
. If justname
is supplied,typing.Any
is used fortype
. The values ofinit
,repr
,eq
,order
,unsafe_hash
,frozen
,match_args
,kw_only
,slots
, andweakref_slot
have the same meaning as they do indataclass()
.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óndataclass()
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 fromchanges
. Ifobj
is not a Data Class, raisesTypeError
. If values inchanges
do not specify fields, raisesTypeError
.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 comoinit=False
. Una excepciónValueError
se lanzará en este caso.Tenga en cuenta cómo funcionan los campos
init=False
durante una llamada areplace()
. No se copian del objeto de origen, sino que, de inicializarse, lo hacen en__post_init__()
. Se espera que los camposinit=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 personalizadoreplace()
(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 retornaFalse
.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 tipoKW_ONLY
se ignora por completo. Esto incluye el nombre de dicho campo. Por convención, se utiliza un nombre de_
para un campoKW_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
yz
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ó confrozen=True
. Es una subclase deAttributeError
.
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¶
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):
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
This has the same issue as the original example using class C
.
That is, two instances of class D
that do not specify a value
for x
when creating a class instance will share the same copy
of x
. Because dataclasses just use normal Python class
creation they also share this behavior. There is no general way
for Data Classes to detect this condition. Instead, the
dataclass()
decorator will raise a TypeError
if it
detects an unhashable default parameter. The assumption is that if
a value is unhashable, it is mutable. This is a partial solution,
but it does protect against many common errors.
Usar las funciones de 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
Distinto en la versión 3.11: Instead of looking for and disallowing objects of type list
,
dict
, or set
, unhashable objects are now not allowed as
default values. Unhashability is used to approximate
mutability.
Campos tipo descriptor¶
Los campos a los que se asigna objetos descriptor como valor por defecto tienen los siguientes comportamientos especiales:
El valor del campo pasado al método
__init__
de la clase de datos se pasa al método__set__
del descriptor en lugar de sobrescribir el objeto descriptor.Del mismo modo, al obtener o establecer el campo, se llama al método
__get__
o__set__
del descriptor en lugar de retornar o sobrescribir el objeto descriptor.Para determinar si un campo contiene un valor por defecto,
dataclasses
llamará al método__get__
del descriptor utilizando su forma de acceso a la clase (es decir,descriptor.__get__(obj=None, type=cls)
. Si el descriptor devuelve un valor en este caso, se utilizará como valor por defecto del campo. Por otro lado, si el descriptor devuelveAttributeError
en esta situación, no se proporcionará ningún valor por defecto para el campo.
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
Tenga en cuenta que si un campo está anotado con un tipo de descriptor, pero no se le asigna un objeto descriptor como valor por defecto, el campo actuará como un campo normal.