Início / coding / Perguntas / 79590366
Accepted
ESBM74
Asked: 2025-04-24 18:38:27 +0800 CST

Determinar se uma função/método tem uma implementação que não é "pass"

  • 772

Tenho uma classe que declara uma propriedade em Python, a implementação padrão para esse método é pass, por exemplo:

class A:

@property
def something(self):
    pass

Esta propriedade tem como objetivo declarar uma funcionalidade para estender classes, e eu quero usá-la para declarar um campo, onde se as classes de extensão a implementarem, o campo será inicializado com algum valor, e se não, o valor do campo será None.

Como posso verificar se os usuários implementaram?

Tentei usar __code__e hasattr()mas não funcionou.

python

2 respostas

  1. Best Answer

    Verifique no inicializador, onde você está definindo o valor padrão para o atributo, se a somethingpropriedade foi modificada na classe da instância ou se ela não foi modificada na implementação da classe base e defina o valor do atributo com base no resultado dessa verificação:

    from __future__ import annotations

class A:
    def __init__(self) -> None:
        self.attribute = None if type(self).something is A.something else 'Initialised'
        
    @property
    def something(self) -> str | None:
        pass

class B(A):
    @property
    def something(self) -> str | None:
        return "X"

class C(A):
    @property
    def something(self) -> str | None:
        print("Has side-effect")
        return None

class D(A):
    ...

print(f"A: {A().attribute}")
print(f"B: {B().attribute}")
print(f"C: {C().attribute}")
print(f"D: {D().attribute}")

    Quais saídas:

    A: None
B: Initialised
C: Initialised
D: None

    Como alternativa, você pode usar uma propriedade para verificar cada vez que o atributo for consultado:

    class A:
    @property
    def attribute(self) -> None:
        return None if type(self).something is A.something else 'Initialised'
        
    @property
    def something(self) -> str | None:
        pass

    Ou, se você quiser um atributo de classe (em vez de um atributo de instância), defina o atributo na subclasse em __init_subclass__:

    class A:
    attribute: str | None = None

    def __init_subclass__(cls) -> None:
        cls.attribute = None if cls.something is A.something else 'Initialised'

    @property
    def something(self) -> str | None:
        pass
    • 1

  2. Crie uma função personalizada propertypor subclasse. Use inspect.getsourcepara verificar se há um corpo semelhante ao da função pass.

    from inspect import getsource


class pimplemented(property):
    
    def __get__(self, obj, objtype=None):
        out = super().__get__(obj, None)
        
        # parse the source code for the "pass" statement
        src = getsource(self.fget)
        _, _, body = src.partition(':')
        
        # check for a match and apply an action
        is_implemented = body.strip(' \n') != 'pass'
        if is_implemented:
            return out         
      
        msg = f"{self.fget.__name__}: implemeted [{str(is_implemented).capitalize()}]"
        print(msg)


class A:

    @pimplemented
    def m1(self): ""
    
    @pimplemented
    def m2(self): pass
    
    @pimplemented
    def m3(self):
        pass


a = A()
a.m1
a.m2
a.m3

    Saída

    m2: implemeted [False]
m3: implemeted [False]

    Observe que

    • o pass"analisador" pode ser tornado mais robusto usando expressões regulares
    • uma mensagem stdout é disparada somente se o corpo não for implementado
    • ao usar logging, em vez de um simples print, é possível rastrear quando uma implementação é adicionada
    • 0

relate perguntas