Wywołanie metody statycznej klasy w treści klasy?

Kiedy próbuję użyć metody statycznej z treści klasy i zdefiniować metodę statyczną za pomocą funkcji wbudowanej staticmethodjako dekoratora, na przykład:

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

Otrzymuję następujący błąd:

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

Rozumiem, dlaczego tak się dzieje (wiązanie deskryptora) i mogę to obejść, ręcznie konwertując _stat_func()na metodę statyczną po jej ostatnim użyciu, na przykład:

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

Więc moje pytanie brzmi:

Czy są lepsze, jak w czystszym lub bardziej „Pythonic”, sposoby osiągnięcia tego celu?

staticmethodobiekty najwyraźniej mają __func__atrybut przechowujący oryginalną funkcję surową (ma sens, że musiały). Więc to zadziała:

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

Na marginesie, chociaż podejrzewałem, że obiekt metody static ma jakiś atrybut przechowujący oryginalną funkcję, nie miałem pojęcia o szczegółach. W duchu uczenia kogoś, jak łowić, zamiast dawać mu rybę, oto co zrobiłem, aby to zbadać i dowiedzieć się (C&P z mojej sesji w Pythonie):

>>> 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>

Podobne rodzaje przekopywania się podczas sesji interaktywnej ( dirjest to bardzo pomocne) często mogą bardzo szybko rozwiązać tego rodzaju pytania.

Tak wolę:

class Klass(object):

    @staticmethod
    def stat_func():
        return 42

    _ANS = stat_func.__func__()

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

Wolę to rozwiązanie niż Klass.stat_funcze względu na zasadę DRY . Przypomina mi powód, dla którego pojawił się nowysuper() w Pythonie 3 :)

Ale zgadzam się z innymi, zwykle najlepszym wyborem jest zdefiniowanie funkcji na poziomie modułu.

Na przykład w przypadku @staticmethodfunkcji rekurencja może nie wyglądać zbyt dobrze (musiałbyś złamać zasadę DRY, dzwoniąc do Klass.stat_funcśrodka Klass.stat_func). Dzieje się tak, ponieważ nie masz odwołania do selfwewnętrznej metody statycznej. Dzięki funkcji na poziomie modułu wszystko będzie wyglądać dobrze.

A co z wstrzyknięciem atrybutu class po definicji klasy?

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

Wynika to z faktu, że metoda staticmethod jest deskryptorem i wymaga pobrania atrybutu na poziomie klasy w celu wykonania protokołu deskryptora i uzyskania prawdziwego możliwego do wywołania.

Z kodu źródłowego:

Można go wywołać w klasie (np. C.f()) Lub w instancji (np. C().f()); instancja jest ignorowana z wyjątkiem jej klasy.

Ale nie bezpośrednio z wnętrza klasy podczas jej definiowania.

Ale jak wspomniał jeden z komentatorów, to wcale nie jest projekt „Pythonic”. Zamiast tego użyj funkcji na poziomie modułu.

A co z tym rozwiązaniem? Nie polega na znajomości @staticmethodimplementacji dekoratora. Klasa wewnętrzna StaticMethod odgrywa rolę kontenera statycznych funkcji inicjalizacyjnych.

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