¿Llamando al método estático de clase dentro del cuerpo de la clase?

Cuando intento usar un método estático desde dentro del cuerpo de la clase, y definir el método estático usando la staticmethodfunción incorporada como decorador, así:

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

Obtuve el siguiente error:

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

Entiendo por qué sucede esto (enlace del descriptor) , y puedo _stat_func()solucionarlo convirtiéndolo manualmente en un método estático después de su último uso, así:

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

Entonces mi pregunta es:

¿Hay mejores formas, como en limpia o más "pitón", de lograr esto?

staticmethodAparentemente, los objetos tienen un __func__atributo que almacena la función original sin procesar (tiene sentido que tuvieran que hacerlo). Entonces esto 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

Por otro lado, aunque sospechaba que un objeto de método estático tenía algún tipo de atributo que almacenaba la función original, no tenía idea de los detalles. En el espíritu de enseñar a alguien a pescar en lugar de darle un pez, esto es lo que hice para investigar y descubrirlo (un C&P de mi sesión de 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 similares de excavación en una sesión interactiva (dir es muy útil) a menudo pueden resolver este tipo de preguntas muy rápidamente.

Esta es la forma en que prefiero:

class Klass(object):

    @staticmethod
    def stat_func():
        return 42

    _ANS = stat_func.__func__()

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

Prefiero esta solución Klass.stat_func, debido al principio DRY . Me recuerda la razón porsuper() la cual hay una nueva en Python 3 :)

Pero estoy de acuerdo con los demás, por lo general, la mejor opción es definir una función de nivel de módulo.

Por ejemplo, con la @staticmethodfunción, la recursión puede no verse muy bien (necesitaría romper el principio DRY llamando al Klass.stat_funcinterior Klass.stat_func). Eso es porque no tiene referencia al selfmétodo estático interno. Con la función de nivel de módulo, todo se verá bien.

¿Qué hay de inyectar el atributo de clase después de la definición de clase?

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

Esto se debe a que el método estático es un descriptor y requiere una búsqueda de atributos a nivel de clase para ejercer el protocolo del descriptor y obtener el verdadero invocable.

Del código fuente:

Se puede invocar en la clase (p C.f(). Ej. ) O en una instancia (p C().f(). Ej. ); la instancia se ignora a excepción de su clase.

Pero no directamente desde dentro de la clase mientras se está definiendo.

Pero como mencionó un comentarista, este no es realmente un diseño "pitónico" en absoluto. Simplemente use una función de nivel de módulo en su lugar.

¿Qué hay de esta solución? No se basa en el conocimiento de la @staticmethodimplementación del decorador. La clase interna StaticMethod juega como un contenedor de funciones de inicialización 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