我在代码中遇到了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上面添加内容以使代码正常工作。我是python新手。有人可以解释一下为什么要定义静态方法吗？还是为什么不将所有方法都定义为静态方法？

静态方法的使用受到限制，因为它们无法访问类的实例的属性（就像常规方法一样），并且它们也不能访问类本身的属性（就像类方法一样） ）。

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

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

可以将它们放在班级之外，但是将它们分组在班级内可能在仅适用于此的地方才有意义。

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

请参阅本文以获取详细说明。

TL; DR

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

2.它减少了内存使用，因为Python不必为每个实例化的对象实例化绑定方法：

>>>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.它允许方法重写，因为如果方法是在模块级别（即，在类外部）定义的，则子类将无法重写该方法。

这并不是您实际问题的重点，但是由于您已经说过自己是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的优点之一是它不会强迫您对所有内容使用类。仅当存在与方法相关联的数据或状态时，才可以使用它们，这就是类的用途。否则，您可以使用函数，这就是函数的作用。

为什么要定义静态方法？

假设我们有一个class叫做Math然后

没有人会希望创建的对象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

这就是为什么我们不使所有方法都是静态的。

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

当您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)

静态方法非常有用，因为您不必声明该方法所属的对象的实例。

python的站点在此处提供了一些有关静态方法的出色文档：http :
//docs.python.org/library/functions.html#staticmethod

一个替代方案staticmethod是：classmethod，instancemethod，和function。如果您不知道这些是什么，请向下滚动到最后一部分。如果astaticmethod优于这些替代方法，则取决于它是出于什么目的编写的。

Python静态方法的优点

• 如果您不需要访问类或实例的属性或方法，则astaticmethod优于aclassmethod或instancemethod。这样，从@staticmethod装饰器可以清楚地看到，类和实例的状态没有被读取或修改。但是，使用afunction可以使这种区分更加清晰（请参见缺点）。
• 的呼叫签名staticmethod是相同的classmethod或instancemethod，即<instance>.<method>(<arguments>)。因此，如果以后在派生类中或派生类中需要它，可以很容易地用三个之一替换它。您不能通过简单的操作function。
• staticmethod可以使用A代替afunction来明确说明它在主观上属于一个类并防止名称空间冲突。

Python静态方法的缺点

• 它无法访问实例或类的属性或方法。
• a的呼叫签名staticmethod与aclassmethod或的呼叫签名相同instancemethod。这掩盖了实际上staticmethod并没有读取或修改任何对象信息的事实。这使代码更难阅读。为什么不只是使用function？
• 一staticmethod，如果你在任何时候需要从类/实例，其中它被定义之外的电话就很难再使用。如果有重复使用的潜力，afunction是更好的选择。
• 该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

因为命名空间功能很好（如前所述）：

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

2. 当我重构非常烂的代码时，我首先尝试制作尽可能多的方法@staticmethod。然后，这使我可以将这些方法提取到类中-尽管我同意，但我很少使用它，但确实有帮助。

根据我的估计，与仅将函数定义在类之外并与之分开的功能相比，使用s并没有单一的性能优势。@staticmethod@staticmethod

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

我偶尔喜欢做的一件事是将类在内部大量使用的功能放入private @staticmethod。这样，我就不会使用任何模块都不会使我的模块公开的API变得混乱，更不用说使用它了。

静态方法几乎没有使用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