Https://www.youtube.com/watch?v=T-TwcmT6Rcw&t=1390

Da especificação PEP:

É fornecido um decorador de classe que inspecciona uma definição de classe para variáveis com anotações de tipo definidas em PEP 526, " sintaxe para Variable Annotations". Neste documento, tais variáveis são chamadas campo. Usando estes campos, o decorador adiciona o método gerado definições para a classe de suporte à inicialização de instância, um repr, métodos de comparação e, facultativamente, outros métodos descritos no Secção de especificações. Tal classe é chamada de classe de dados, mas não há nada de especial na aula: o decorador acrescenta métodos gerados para a classe e retorna a mesma classe que era dado.

O gerador {[[0]} adiciona métodos à classe que se definiria de outra forma como __repr__, __init__, __lt__, e __gt__

Panorâmica

O que são exactamente as classes de dados python e quando é melhor usá-las?

1. geradores de código : gerar código boilerplate; você pode optar por implementar métodos especiais numa classe regular ou ter um dataclass implementá-los automaticamente.
2. dados containers : structures that hold data (e.g. tuplas and dicts), often with tracked, attribute access such as classes, namedtuple and others.

"mutable namedtuples with default"

• mutável : por omissão, os atributos dataclass podem ser reatribuídos. Você pode opcionalmente torná-los imutáveis (veja exemplos abaixo).
• Tem pontilhado, atributo acesso como uma aula normal.
• predefinição : você pode atribuir valores predefinidos aos atributos

Em comparação com as classes comuns, economiza-se principalmente na escrita do Código boilerplate.

Exemplos

Aqui está uma rápida visão geral das funcionalidades do dataclass com exemplos.

O que tens

Atributos + Representação + Comparação

imp dataclasses


@dataclasses.dataclass
#@dataclasses.dataclass()                                       # alternative
class Color:
    r : int = 0
    g : int = 0
    b : int = 0

Os seguintes valores por omissão estão definidos:

@dataclasses.dataclass(init=True, repr=True, eq=True)

Algumas funcionalidades adicionais estão disponíveis se a palavra-chave apropriada for True.

ordem

@dataclasses.dataclass(order=True)
class Color:
    r : int = 0
    g : int = 0
    b : int = 0

Os métodos de encomenda são implementados (sobrecarga < > <= >=), de forma semelhante à functools.total_ordering com testes de igualdade mais fortes.

Hashable, Mutable

@dataclasses.dataclass(unsafe_hash=True)                        # override base `__hash__`
class Color:
    ...

Embora o objecto seja potencialmente mutável (possivelmente indesejável), um hash é implementado.

Hashable, Imutável

@dataclasses.dataclass(frozen=True)                                 # `eq=True` (default) to be immutable 
class Color:
    ...

Um hash é implementado e mudar o objecto ou atribuir atributos é proibido.

Globalmente, se unsafe_hash=True ou frozen=True for definido, o objecto é hashable.

Ver também a tabela lógica original sobre detalhes.

Para obter as seguintes características, os métodos especiais devem ser manualmente implementado:

Impacável

@dataclasses.dataclass
class Color:
    r : int = 0
    g : int = 0
    b : int = 0

    def __iter__(self):
        yield from dataclasses.astuple(self)

optimização

@dataclasses.dataclass
class SlottedColor:
    __slots__ = ["r", "b", "g"]
    r : int
    g : int
    b : int

O tamanho do objecto está agora reduzido:

>>> imp sys
>>> sys.getsizeof(Color)
1056
>>> sys.getsizeof(SlottedColor)
888

Em algumas circunstâncias, {[19] } também melhora a velocidade de criação de instância e acesso de atributos. Além disso, os 'slots' não permitem atribuições predefinidas; caso contrário, um ValueError é elevado.

Veja mais em slots neste postno blog .

Tabela-Resumo

+----------------------+----------------------+----------------------------------------------------+-----------------------------------------+
|       Feature        |       Keyword        |                      Example                       |           Implement in a Class          |
+----------------------+----------------------+----------------------------------------------------+-----------------------------------------+
| Attributes           |  init                |  Color().r -> 0                                    |  __init__                               |
| Representation       |  repr                |  Color() -> Color(r=0, g=0, b=0)                   |  __repr__                               |
| Comparision*         |  eq                  |  Color() == Color(0, 0, 0) -> True                 |  __eq__                                 |
|                      |                      |                                                    |                                         |
| Order                |  order               |  sorted([Color(0, 50, 0), Color()]) -> ...         |  __lt__, __le__, __gt__, __ge__         |
| Hashing              |  unsafe_hash/frozen  |  {Color(), {Color()}} -> {Color(r=0, g=0, b=0)}    |  __hash__                               |
| Immutable            |  frozen + eq         |  Color().r = 10 -> TypeError                       |  __setattr__, __delattr__               |
|                      |                      |                                                    |                                         |
| Unpackable+          |  -                   |  r, g, b = Color()                                 |   __iter__                              |
| Optimization+        |  -                   |  sys.getsizeof(SlottedColor) -> 888                |  __slots__                              |
+----------------------+----------------------+----------------------------------------------------+-----------------------------------------+

_{⁺estes métodos não são gerados automaticamente e requerem implementação manual em um dataclass.}

_{^*__ne__ não está implementado.}

Características adicionais

Pós-inicialização

@dataclasses.dataclass
class RGBA:
    r : int = 0
    g : int = 0
    b : int = 0
    a : float = 1.0

    def __post_init__(self):
        self.a : int =  int(self.a * 255)


RGBA(127, 0, 255, 0.5)
# RGBA(r=127, g=0, b=255, a=127)

Herança

@dataclasses.dataclass
class RGBA(Color):
    a : int = 0

Conversões

Converta um dataclass para uma tupla ou uma dict, recursivamente:

>>> dataclasses.astuple(Color(128, 0, 255))
(128, 0, 255)
>>> dataclasses.asdict(Color(128, 0, 255))
{r: 128, g: 0, b: 255}

Limitações

Falta de mecanismos para lidar com argumentos de starry

Referências

• R. Hettinger's talk on Dataclasses: the code generator to end all code generators
• T. Hunner's talk on classes mais fáceis: classes Python sem todo o Cruft
Documentação De Python sobre os detalhes da lavagem
• O guia real do Python em O Guia final das Classes de dados em Python 3.7
[[32]}A. Shaw's post no blog on a brief tour of Python 3.7 data classes
• o repositório de github de E. Smith em dataclasses