Appel de la méthode statique de la classe dans le corps de la classe?

Lorsque j'essaie d'utiliser une méthode statique à partir du corps de la classe et que je définis la méthode statique en utilisant la staticmethodfonction intégrée en tant que décorateur, comme ceci:

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

J'obtiens l'erreur suivante:

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

Je comprends pourquoi cela se produit (liaison de descripteur) , et je peux le contourner en convertissant manuellement _stat_func()en une méthode statique après sa dernière utilisation, comme ceci:

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

Ma question est donc:

Y a-t-il de meilleures façons, par exemple, plus propres ou plus «pythoniques», d'accomplir cela?

staticmethodles objets ont apparemment un __func__attribut stockant la fonction brute d'origine (il est logique qu'ils le fassent). Donc cela fonctionnera:

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

En passant, même si je soupçonnais qu'un objet staticmethod avait une sorte d'attribut stockant la fonction d'origine, je n'avais aucune idée des détails. Dans l'esprit d'apprendre à quelqu'un à pêcher plutôt que de lui donner un poisson, voici ce que j'ai fait pour enquêter et le découvrir (un C&P de ma session 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>

Des types similaires de fouille dans une session interactive ( direst très utile) peuvent souvent résoudre ce type de questions très rapidement.

C'est comme ça que je préfère:

class Klass(object):

    @staticmethod
    def stat_func():
        return 42

    _ANS = stat_func.__func__()

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

Je préfère cette solution à Klass.stat_func, en raison du principe DRY . Cela me rappelle la raison pour laquelle il y a un nouveausuper() dans Python 3 :)

Mais je suis d'accord avec les autres, généralement le meilleur choix est de définir une fonction au niveau du module.

Par exemple, avec la @staticmethodfonction, la récursivité peut ne pas sembler très bonne (vous auriez besoin de casser le principe DRY en appelant Klass.stat_funcà l' intérieur Klass.stat_func). C'est parce que vous n'avez pas de référence à selfla méthode statique interne. Avec la fonction de niveau de module, tout semblera OK.

Qu'en est-il de l'injection de l'attribut de classe après la définition de 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

Cela est dû au fait que staticmethod est un descripteur et nécessite une extraction d'attribut au niveau de la classe pour exercer le protocole du descripteur et obtenir le vrai appelable.

À partir du code source:

Il peut être appelé soit sur la classe (par exemple C.f()) soit sur une instance (par exemple C().f()); l'instance est ignorée sauf pour sa classe.

Mais pas directement de l'intérieur de la classe pendant sa définition.

Mais comme un commentateur l'a mentionné, ce n'est pas du tout une conception "pythonique". Utilisez simplement une fonction de niveau module à la place.

Et cette solution? Il ne repose pas sur la connaissance de la @staticmethodmise en œuvre du décorateur. La classe interne StaticMethod joue comme un conteneur de fonctions d'initialisation statiques.

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