Início / coding / Perguntas / 79556229
Accepted
502E532E
Asked: 2025-04-05 04:50:29 +0800 CST

Tipo de retorno de dica de tipo do método abstrato para ser qualquer instância da classe pai

  • 772

Como posso digitar uma dica de que o tipo de retorno de um método de alguma classe abstrata é alguma instância dessa classe?

Minha resposta intuitiva é que

@abstractmethod
def mymethod() -> typing.Self:
    pass

deveria ser a maneira correta (como sugerido neste post , por exemplo). Mas quando agora subclassifico desta classe, o tipo de retorno é restrito ao tipo da classe filha. Qual é a maneira correta de digitar hint aqui, para que cada subclasse da classe pai seja permitida?

Código de exemplo:

from abc import ABC, abstractmethod
from typing import Self, override
import random

class DiceResult(ABC):
    @abstractmethod
    def reroll(self) -> Self:
        pass

class NaturalTwenty(DiceResult):
    @override
    def reroll(self) -> DiceResult: # Type checkers report an error here
        return random.choice([NaturalTwenty(), NaturalOne()])

class NaturalOne(DiceResult):
    @override
    def reroll(self) -> DiceResult: # Type checkers report an error here
        return random.choice([NaturalTwenty(), NaturalOne()])

Mypy playground Baseado em direitos autorais playground

python

2 respostas

  1. Mas quando agora subclassifico dessa classe, o tipo de retorno é restrito ao tipo da classe filha. Qual é a maneira correta de digitar hint aqui, para que cada subclasse da classe pai seja permitida?

    DiceResult.rerollnão deve usar Selfporque...

    Você não deve usar Self como anotação de retorno se não houver garantia de que o método retornará uma instância de uma subclasse quando a classe for subclassificada.

    Você tem que dizer que todos eles retornam DiceResult, mas então você não pode usar nenhum método extra das subclasses. Vou usar um exemplo diferente porque os dados não mudam quando você os rola.

    from abc import ABC, abstractmethod
from typing import override
import random


class Thing(ABC):
    @abstractmethod
    def repick(self) -> "Thing":
        pass


class TheBestThing(Thing):
    @override
    def repick(self) -> Thing:
        print("You already have the best thing")
        return self


class Duck(Thing):
    @override
    def repick(self) -> Thing:
        return random.choice((Duck(), TheBestThing()))

    def quack(self):
        print("QUACK!")


duck = Duck()
duck.quack()
new_thing = duck.repick()

# error: "Thing" has no attribute "quack"  [attr-defined]
new_thing.quack()

    Então você precisa de um protetor de tipo.

    if isinstance(new_thing, Duck):
    new_thing.quack()
    • 2
  2. Best Answer

    @Schwern já explica por que typing.Selfnão funciona aqui em sua resposta . Isso ocorre porque typing.Selfsempre type hints a classe envolvente atual. Se for a subclasse de outra classe, o type hint se refere à subclasse.

    Para resolver isso, queremos usar a classe pai como anotação de tipo, como em

    class DiceResult(ABC):
    @abstractmethod
    def reroll(self) -> DiceResult:
        pass

    Isso não funciona na versão atual do python, pois é uma referência de avanço . A solução atual é usar uma literal de string, como em

    class DiceResult(ABC):
    @abstractmethod
    def reroll(self) -> "DiceResult":
        pass

    No futuro, a primeira versão pretende funcionar também, e também já está (python >= 3.7) disponível em __future__. Pode ser usado como

    from __future__ import annotations

class DiceResult(ABC):
    @abstractmethod
    def reroll(self) -> DiceResult:
        pass
    • 1

relate perguntas