Python 中的静态方法?

Python 中是否可以有无需初始化类即可调用的静态方法,例如:

ClassName.static_method()

答案

是的,使用staticmethod装饰器

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, ...): ...

@staticmethod 形式是一个函数装饰器 –有关详细信息,请参见函数定义中的函数定义说明。

可以在类(例如Cf() )或实例(例如C().f() )上调用它。该实例除其类外均被忽略。

Python 中的静态方法类似于 Java 或 C ++ 中的静态方法。有关更高级的概念,请参见classmethod()

有关静态方法的更多信息,请参阅标准类型层次结构中有关标准类型层次结构的文档。

2.2 版中的新功能。

在版本 2.4 中更改:添加了函数装饰器语法。

我认为史蒂文实际上是对的 。为了回答最初的问题,然后,为了建立一个类方法,只需假设第一个参数不会成为调用实例,然后确保仅从类中调用该方法。

(请注意,此答案是针对 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 为数字时,现在 n 将表示 Dog 实例(即 rex)。

这是装饰的来源:如果我们在 “rollCall” 方法之前加上

@staticmethod

然后,通过明确声明该方法是静态的,我们甚至可以从实例中调用它。现在,

rex.rollCall(-1)

会工作。然后,在方法定义之前插入 @staticmethod 可以阻止实例将自身作为参数发送。

您可以通过尝试以下代码(带有和不带有 @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)

是的,请检查staticmethod装饰器:

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

您实际上并不需要使用@staticmethod装饰器。只需声明一个方法(不需要 self 参数)并从类中调用它即可。装饰器仅在您还希望能够从实例调用它的情况下存在(这不是您想要执行的操作)

通常,您只是使用函数而已...

Python 中的静态方法?

Python 中是否可以有静态方法,所以我可以在不初始化类的情况下调用它们,例如:

ClassName.StaticMethod()

是的,可以这样创建静态方法(尽管使用下划线而不是 CamelCase 的方法有点Pythonic ):

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

静态方法的内置示例是 Python 3 中的str.maketrans() ,它是 Python 2 中string模块中的函数。


您可以使用的另一个选择是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'])

除了静态方法对象的行为方式的特殊性之外,在组织模块级代码时,还可以利用它们带来某种美感。

# 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

也许最简单的选择就是将这些函数放在类之外:

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装饰器。

因此,静态方法是可以在不创建类对象的情况下调用的方法。例如 :-

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

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

在上面的示例方法中, add由类名A而不是对象名调用。

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

  1. 使用 @staticmethod

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

输出:

结果:25

我不时遇到这个问题。我喜欢的用例和示例是:

jeffs@jeffs-desktop:/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 类的对象没有任何意义,因为 cmath 对象中没有任何状态。但是,cmath 是所有以某种方式相关的方法的集合。在上面的示例中,cmath 中的所有函数都以某种方式作用于复数。