分析@staticmethod，提供不同的见解。

类的普通方法是一种隐式动态方法，它将实例作为第一个参数。相反，静态方法不将实例作为第一个参数，因此称为“static”。

静态方法确实是一个与类定义之外的函数相同的正常函数。幸运的是，它被分组到类中，只是为了更接近应用它的位置，或者您可以滚动查找它。

我认为一个更好的问题是“你什么时候会使用@classmethod vs@staticmethod？”

@classmethod允许您轻松访问与类定义关联的私有成员。这是一种很好的方法来实现单实例，或者控制所创建对象实例数量的工厂类。

@staticmethod提供了边际性能增益，但我还没有看到静态方法在类内的有效使用，而静态方法不能作为类外的独立函数实现。

@python2.4中添加了修饰符。如果您使用的是python<2.4，则可以使用classmethod（）和staticmethod（）函数。

例如，如果您想要创建一个工厂方法（一个函数，它返回一个类的不同实现的实例，具体取决于它获得的参数），您可以执行以下操作：

class Cluster(object):

    def _is_cluster_for(cls, name):
        """
        see if this class is the cluster with this name
        this is a classmethod
        """ 
        return cls.__name__ == name
    _is_cluster_for = classmethod(_is_cluster_for)

    #static method
    def getCluster(name):
        """
        static factory method, should be in Cluster class
        returns a cluster object for the given name
        """
        for cls in Cluster.__subclasses__():
            if cls._is_cluster_for(name):
                return cls()
    getCluster = staticmethod(getCluster)

还要注意，这是一个使用类方法和静态方法的好例子，静态方法显然属于类，因为它在内部使用了类Cluster。类方法只需要关于类的信息，而不需要对象的实例。

将_is_cluster_for方法设置为类方法的另一个好处是，子类可以决定更改其实现，这可能是因为它非常通用，可以处理多种类型的集群，因此仅检查类的名称是不够的。

首先，让我们从一个示例代码开始，我们将使用它来理解这两个概念：

class Employee:

    NO_OF_EMPLOYEES = 0
  
    def __init__(self, first_name, last_name, salary):
        self.first_name = first_name
        self.last_name = last_name
        self.salary = salary
        self.increment_employees()

    def give_raise(self, amount):
        self.salary += amount

    @classmethod
    def employee_from_full_name(cls, full_name, salary):
        split_name = full_name.split(' ')
        first_name = split_name[0]
        last_name = split_name[1]
        return cls(first_name, last_name, salary)

    @classmethod
    def increment_employees(cls):
        cls.NO_OF_EMPLOYEES += 1

    @staticmethod
    def get_employee_legal_obligations_txt():
        legal_obligations = """
        1. An employee must complete 8 hours per working day
        2. ...
        """
        return legal_obligations

Class方法

类方法接受类本身作为隐式参数，以及（可选地）定义中指定的任何其他参数。重要的是要理解类方法不能访问对象实例（就像实例方法一样）。因此，类方法不能用于更改实例化对象的状态，而是能够更改该类的所有实例之间共享的类状态。当我们需要访问类本身时，类方法通常很有用——例如，当我们想要创建工厂方法时，即创建类实例的方法。换句话说，类方法可以作为替代构造函数。

在我们的示例代码中，可以通过提供三个参数来构造Employee的实例；first_name、last_name和薪水。

employee_1 = Employee('Andrew', 'Brown', 85000)
print(employee_1.first_name)
print(employee_1.salary)

'Andrew'
85000

现在，让我们假设有可能在单个字段中提供雇员的姓名，在该字段中，名字和姓氏用空格分隔。在本例中，我们可以使用名为employee_from_full_name的类方法，该方法总共接受三个参数。第一个是类本身，这是一个隐式参数，这意味着在调用方法时不会提供它-Python将自动为我们执行此操作：

employee_2 = Employee.employee_from_full_name('John Black', 95000)
print(employee_2.first_name)
print(employee_2.salary)

'John'
95000

请注意，也可以从对象实例调用employee_from_full_name，尽管在这种情况下，这没有什么意义：

employee_1 = Employee('Andrew', 'Brown', 85000)
employee_2 = employee_1.employee_from_full_name('John Black', 95000)

我们可能想要创建类方法的另一个原因是，当我们需要更改类的状态时。在我们的示例中，类变量NO_OF_EMPLOYEES跟踪当前为公司工作的员工数量。每次创建Employee的新实例时都会调用此方法，并相应地更新计数：

employee_1 = Employee('Andrew', 'Brown', 85000)
print(f'Number of employees: {Employee.NO_OF_EMPLOYEES}')
employee_2 = Employee.employee_from_full_name('John Black', 95000)
print(f'Number of employees: {Employee.NO_OF_EMPLOYEES}')

Number of employees: 1
Number of employees: 2

静态方法

另一方面，在静态方法中，实例（即self）和类本身（即cls）都不会作为隐式参数传递。这意味着此类方法不能访问类本身或其实例。现在有人可能会争辩说，静态方法在类的上下文中并不有用，因为它们也可以放在助手模块中，而不是作为类的成员添加它们。在面向对象的编程中，将类构造成逻辑块非常重要，因此，当我们需要在类下添加方法时，静态方法非常有用，因为它在逻辑上属于该类。在我们的示例中，名为get_eemployee_legal_entributions_txt的静态方法只返回一个字符串，该字符串包含公司每个员工的法律义务。此函数不与类本身或任何实例交互。它可能被放置在不同的帮助器模块中，但是，它只与这个类相关，因此我们必须将它放置在Employee类下。

可以直接从类本身访问静态方法

print(Employee.get_employee_legal_obligations_txt())


    1. An employee must complete 8 hours per working day
    2. ...

或从类的实例：

employee_1 = Employee('Andrew', 'Brown', 85000)
print(employee_1.get_employee_legal_obligations_txt())


    1. An employee must complete 8 hours per working day
    2. ...

工具书类

Python中静态方法和类方法的区别是什么？

我认为提供一个纯Python版本的staticmethod和classmethod将有助于在语言级别上理解它们之间的区别（请参阅Descriptor Howto Guide）。

这两个都是非数据描述符（如果您首先熟悉描述符，那么更容易理解它们）。

class StaticMethod(object):
    "Emulate PyStaticMethod_Type() in Objects/funcobject.c"

    def __init__(self, f):
        self.f = f

    def __get__(self, obj, objtype=None):
        return self.f


class ClassMethod(object):
    "Emulate PyClassMethod_Type() in Objects/funcobject.c"
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, cls=None):
        def inner(*args, **kwargs):
            if cls is None:
                cls = type(obj)
            return self.f(cls, *args, **kwargs)
        return inner

您可能需要考虑以下两者之间的区别：

class A:
    def foo():  # no self parameter, no decorator
        pass

and

class B:
    @staticmethod
    def foo():  # no self parameter
        pass

这在python2和python3之间发生了变化：

蟒蛇2:

>>> A.foo()
TypeError
>>> A().foo()
TypeError
>>> B.foo()
>>> B().foo()

蟒蛇3：

>>> A.foo()
>>> A().foo()
TypeError
>>> B.foo()
>>> B().foo()

因此，在python3中，对仅直接从类调用的方法使用@staticmethod已成为可选的。如果要从类和实例调用它们，仍然需要使用@staticmethoddecorator。

其他案例都被未用的答案很好地涵盖了。