使用静态方法有什么好处？

Question

我用代码在python中遇到了未绑定方法错误

import random

class Sample(object):
    '''This class defines various methods related to the sample'''

    def drawSample(samplesize,List):
        sample=random.sample(List,samplesize)
        return sample

Choices=range(100)
print Sample.drawSample(5,Choices)

在这里阅读了许多有用的帖子后，我想出了如何在上面添加@staticmethod 以使代码正常工作。我是蟒蛇新手。有人可以解释一下为什么要定义静态方法吗？或者，为什么不是所有的方法都定义为静态方法？

Answer 1

staticmethod 的替代选项是：classmethod、instancemethod 和 function。如果您不知道这些是什么，请向下滚动到最后一部分。如果staticmethod 比这些替代方案中的任何一个更好，则取决于它的编写目的。

Python 静态方法的优点

• 如果您不需要访问类或实例的属性或方法，staticmethod 比classmethod 或instancemethod 更好。这样就很清楚（来自@staticmethod 装饰器）类和实例的状态没有被读取或修改。但是，使用 function 会使这种区别更加清晰（请参阅缺点）。
• staticmethod的调用签名与classmethod或instancemethod的调用签名相同，即<instance>.<method>(<arguments>)。因此，如果以后需要或在派生类中需要，它可以很容易地被 三个 之一替换。简单的function 无法做到这一点。
• 可以使用staticmethod 代替function 来明确它主观上属于一个类并防止命名空间冲突。

Python 静态方法的缺点

• 它不能访问实例或类的属性或方法。
• staticmethod 的调用签名与classmethod 或instancemethod 的调用签名相同。这掩盖了staticmethod 实际上并未读取或修改任何对象信息的事实。这使得代码更难阅读。为什么不直接使用function？
• 如果您需要从定义它的类/实例外部调用staticmethod，则很难重复使用它。如果有任何重复使用的潜力，function 是更好的选择。
• staticmethod 很少使用，因此阅读包含 staticmethod 的代码的人可能需要更长的时间来阅读它。

Python 中静态方法的替代方案

要讨论staticmethod 的优势，我们需要知道替代方案是什么以及它们之间的区别。

• staticmethod 属于一个类，但不能访问或修改任何实例或类信息。

它有三种选择：

• classmethod 可以访问调用者的类。
• instancemethod 可以访问调用者的实例及其类。
• function 与类无关。它的功能最接近staticmethod。

这是代码中的样子：

# function
# has nothing to do with a class
def make_cat_noise(asker_name):
    print('Hi %s, mieets mieets!' % asker_name)

# Yey, we can make cat noises before we've even defined what a cat is!
make_cat_noise('JOey')  # just a function

class Cat:
    number_of_legs = 4

    # special instance method __init__
    def __init__(self, name):
        self.name = name

    # instancemethod
    # the instance (e.g. Cat('Kitty')) is passed as the first method argument
    def tell_me_about_this_animal(self, asker_name):
        print('Hi %s, This cat has %d legs and is called %s'
              % (asker_name, self.number_of_legs, self.name))

    # classmethod
    # the class (e.g. Cat) is passed as the first method argument
    # by convention we call that argument cls
    @classmethod
    def tell_me_about_cats(cls, asker_name):
        print("Hi %s, cats have %d legs."
              % (asker_name, cls.number_of_legs))
        # cls.name  # AttributeError because only the instance has .name
        # self.name  # NameError because self isn't defined in this namespace

    # staticmethod
    # no information about the class or the instance is passed to the method
    @staticmethod
    def make_noise(asker_name):
        print('Hi %s, meooow!' % asker_name)
        # class and instance are not accessible from here

# one more time for fun!
make_cat_noise('JOey')  # just a function

# We just need the class to call a classmethod or staticmethod:
Cat.make_noise('JOey')  # staticmethod
Cat.tell_me_about_cats('JOey')  # classmethod
# Cat.tell_me_about_this_animal('JOey')  # instancemethod -> TypeError

# With an instance we can use instancemethod, classmethod or staticmethod
mycat = Cat('Kitty')  # mycat is an instance of the class Cat
mycat.make_noise('JOey')  # staticmethod
mycat.tell_me_about_cats('JOey')  # classmethod
mycat.tell_me_about_this_animal('JOey')  # instancemethod

Answer 2

这不是你的实际问题的重点，但既然你说你是一个 python 新手，也许它会有所帮助，而且没有其他人完全站出来明确地说出来。

我永远不会通过将方法设为静态方法来修复上述代码。我要么放弃这门课，只写一个函数：

def drawSample(samplesize,List):
    sample=random.sample(List,samplesize)
    return sample

Choices=range(100)
print drawSample(5,Choices)

如果你有很多相关的函数，你可以将它们分组到一个模块中——即将它们都放在同一个文件中，例如命名为sample.py；那么

import sample

Choices=range(100)
print sample.drawSample(5,Choices)

或者我会在类中添加一个__init__ 方法并创建一个具有有用方法的实例：

class Sample(object):
'''This class defines various methods related to the sample'''

    def __init__(self, thelist):
        self.list = thelist

    def draw_sample(self, samplesize):
        sample=random.sample(self.list,samplesize)
        return sample

choices=Sample(range(100))
print choices.draw_sample(5)

（我还更改了上面示例中的大小写约定以匹配 PEP 8 推荐的样式。）

Python 的优点之一是它不会强迫您对所有事情都使用类。只有当存在应该与方法相关联的数据或状态时才能使用它们，这就是类的用途。否则，您可以使用函数，这就是函数的用途。

Answer 3

据我估计，使用@staticmethods 与仅在类之外定义函数相比，并没有单一的性能优势，否则它将是@staticmethod 的类。

我要说的唯一证明它们存在的理由就是方便。静态方法在其他流行的编程语言中很常见，那么为什么不是 python 呢？如果您想创建一个行为与您为其创建它的类非常密切相关的函数，但它实际上并没有以一种证明将其概念化为典型的方式来访问/修改类实例的内部数据然后在该类的方法上面加上@staticmethod，任何阅读您的代码的人都会立即了解该方法的性质及其与类的关系。

我偶尔喜欢做的一件事是将我的班级内部经常使用的功能放入私有@staticmethods。这样一来，我的模块所公开的 API 就不会被使用我模块的任何人都不需要看到的方法弄乱，更不用说使用了。

Answer 4

静态方法的用途有限，因为它们无法访问类实例的属性（就像常规方法一样），也无法访问类本身的属性（例如类方法可以）。

因此它们对于日常方法没有用处。

但是，它们可以用于将某些实用程序功能与类组合在一起 - 例如从一种类型到另一种类型的简单转换 - 除了提供的参数（可能还有模块的一些全局属性）之外，不需要访问任何信息。

它们可以放在类之外，但是将它们分组到类中可能是有意义的，它们只适用于那里。

您也可以通过实例或类来引用方法，而不是模块名称，这可能有助于读者理解该方法与哪个实例相关。

Answer 5

因为命名空间函数很好（如前所述）：

1. 当我想明确说明不改变对象状态的方法时，我使用静态方法。这不鼓励我团队中的人开始在这些方法中更改对象的属性。

2. 当我重构真正烂代码时，我首先尝试创建尽可能多的方法@staticmethod。这让我可以将这些方法提取到一个类中——尽管我同意，这不是我使用的东西，但它确实有用过几次。

Answer 6

详细解释见this article。

TL;DR

1.它消除了self参数的使用。

2.它减少了内存使用，因为Python不必为每个实例化的对象实例化bound-method：

>>>RandomClass().regular_method is RandomClass().regular_method
False
>>>RandomClass().static_method is RandomClass().static_method
True
>>>RandomClass.static_method is RandomClass().static_method
True

3.它提高了代码的可读性，表明该方法不依赖于对象本身的状态。

4.它允许方法覆盖，因为如果方法是在模块级别（即在类之外）定义的，则子类将无法覆盖该方法。

Answer 7

为什么要定义静态方法？

假设我们有一个名为Math 的class 那么

没有人会想要创建class Math 的对象
然后在其上调用ceil 和floor 和fabs 之类的方法。

所以我们将它们设为static。

例如做

>> Math.floor(3.14)

比

好很多

>> mymath = Math()
>> mymath.floor(3.14)

所以它们在某些方面很有用。您无需创建类的实例即可使用它们。

为什么不是所有的方法都定义为静态方法？

他们无权访问实例变量。

class Foo(object):
    def __init__(self):
        self.bar = 'bar'

    def too(self):
        print self.bar

    @staticmethod
    def foo():
        print self.bar

Foo().too() # works
Foo.foo() # doesn't work

这就是为什么我们不将所有方法都设为静态的原因。

Answer 8

当您从对象实例调用函数对象时，它成为“绑定方法”并获取实例对象本身作为第一个参数传入。

当您在对象实例上调用classmethod 对象（包装函数对象）时，实例对象的类作为第一个参数传入。

当您调用 staticmethod 对象（包装函数对象）时，不使用隐式第一个参数。

class Foo(object):

    def bar(*args):
        print args

    @classmethod
    def baaz(*args):
        print args

    @staticmethod
    def quux(*args):
        print args

>>> foo = Foo()

>>> Foo.bar(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method bar() must be called with Foo instance as first argument (got int instance instead)
>>> Foo.baaz(1,2,3)
(<class 'Foo'>, 1, 2, 3)
>>> Foo.quux(1,2,3)
(1, 2, 3)

>>> foo.bar(1,2,3)
(<Foo object at 0x1004a4510>, 1, 2, 3)
>>> foo.baaz(1,2,3)
(<class 'Foo'>, 1, 2, 3)
>>> foo.quux(1,2,3)
(1, 2, 3)

Answer 9

静态方法在 Python 中几乎没有理由存在。您可以使用实例方法或类方法。

def method(self, args):
    self.member = something

@classmethod
def method(cls, args):
    cls.member = something

@staticmethod
def method(args):
    MyClass.member = something
    # The above isn't really working
    # if you have a subclass

Answer 10

静态方法很棒，因为您不必声明该方法所属对象的实例。

python 的站点在这里有一些关于静态方法的精彩文档：
http://docs.python.org/library/functions.html#staticmethod