Versión de Python

Question 1

Cuando intento usar un método estático dentro del cuerpo de la clase y defino el método estático usando el método incorporado staticmethod funcionar 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):
  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 de descriptor)y puede solucionarlo convirtiendo manualmente _stat_func() 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 formas más limpias o más “Pythonic” de lograr esto?

Question 2

actualización para la versión de python> = 3.10: las funciones de método estático se pueden llamar desde dentro del alcance de la clase muy bien (para obtener más información, consulte: rastreador de problemas de pythono “qué hay de nuevo”o aquí)

para la versión de python

staticmethod los objetos aparentemente tienen un __func__ atributo que almacena la función sin procesar original (tiene sentido que tuvieran que hacerlo). Así que 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

Aparte, 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. Con el espíritu de enseñarle 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 puede resolver este tipo de preguntas muy rápidamente.

Question 3

Esta es la forma 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 a Klass.stat_funcdebido a la principio SECO. me recuerda a la razón por la cual hay una nueva super() en pitón 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 @staticmethod función, la recursividad podría no verse muy bien (Debería romper el principio DRY llamando Klass.stat_func adentro Klass.stat_func). Eso es porque no tienes referencia a self dentro del método estático. Con la función de nivel de módulo, todo se verá bien.

Question 4

Esto se debe a que staticmethod es un descriptor y requiere una obtención de atributo de nivel de clase para ejecutar el protocolo del descriptor y obtener el verdadero invocable.

Desde el código fuente:

Se puede llamar en la clase (p. ej. C.f()) o en una instancia (p. ej. C().f()); la instancia se ignora excepto por su clase.

Pero no directamente desde dentro de la clase mientras se define.

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

Question 5

¿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

Question 6

¿Qué pasa con esta solución? No se basa en el conocimiento de @staticmethod implementación del decorador. La clase interna StaticMethod actúa como un contenedor de funciones de inicialización estáticas.

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

Question 7

Si el “problema central” es asignar variables de clase usando funciones, una alternativa es usar una metaclase (es un poco “molesto” y “mágico” y estoy de acuerdo en que el método estático debería poder llamarse dentro de la clase, pero desafortunadamente no lo es t). De esta forma, podemos refactorizar el comportamiento en una función independiente y no abarrotar la clase.

class KlassMetaClass(type(object)):
    @staticmethod
    def _stat_func():
        return 42

    def __new__(cls, clsname, bases, attrs):
        # Call the __new__ method from the Object metaclass
        super_new = super().__new__(cls, clsname, bases, attrs)
        # Modify class variable "_ANS"
        super_new._ANS = cls._stat_func()
        return super_new

class Klass(object, metaclass=KlassMetaClass):
    """
    Class that will have class variables set pseudo-dynamically by the metaclass
    """
    pass

print(Klass._ANS) # prints 42

Usar esta alternativa “en el mundo real” puede ser problemático. Tuve que usarlo para anular las variables de clase en las clases de Django, pero en otras circunstancias tal vez sea mejor optar por una de las alternativas de las otras respuestas.

Question 8

para la versión de python> = 3.10, las funciones de método estático se pueden llamar desde dentro del alcance de la clase muy bien

Un consejo para el foro de python.org: https://discuss.python.org/t/staticmethod-called-outside-class-scope/15007/4 (para más información: sigue leyendo en Problema de Python #87848o “qué hay de nuevo”)
probé en python 3.9 (rockylinux:9) y python 3.10 (fedora:36) con el siguiente ejemplo de código mínimo:

class Tmp:
    @staticmethod
    def func1():
        return 1234
    X = func1() 
print(Tmp.X)

mi prueba muestra:
- errores de python3.9
- python3.10 funciona bien (sin errores)

actualización para la versión de python> = 3.10: las funciones de método estático se pueden llamar desde dentro del alcance de la clase muy bien (para obtener más información, consulte: rastreador de problemas de pythono “qué hay de nuevo”o aquí)

para la versión de python

para la versión de python> = 3.10, las funciones de método estático se pueden llamar desde dentro del alcance de la clase muy bien

¿Ha sido útil esta solución?