Называете класс статическим методом внутри тела класса?

Когда я пытаюсь использовать статический метод из тела класса, и определяю статический метод, используя встроенную staticmethodфункцию в качестве декоратора, например:

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

Я получаю следующую ошибку:

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

Я понимаю, почему это происходит (привязка дескриптора) , и могу обойти это, вручную преобразовав _stat_func()метод static после его последнего использования, например, так:

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

Итак, мой вопрос:

Есть ли лучшие, как в более чистых или более «Pythonic», способы сделать это?

staticmethodу объектов, по-видимому, есть __func__атрибут, хранящий исходную необработанную функцию (имеет смысл, что они должны были). Так что это будет работать:

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

Помимо этого, хотя я подозревал, что у объекта staticmethod есть какой-то атрибут, хранящий исходную функцию, я понятия не имел о специфике. В духе обучения кого-то ловить рыбу, а не давать ему рыбу, это то, что я сделал, чтобы исследовать и выяснить это (C & P из моей сессии 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>

Подобные виды копания в интерактивном сеансе ( dirочень полезно) часто могут решить такие вопросы очень быстро.

Это способ, которым я предпочитаю:

class Klass(object):

    @staticmethod
    def stat_func():
        return 42

    _ANS = stat_func.__func__()

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

Я предпочитаю это решение Klass.stat_funcиз-за принципа СУХОЙ . Напоминает мне причину появления новогоsuper() в Python 3 :)

Но я согласен с другими, обычно лучшим выбором является определение функции уровня модуля.

Например, с @staticmethodфункцией рекурсия может выглядеть не очень хорошо (вам нужно нарушить принцип DRY, вызывая Klass.stat_funcвнутри Klass.stat_func). Это потому, что у вас нет ссылки на selfвнутренний статический метод. С функцией уровня модуля все будет выглядеть хорошо.

Как насчет введения атрибута класса после определения класса?

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

Это происходит из-за того, что staticmethod является дескриптором и требует выборки атрибутов на уровне класса, чтобы использовать протокол дескриптора и получить истинный вызываемый объект.

Из исходного кода:

Он может быть вызван либо в классе (например C.f()), либо в экземпляре (например C().f()); экземпляр игнорируется за исключением его класса.

Но не прямо из класса, пока он определяется.

Но, как заметил один комментатор, на самом деле это не «Pythonic» дизайн. Просто используйте вместо этого функцию уровня модуля.

Как насчет этого решения? Он не зависит от знаний о @staticmethodреализации декоратора. Внутренний класс StaticMethod играет роль контейнера статических функций инициализации.

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