dataclasses
— Clases de datos¶
Código fuente: Lib/dataclasses.py
This module provides a decorator and functions for automatically
adding generated special methods such as __init__()
and
__repr__()
to user-defined classes. It was originally described
in 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
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.
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
: If true (the default), a__init__()
method will be generated.If the class already defines
__init__()
, this parameter is ignored.repr
: If true (the default), a__repr__()
method will be generated. The generated repr string will have the class name and the name and repr of each field, in the order they are defined in the class. Fields that are marked as being excluded from the repr are not included. For example:InventoryItem(name='widget', unit_price=3.0, quantity_on_hand=10)
.If the class already defines
__repr__()
, this parameter is ignored.eq
: If true (the default), an__eq__()
method will be generated. This method compares the class as if it were a tuple of its fields, in order. Both instances in the comparison must be of the identical type.If the class already defines
__eq__()
, this parameter is ignored.order
: If true (the default isFalse
),__lt__()
,__le__()
,__gt__()
, and__ge__()
methods will be generated. These compare the class as if it were a tuple of its fields, in order. Both instances in the comparison must be of the identical type. Iforder
is true andeq
is false, aValueError
is raised.If the class already defines any of
__lt__()
,__le__()
,__gt__()
, or__ge__()
, thenTypeError
is raised.unsafe_hash
: IfFalse
(the default), a__hash__()
method is generated according to howeq
andfrozen
are set.__hash__()
is used by built-inhash()
, and when objects are added to hashed collections such as dictionaries and sets. Having a__hash__()
implies that instances of the class are immutable. Mutability is a complicated property that depends on the programmer’s intent, the existence and behavior of__eq__()
, and the values of theeq
andfrozen
flags in thedataclass()
decorator.By default,
dataclass()
will not implicitly add a__hash__()
method unless it is safe to do so. Neither will it add or change an existing explicitly defined__hash__()
method. Setting the class attribute__hash__ = None
has a specific meaning to Python, as described in the__hash__()
documentation.If
__hash__()
is not explicitly defined, or if it is set toNone
, thendataclass()
may add an implicit__hash__()
method. Although not recommended, you can forcedataclass()
to create a__hash__()
method withunsafe_hash=True
. This might be the case if your class is logically immutable but can nonetheless be mutated. This is a specialized use case and should be considered carefully.Here are the rules governing implicit creation of a
__hash__()
method. Note that you cannot both have an explicit__hash__()
method in your dataclass and setunsafe_hash=True
; this will result in aTypeError
.If
eq
andfrozen
are both true, by defaultdataclass()
will generate a__hash__()
method for you. Ifeq
is true andfrozen
is false,__hash__()
will be set toNone
, marking it unhashable (which it is, since it is mutable). Ifeq
is false,__hash__()
will be left untouched meaning the__hash__()
method of the superclass will be used (if the superclass isobject
, this means it will fall back to id-based hashing).frozen
: If true (the default isFalse
), assigning to fields will generate an exception. This emulates read-only frozen instances. If__setattr__()
or__delattr__()
is defined in the class, thenTypeError
is raised. See the discussion below.match_args
: If true (the default isTrue
), the__match_args__
tuple will be created from the list of parameters to the generated__init__()
method (even if__init__()
is not generated, see above). If false, or if__match_args__
is already defined in the class, then__match_args__
will not be generated.
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
: If true (the default isFalse
),__slots__
attribute will be generated and new class will be returned instead of the original one. If__slots__
is already defined in the class, thenTypeError
is raised.
Nuevo en la versión 3.10.
Distinto en la versión 3.11: If a field name is already included in the
__slots__
of a base class, it will not be included in the generated__slots__
to prevent overriding them. Therefore, do not use__slots__
to retrieve the field names of a dataclass. Usefields()
instead. To be able to determine inherited slots, base class__slots__
may be any iterable, but not an iterator.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'
In this example, both
a
andb
will be included in the added__init__()
method, which will be defined as: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
: If true (the default), this field is included as a parameter to the generated__init__()
method.repr
: If true (the default), this field is included in the string returned by the generated__repr__()
method.hash
: This can be a bool orNone
. If true, this field is included in the generated__hash__()
method. IfNone
(the default), use the value ofcompare
: this would normally be the expected behavior. A field should be considered in the hash if it’s used for comparisons. Setting this value to anything other thanNone
is discouraged.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
: If true (the default), this field is included in the generated equality and comparison methods (__eq__()
,__gt__()
, et al.).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
: If true, this field will be marked as keyword-only. This is used when the generated__init__()
method’s parameters are computed.
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, module=None)¶
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()
.If
module
is defined, the__module__
attribute of the dataclass is set to that value. By default, it is set to the module name of the caller.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
.The newly returned object is created by calling the
__init__()
method of the dataclass. This ensures that__post_init__()
, if present, is also called.Init-only variables without default values, if any exist, must be specified on the call to
replace()
so that they can be passed to__init__()
and__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.Dataclass instances are also supported by generic function
copy.replace()
.
- 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¶
A sentinel value used as a type annotation. Any fields after a pseudo-field with the type of
KW_ONLY
are marked as keyword-only fields. Note that a pseudo-field of typeKW_ONLY
is otherwise completely ignored. This includes the name of such a field. By convention, a name of_
is used for aKW_ONLY
field. Keyword-only fields signify__init__()
parameters that must be specified as keywords when the class is instantiated.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¶
Raised when an implicitly defined
__setattr__()
or__delattr__()
is called on a dataclass which was defined withfrozen=True
. It is a subclass ofAttributeError
.
Procesamiento posterior a la inicialización¶
- dataclasses.__post_init__()¶
When defined on the class, it will be called by the generated
__init__()
, normally asself.__post_init__()
. However, if anyInitVar
fields are defined, they will also be passed to__post_init__()
in the order they were defined in the class. If no__init__()
method is generated, then__post_init__()
will not automatically be called.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¶
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¶
It is not possible to create truly immutable Python objects. However,
by passing frozen=True
to the dataclass()
decorator you can
emulate immutability. In that case, dataclasses will add
__setattr__()
and __delattr__()
methods to the class. These
methods will raise a FrozenInstanceError
when invoked.
There is a tiny performance penalty when using frozen=True
:
__init__()
cannot use simple assignment to initialize fields, and
must use 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
.
The generated __init__()
method for C
will look like:
def __init__(self, x: int = 15, y: int = 0, z: int = 10):
Re-ordering of keyword-only parameters in __init__()
¶
After the parameters needed for __init__()
are computed, any
keyword-only parameters are moved to come after all regular
(non-keyword-only) parameters. This is a requirement of how
keyword-only parameters are implemented in Python: they must come
after non-keyword-only parameters.
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)
The generated __init__()
method for D
will look like:
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.
The relative ordering of keyword-only parameters is maintained in the
re-ordered __init__()
parameter list.
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)
If a field is excluded from __init__()
(using init=False
)
and the field also specifies default_factory
, then the default
factory function will always be called from the generated
__init__()
function. This happens because there is no other
way to give the field an initial value.
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 = [] # This code raises ValueError
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 ValueError
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.