Статические методы в Python?

Ответ 1

Да, используя статический метод декоратор

class MyClass(object):
    @staticmethod
    def the_static_method(x):
        print(x)

MyClass.the_static_method(2)  # outputs 2

Обратите внимание, что в некотором коде может использоваться старый метод определения статического метода, использующий staticmethod в качестве функции, а не декоратора. Это следует использовать, только если вы должны поддерживать древние версии Python (2.2 и 2.3)

class MyClass(object):
    def the_static_method(x):
        print(x)
    the_static_method = staticmethod(the_static_method)

MyClass.the_static_method(2)  # outputs 2

Это полностью идентично первому примеру (с использованием @staticmethod), только без использования хорошего синтаксиса декоратора

Наконец, используйте staticmethod() экономно! В Python очень мало ситуаций, когда необходимы статические методы, и я видел, как они много раз использовались, когда отдельная функция "верхнего уровня" была бы более понятной.

Ниже приводится дословно из документации::

Статический метод не получает неявный первый аргумент. Чтобы объявить статический метод, используйте эту идиому:

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

The @staticmethod form is a function decorator – see the description of function definitions in Function definitions for details.

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

Статические методы в Python аналогичны тем, которые можно найти в Java или C++. Для более сложной концепции см. classmethod().

Дополнительную информацию о статических методах см. в документации по стандартной иерархии типов в Стандартной иерархии типов.

Новое в версии 2.2.

Изменено в версии 2.4: добавлен синтаксис функции декоратора.

Ответ 2

Я думаю, что Стивен на самом деле прав. Чтобы ответить на исходный вопрос, затем, чтобы настроить метод класса, просто предположите, что первый аргумент не будет вызывающим экземпляром, а затем убедитесь, что вы вызываете метод только из класса.

(Обратите внимание, что этот ответ относится к Python 3.x. В Python 2.x вы получите TypeError для вызова метода в самом классе.)

Например:

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    def rollCall(n): #this is implicitly a class method (see comments below)
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))

fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)

В этом коде метод "rollCall" предполагает, что первый аргумент не является экземпляром (как если бы он был вызван экземпляром вместо класса). Пока "rollCall" вызывается из класса, а не экземпляра, код будет работать нормально. Если мы попытаемся вызвать "rollCall" из экземпляра, например:

rex.rollCall(-1)

однако это приведет к возникновению исключения, поскольку он отправит два аргумента: сам и -1, а "rollCall" определяется только для принятия одного аргумента.

Кстати, rex.rollCall() отправляет правильное количество аргументов, но также вызывает исключение, потому что теперь n будет представлять экземпляр Dog (т.е. Rex), когда функция ожидает, что n будет численным.

Здесь происходит декорация: если мы предшествуем методу rollCall,

@staticmethod

то, явно указывая, что метод статичен, мы можем даже вызвать его из экземпляра. Теперь,

rex.rollCall(-1)

должно сработать. Таким образом, вставка метода @static перед определением метода останавливает экземпляр от отправки себя в качестве аргумента.

Вы можете проверить это, попробовав следующий код с и без строки @staticmethod.

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    @staticmethod
    def rollCall(n):
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))


fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)
rex.rollCall(-1)

Ответ 3

Да, посмотрите staticmethod decorator:

>>> class C:
...     @staticmethod
...     def hello():
...             print "Hello World"
...
>>> C.hello()
Hello World

Ответ 4

Вам действительно не нужно использовать декоратор @staticmethod. Просто объявляя метод (который не ожидает параметра self) и вызывает его из класса. Декоратор только там, если вы хотите иметь возможность вызвать его из экземпляра (что не было тем, что вы хотели сделать)

В основном, вы просто используете функции, хотя...

Ответ 5

Статические методы в Python?

Возможно ли иметь статические методы в Python, чтобы я мог их назвать без инициализации класса, например:

ClassName.StaticMethod()

Да, статические методы могут быть созданы как это (хотя немного более Pythonic использовать символы подчеркивания вместо методов CamelCase для методов):

class ClassName(object):

    @staticmethod
    def static_method(kwarg1=None):
        '''return a value that is a function of kwarg1'''

В приведенном выше примере используется синтаксис декоратора. Этот синтаксис эквивалентен

class ClassName(object):

    def static_method(kwarg1=None):
        '''return a value that is a function of kwarg1'''

    static_method = staticmethod(static_method)

Это можно использовать так, как вы описали:

ClassName.static_method()

Встроенным примером статического метода является str.maketrans() в Python 3, который был функцией в модуле string в Python 2.

Другим вариантом, который можно использовать при описании, является classmethod, различие заключается в том, что classmethod получает класс как неявный первый аргумент, и если он подклассифицирован, то он получает подкласс как неявный первый аргумент.

class ClassName(object):

    @classmethod
    def class_method(cls, kwarg1=None):
        '''return a value that is a function of the class and kwarg1'''

Обратите внимание, что cls не является обязательным именем для первого аргумента, но большинство опытных кодировщиков Python будут считать это плохо выполненным, если вы используете что-то еще.

Они обычно используются в качестве альтернативных конструкторов.

new_instance = ClassName.class_method()

Встроенный пример dict.fromkeys():

new_dict = dict.fromkeys(['key1', 'key2'])

Ответ 6

Помимо особенностей того, как объекты статического метода ведут себя, есть определенная красота, с которой вы можете столкнуться, когда дело доходит до организации ваш код на уровне модуля.

# garden.py
def trim(a):
    pass

def strip(a):
    pass

def bunch(a, b):
    pass

def _foo(foo):
    pass

class powertools(object):
    """
    Provides much regarded gardening power tools.
    """
    @staticmethod
    def answer_to_the_ultimate_question_of_life_the_universe_and_everything():
        return 42

    @staticmethod
    def random():
        return 13

    @staticmethod
    def promise():
        return True

def _bar(baz, quux):
    pass

class _Dice(object):
    pass

class _6d(_Dice):
    pass

class _12d(_Dice):
    pass

class _Smarter:
    pass

class _MagicalPonies:
    pass

class _Samurai:
    pass

class Foo(_6d, _Samurai):
    pass

class Bar(_12d, _Smarter, _MagicalPonies):
    pass

...

# tests.py
import unittest
import garden

class GardenTests(unittest.TestCase):
    pass

class PowertoolsTests(unittest.TestCase):
    pass

class FooTests(unittest.TestCase):
    pass

class BarTests(unittest.TestCase):
    pass

...

# interactive.py
from garden import trim, bunch, Foo

f = trim(Foo())
bunch(f, Foo())

...

# my_garden.py
import garden
from garden import powertools

class _Cowboy(garden._Samurai):
    def hit():
        return powertools.promise() and powertools.random() or 0

class Foo(_Cowboy, garden.Foo):
    pass

Теперь он становится немного более интуитивно понятным и самодокументирующимся, в контексте которого предполагается использовать некоторые компоненты, и он идеально подходит для обозначения различных тестовых случаев, а также для простого подхода к тому, как тестовые модули сопоставляются с фактическими модулями в тесты для пуристов.

Я часто считаю целесообразным применить этот подход к организации кода утилиты проекта. Довольно часто люди сразу бросаются и создают пакет utils и в итоге получают 9 модулей, из которых 120 LOC, а остальные - в два десятка LOC в лучшем случае. Я предпочитаю начинать с этого и преобразовывать его в пакет и создавать модули только для тех зверей, которые их действительно заслуживают:

# utils.py
class socket(object):
    @staticmethod
    def check_if_port_available(port):
        pass

    @staticmethod
    def get_free_port(port)
        pass

class image(object):
    @staticmethod
    def to_rgb(image):
        pass

    @staticmethod
    def to_cmyk(image):
        pass

Ответ 7

Возможно, самый простой вариант - просто поставить эти функции вне класса:

class Dog(object):
    def __init__(self, name):
        self.name = name

    def bark(self):
        if self.name == "Doggy":
            return barking_sound()
        else:
            return "yip yip"

def barking_sound():
    return "woof woof"

Используя этот метод, функции, которые изменяют или используют внутреннее состояние объекта (имеют побочные эффекты), могут храниться в классе, а функции многократного использования могут быть перемещены за пределы.

Скажем, этот файл называется dogs.py Чтобы использовать их, вы вызываете dogs.barking_sound() вместо dogs.Dog.barking_sound.

Если вам действительно нужен статический метод, который должен быть частью класса, вы можете использовать декоратор staticmethod.

Ответ 8

Итак, статические методы - это методы, которые можно вызывать без создания объекта класса. Например :-

    @staticmethod
    def add(a, b):
        return a + b

b = A.add(12,12)
print b

В приведенном выше примере метод add вызывается именем класса A не именем объекта.

Ответ 9

В Python 3:

Вот еще один хороший способ использовать нестатические методы, так как они были статическими.

class Account:
# here is the main class

# a non-static method
def login(self, url, email, password):
    # as a convention self is passed as a 
    # placeholder for the class Object itself

    self.login_url = url
    self.user_email = email
    self.user_password = password

    print(self.login_url, self.user_email, self.user_password)

Вызвать нестатический метод как статический

"""
* Referencing the Account.login(self, url, email, password)
* Just call the 'Account' object as the self 
"""
Account.login(Account, "https://example.com/login", "[email protected]", "password_example")

:$ https://example.com/login [email protected] password_example

Ответ 10

Статические методы Python могут быть созданы двумя способами.

1. Использование staticmethod()

   class Arithmetic:
       def add(x, y):
           return x + y
   # create add static method
   Arithmetic.add = staticmethod(Arithmetic.add)
   
   print('Result:', Arithmetic.add(15, 10))
   

Выход:

Результат: 25

2. Использование @staticmethod

   class Arithmetic:
   
   # create add static method
   @staticmethod
   def add(x, y):
       return x + y
   
   print('Result:', Arithmetic.add(15, 10))
   

Выход:

Результат: 25

Ответ 11

Время от времени я сталкиваюсь с этим вопросом. Вариант использования и пример, который мне нравится, это:

[email protected]:/home/jeffs  $ python36
Python 3.6.1 (default, Sep  7 2017, 16:36:03) 
[GCC 6.3.0 20170406] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cmath
>>> print(cmath.sqrt(-4))
2j
>>>
>>> dir(cmath)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
>>> 

Не имеет смысла создавать объект класса cmath, потому что в CMAT-объекте нет состояния. Однако cmath - это совокупность методов, которые в какой-то мере связаны. В моем примере выше все функции в cmath каким-то образом действуют на сложные числа.