Está chamando classe staticmethod dentro do corpo da classe?

Quando tento usar um método estático de dentro do corpo da classe e defino o método estático usando a staticmethodfunção interna como decorador, desta forma:

class Klass(object):

    @staticmethod  # use as decorator
    def _stat_func():
        return 42

    _ANS = _stat_func()  # call the staticmethod

    def method(self):
        ret = Klass._stat_func() + Klass._ANS
        return ret

Estou tendo o erro a seguir:

Traceback (most recent call last):<br>
  File "call_staticmethod.py", line 1, in <module>
    class Klass(object): 
  File "call_staticmethod.py", line 7, in Klass
    _ANS = _stat_func() 
  TypeError: 'staticmethod' object is not callable

Entendo por que isso está acontecendo (ligação do descritor) e posso contornar isso convertendo-o manualmente _stat_func()em um método estático após seu último uso, da seguinte forma:

class Klass(object):

    def _stat_func():
        return 42

    _ANS = _stat_func()  # use the non-staticmethod version

    _stat_func = staticmethod(_stat_func)  # convert function to a static method

    def method(self):
        ret = Klass._stat_func() + Klass._ANS
        return ret

Então, minha pergunta é:

Existem melhores, como em formas mais limpas ou mais "pitônicas", para conseguir isso?

staticmethodos objetos aparentemente têm um __func__atributo que armazena a função bruta original (faz sentido que eles precisassem). Então, isso vai funcionar:

class Klass(object):

    @staticmethod  # use as decorator
    def stat_func():
        return 42

    _ANS = stat_func.__func__()  # call the staticmethod

    def method(self):
        ret = Klass.stat_func()
        return ret

Além disso, embora eu suspeitasse que um objeto staticmethod tivesse algum tipo de atributo armazenando a função original, eu não tinha ideia dos detalhes. No espírito de ensinar alguém a pescar em vez de dar a ele um peixe, foi o que eu fiz para investigar e descobrir isso (um C&P da minha sessão em Python):

>>> class Foo(object):
...     @staticmethod
...     def foo():
...         return 3
...     global z
...     z = foo

>>> z
<staticmethod object at 0x0000000002E40558>
>>> Foo.foo
<function foo at 0x0000000002E3CBA8>
>>> dir(z)
['__class__', '__delattr__', '__doc__', '__format__', '__func__', '__get__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>> z.__func__
<function foo at 0x0000000002E3CBA8>

Tipos semelhantes de escavação em uma sessão interativa ( diré muito útil) geralmente podem resolver esses tipos de perguntas muito rapidamente.

É assim que eu prefiro:

class Klass(object):

    @staticmethod
    def stat_func():
        return 42

    _ANS = stat_func.__func__()

    def method(self):
        return self.__class__.stat_func() + self.__class__._ANS

Prefiro esta solução a Klass.stat_func, por causa do princípio DRY . Lembra-me da razão pela qual há um novosuper() no Python 3 :)

Mas eu concordo com os outros, geralmente a melhor opção é definir uma função no nível do módulo.

Por exemplo, com a @staticmethodfunção, a recursão pode não parecer muito boa (você precisaria quebrar o princípio DRY ligando para Klass.stat_funcdentro Klass.stat_func). Isso ocorre porque você não tem referência ao selfmétodo estático interno. Com a função no nível do módulo, tudo ficará bem.

Que tal injetar o atributo de classe após a definição da classe?

class Klass(object):

    @staticmethod  # use as decorator
    def stat_func():
        return 42

    def method(self):
        ret = Klass.stat_func()
        return ret

Klass._ANS = Klass.stat_func()  # inject the class attribute with static method value

Isso ocorre porque o staticmethod é um descritor e requer uma busca de atributo no nível da classe para exercitar o protocolo do descritor e obter a verdadeira capacidade de chamada.

Do código fonte:

Pode ser chamado na classe (por exemplo C.f()) ou em uma instância (por exemplo C().f()); a instância é ignorada, exceto por sua classe.

Mas não diretamente de dentro da classe enquanto ela está sendo definida.

Mas como um comentarista mencionou, esse não é realmente um design "pitonico". Basta usar uma função de nível de módulo.

E essa solução? Não depende do conhecimento da @staticmethodimplementação do decorador. Classe interna StaticMethod é reproduzida como um contêiner de funções de inicialização estática.

class Klass(object):

    class StaticMethod:
        @staticmethod  # use as decorator
        def _stat_func():
            return 42

    _ANS = StaticMethod._stat_func()  # call the staticmethod

    def method(self):
        ret = self.StaticMethod._stat_func() + Klass._ANS
        return ret