Início / coding / Perguntas / 78934877
Accepted
Alex Duchnowski
Asked: 2024-08-31 18:46:47 +0800 CST

Como posso formalizar um relacionamento repetido entre grupos disjuntos de classes em Python?

  • 772

Tenho um código Python que tem o seguinte formato:

from dataclasses import dataclass


@dataclass
class Foo_Data:
    foo: int


class Foo_Processor:
    def process(self, data: Foo_Data): ...


class Foo_Loader:
    def load(self, file_path: str) -> Foo_Data: ...


@dataclass
class Bar_Data:
    bar: str


class Bar_Processor:
    def process(self, data: Bar_Data): ...


class Bar_Loader:
    def load(self, file_path: str) -> Bar_Data: ...

Tenho várias instâncias desse tipo de configuração de Dados/Processador/Carregador, e todas as classes têm as mesmas assinaturas de método módulo da família de classes específica (Foo, Bar, etc.). Existe uma maneira pythonic de formalizar esse relacionamento entre classes para impor uma estrutura semelhante se eu decidir criar uma família de classes Spam_Data, Spam_Processor, e Spam_Loader? Por exemplo, quero algo para impor que Spam_Processortenha um processmétodo que receba um argumento do tipo Spam_Data. Existe uma maneira de atingir essa padronização de alguma forma com classes abstratas, tipos genéricos ou alguma outra estrutura?

Tentei usar classes abstratas, mas o mypy corretamente aponta que ter todas as classes *_Data como subclasses de uma Dataclasse abstrata e, da mesma forma, ter todas as classes *_Processor como subclasses de uma Processorclasse abstrata viola o princípio de substituição de Liskov, já que cada processador é projetado apenas para sua respectiva classe Data (ou seja, Foo_Processornão pode processar Bar_Data, mas seria de se esperar que pudesse se essas classes tivessem superclasses Processore Datafossem compatíveis dessa forma).

python

1 respostas

  1. Best Answer

    Você pode usar classes base abstratas (ABCs) com Generics. Dessa forma, você pode definir uma interface comum, garantindo a segurança do tipo:

    from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Generic, TypeVar

# generic type variable for Data
T = TypeVar('T', bound='BaseData')


@dataclass
class BaseData(ABC):
    pass


class BaseProcessor(ABC, Generic[T]):
    @abstractmethod
    def process(self, data: T) -> None:
        pass


class BaseLoader(ABC, Generic[T]):
    @abstractmethod
    def load(self, file_path: str) -> T:
        pass

    Agora você pode definir suas classes específicas

    @dataclass
class Foo_Data(BaseData):
    foo: int


class Foo_Processor(BaseProcessor[Foo_Data]):
    def process(self, data: Foo_Data) -> None: ...


class Foo_Loader(BaseLoader[Foo_Data]):
    def load(self, file_path: str) -> Foo_Data: ...


@dataclass
class Bar_Data(BaseData):
    bar: str


class Bar_Processor(BaseProcessor[Bar_Data]):
    def process(self, data: Bar_Data) -> None: ...


class Bar_Loader(BaseLoader[Bar_Data]):
    def load(self, file_path: str) -> Bar_Data: ...

    Escrever seu código dessa maneira combina os benefícios de uma interface comum com a segurança de tipos.

    • Os ABCs garantem que as subclasses implementem os métodos necessários, promovendo uma estrutura consistente.

    • Os genéricos permitem operações específicas de tipo, melhorando a legibilidade e a manutenção do código.

    Como confirmação com mypy:

    mypy script.py
Success: no issues found in 1 source file
    • 2

relate perguntas