一个小汇编

@静态方法一种在类中编写方法的方法，而不引用它所调用的对象。因此不需要传递self或cls之类的隐式参数。它的编写方式与在类外部的编写方式完全相同，但在python中没有任何用处，因为如果您需要在类内部封装方法，因为该方法需要是该类的一部分，那么@staticmethod在这种情况下很方便。

@分类法当你想写一个工厂方法并且通过这个自定义属性可以附加在一个类中时，这一点很重要。可以在继承的类中重写此属性。

这两种方法的比较如下

何时使用每个

@staticmethod函数只不过是在类中定义的函数。它可以在不首先实例化类的情况下调用。它的定义通过继承是不可变的。

Python不必为对象实例化绑定方法。它简化了代码的可读性：看到@staticmethod，我们知道该方法不依赖于对象本身的状态；

@classmethod函数也可以在不实例化类的情况下调用，但它的定义遵循子类，而不是父类，通过继承，可以被子类重写。这是因为@classmethod函数的第一个参数必须始终是cls（class）。

工厂方法，用于使用例如某种预处理为类创建实例。静态方法调用静态方法：如果将静态方法拆分为多个静态方法，则不应硬编码类名，而应使用类方法

这里有一个很好的链接。

@classmethod和@staticmethod的含义？

方法是对象名称空间中的函数，可作为属性访问。常规（即实例）方法获取实例（我们通常称其为self）作为隐式第一个参数。类方法获取类（我们通常称之为cls）作为隐式第一个参数。静态方法没有得到隐式的第一个参数（像正则函数）。

我应该何时使用它们，为什么要使用它们，以及如何使用它们？

你不需要任何一个装饰器。但是，基于应该最小化函数的参数数量的原则（请参见Clean Coder），它们对于实现这一点非常有用。

class Example(object):

    def regular_instance_method(self):
        """A function of an instance has access to every attribute of that 
        instance, including its class (and its attributes.)
        Not accepting at least one argument is a TypeError.
        Not understanding the semantics of that argument is a user error.
        """
        return some_function_f(self)

    @classmethod
    def a_class_method(cls):
        """A function of a class has access to every attribute of the class.
        Not accepting at least one argument is a TypeError.
        Not understanding the semantics of that argument is a user error.
        """
        return some_function_g(cls)

    @staticmethod
    def a_static_method():
        """A static method has no information about instances or classes
        unless explicitly given. It just lives in the class (and thus its 
        instances') namespace.
        """
        return some_function_h()

对于实例方法和类方法，不接受至少一个参数是TypeError，但不理解该参数的语义是用户错误。

（定义某些函数，例如：

some_function_h = some_function_g = some_function_f = lambda x=None: x

这将起作用。）

实例和类上的虚线查找：

实例上的虚线查找按以下顺序执行：

类名称空间中的数据描述符（如属性）实例__dict中的数据__类名称空间（方法）中的非数据描述符。

注意，实例上的虚线查找是这样调用的：

instance = Example()
instance.regular_instance_method 

方法是可调用的属性：

instance.regular_instance_method()

实例方法

参数self是通过虚线查找隐式给出的。

必须从类的实例访问实例方法。

>>> instance = Example()
>>> instance.regular_instance_method()
<__main__.Example object at 0x00000000399524E0>

类方法

参数cls是通过虚线查找隐式给出的。

您可以通过实例或类（或子类）访问此方法。

>>> instance.a_class_method()
<class '__main__.Example'>
>>> Example.a_class_method()
<class '__main__.Example'>

静态方法

未隐式给出任何参数。此方法的工作方式与（例如）在模块名称空间上定义的任何函数类似，但它可以被查找

>>> print(instance.a_static_method())
None

同样，我什么时候应该使用它们，为什么要使用它们？

与实例方法相比，这些方法中的每一个在传递方法的信息方面都越来越严格。

当你不需要这些信息时使用它们。

这使您的函数和方法更易于推理和单元测试。

哪个更容易推理？

def function(x, y, z): ...

or

def function(y, z): ...

or

def function(z): ...

参数较少的函数更容易推理。它们也更容易进行单元测试。

这些类似于实例、类和静态方法。记住，当我们有一个实例时，我们也有它的类，再次问问自己，哪个更容易推理？：

def an_instance_method(self, arg, kwarg=None):
    cls = type(self)             # Also has the class of instance!
    ...

@classmethod
def a_class_method(cls, arg, kwarg=None):
    ...

@staticmethod
def a_static_method(arg, kwarg=None):
    ...

内置示例

下面是几个我最喜欢的内置示例：

str.maketrans静态方法是字符串模块中的一个函数，但从str命名空间访问它要方便得多。

>>> 'abc'.translate(str.maketrans({'a': 'b'}))
'bbc'

dict.fromkeys类方法返回一个从可迭代键实例化的新字典：

>>> dict.fromkeys('abc')
{'a': None, 'c': None, 'b': None}

当进行子类化时，我们看到它以类方法的形式获取类信息，这非常有用：

>>> class MyDict(dict): pass
>>> type(MyDict.fromkeys('abc'))
<class '__main__.MyDict'> 

我的建议-结论

当您不需要类或实例参数，但函数与对象的使用相关，并且函数位于对象的命名空间中时，可以使用静态方法。

当您不需要实例信息，但需要类信息（可能是其他类或静态方法的类信息，也可能是构造函数本身的类信息）时，请使用类方法。（您不会对类进行硬编码，以便在此处使用子类。）

我是这个网站的初学者，我已经阅读了以上所有答案，并得到了我想要的信息。然而，我没有投票权。所以我想从StackOverflow开始，得到我所理解的答案。

@staticmethod不需要self或cls作为方法的第一个参数@staticmethod和@classmethod包装函数可以由实例或类变量调用@staticmethod修饰函数会影响某种“不可变属性”，子类继承无法覆盖其基类函数，该基类函数由@staticmethoddecorator封装。@classmethod需要cls（类名，如果需要，可以更改变量名，但不建议）作为函数的第一个参数@classmethod总是以子类的方式使用，子类继承可能会改变基类函数的效果，即@classmethod包装的基类函数可能会被不同的子类覆盖。

类方法可以修改类状态，它绑定到类并且包含cls作为参数。

静态方法不能修改类状态，它绑定到类，它不知道类或实例

class empDetails:
    def __init__(self,name,sal):
        self.name=name
        self.sal=sal
    @classmethod
    def increment(cls,name,none):
        return cls('yarramsetti',6000 + 500)
    @staticmethod
    def salChecking(sal):
        return sal > 6000

emp1=empDetails('durga prasad',6000)
emp2=empDetails.increment('yarramsetti',100)
# output is 'durga prasad'
print emp1.name
# output put is 6000
print emp1.sal
# output is 6500,because it change the sal variable
print emp2.sal
# output is 'yarramsetti' it change the state of name variable
print emp2.name
# output is True, because ,it change the state of sal variable
print empDetails.salChecking(6500)

当他/她希望根据调用方法的子类来更改方法的行为时，可以使用@classmethod。请记住，我们在类方法中引用了调用类。

在使用静态时，您希望行为在子类之间保持不变

例子：

class Hero:

  @staticmethod
  def say_hello():
     print("Helllo...")

  @classmethod
  def say_class_hello(cls):
     if(cls.__name__=="HeroSon"):
        print("Hi Kido")
     elif(cls.__name__=="HeroDaughter"):
        print("Hi Princess")

class HeroSon(Hero):
  def say_son_hello(self):
     print("test  hello")



class HeroDaughter(Hero):
  def say_daughter_hello(self):
     print("test  hello daughter")


testson = HeroSon()

testson.say_class_hello() #Output: "Hi Kido"

testson.say_hello() #Outputs: "Helllo..."

testdaughter = HeroDaughter()

testdaughter.say_class_hello() #Outputs: "Hi Princess"

testdaughter.say_hello() #Outputs: "Helllo..."