Chiamare il metodo statico di classe all'interno del corpo della classe?

Quando provo a usare un metodo statico all'interno del corpo della classe e definisco il metodo statico usando la staticmethodfunzione integrata come decoratore, in questo modo:

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

Ottengo il seguente errore:

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

Capisco perché ciò sta accadendo (associazione del descrittore) e posso aggirare il problema convertendolo manualmente _stat_func()in un metodo statico dopo il suo ultimo utilizzo, in questo modo:

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

Quindi la mia domanda è:

Ci sono modi migliori, come quelli più puliti o più "Pythonic", per farlo?

staticmethodgli oggetti hanno apparentemente un __func__attributo che memorizza la funzione raw originale (ha senso che dovevano farlo). Quindi questo funzionerà:

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

Per inciso, anche se sospettavo che un oggetto staticmethod avesse una sorta di attributo che memorizzava la funzione originale, non avevo idea dei dettagli. Nello spirito di insegnare a qualcuno a pescare piuttosto che dargli un pesce, questo è quello che ho fatto per indagare e scoprirlo (un C&P dalla mia sessione di 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>

Tipi simili di scavi in ​​una sessione interattiva ( dirè molto utile) possono spesso risolvere questi tipi di domande molto rapidamente.

Questo è il modo in cui preferisco:

class Klass(object):

    @staticmethod
    def stat_func():
        return 42

    _ANS = stat_func.__func__()

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

Preferisco questa soluzione a Klass.stat_funccausa del principio DRY . Mi ricorda il motivo per cui c'è un nuovosuper() in Python 3 :)

Ma sono d'accordo con gli altri, di solito la scelta migliore è definire una funzione a livello di modulo.

Ad esempio con la @staticmethodfunzione, la ricorsione potrebbe non sembrare molto buona (dovresti rompere il principio DRY chiamando Klass.stat_funcall'interno Klass.stat_func). Questo perché non hai riferimenti al selfmetodo statico interno. Con la funzione a livello di modulo, tutto sembrerà OK.

Che dire dell'iniezione dell'attributo class dopo la definizione della 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

Ciò è dovuto al fatto che il metodo statico è un descrittore e richiede un recupero di attributo a livello di classe per esercitare il protocollo descrittore e ottenere il vero callable.

Dal codice sorgente:

Può essere chiamato sulla classe (ad es. C.f()) O su un'istanza (ad es. C().f()); l'istanza viene ignorata ad eccezione della sua classe.

Ma non direttamente dall'interno della classe mentre viene definita.

Ma come ha detto un commentatore, questo non è affatto un design "Pythonic". Usa invece una funzione a livello di modulo.

E questa soluzione? Non si basa sulla conoscenza dell'implementazione del @staticmethoddecoratore. Classe interna StaticMethod viene utilizzato come contenitore di funzioni di inizializzazione statica.

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