Python带有几个内置的装饰器。三大类是：

@classmethod
@staticmethod
@property

首先，让我们注意，类的任何函数都可以用这个类的实例调用（在初始化这个类之后）。

@classmethod是一种方法，它不仅可以作为类的实例调用函数，还可以直接由类本身作为其第一个参数调用函数。

@staticmethod是一种将函数放入类的方法（因为它在逻辑上属于类），同时表示它不需要访问类（因此我们不需要在函数定义中使用self）。

让我们考虑一下以下课程：

class DecoratorTest(object):

    def __init__(self):
        pass

    def doubler(self, x):
        return x*2

    @classmethod
    def class_doubler(cls, x): # we need to use 'cls' instead of 'self'; 'cls' reference to the class instead of an instance of the class
        return x*2

    @staticmethod
    def static_doubler(x): # no need adding 'self' here; static_doubler() could be just a function not inside the class
        return x*2

让我们看看它是如何工作的：

decor = DecoratorTest()

print(decor.doubler(5))
# 10

print(decor.class_doubler(5)) # a call with an instance of a class
# 10
print(DecoratorTest.class_doubler(5)) # a direct call by the class itself
# 10

# staticmethod could be called in the same way as classmethod.
print(decor.static_doubler(5)) # as an instance of the class
# 10
print(DecoratorTest.static_doubler(5)) # or as a direct call 
# 10

这里您可以看到这些方法的一些用例。

奖金：您可以在这里阅读@property decorator

@类方法：

可以通过cls和直接通过类名调用类变量和实例、类和静态方法，但不能通过实例变量。可以通过对象和类名直接调用。第一个参数需要cls，否则无法调用@classmethod，并且按照惯例使用cls的名称，因此其他名称而不是cls仍然有效。

@静态方法：

既可以由对象调用，也可以直接由类名调用。可以通过类名而不是实例变量直接调用类变量和实例、类和静态方法。不需要self或cls。

*在回答Python中什么是“实例方法”时，我还详细解释了实例方法？

@类方法：

例如，@classmethod可以通过cls和直接通过类名调用类变量和实例、类和静态方法，@classmethod可以通过对象和直接通过类名称调用，如下所示：

class Person:
    x = "Hello"
    def __init__(self, name):
        self.name = name
    
    @classmethod # Here
    def test1(cls):
        print(cls.x)   # Class variable by `cls`
        cls.test2(cls) # Instance method by `cls`
        cls.test3()    # Class method by `cls`
        cls.test4()    # Static method by `cls`
        print()
        print(Person.x)       # Class variable by class name
        Person.test2("Test2") # Instance method by class name
        Person.test3()        # Class method by class name
        Person.test4()        # Static method by class name
    
    def test2(self):
        print("Test2")
        
    @classmethod
    def test3(cls):
        print("Test3")
        
    @staticmethod
    def test4():
        print("Test4")

obj = Person("John")
obj.test1() # By object

# Or

Person.test1() # By class name

输出：

Hello
Test2
Test3
Test4

Hello
Test2
Test3
Test4

而且，@classmethod不能同时通过cls和直接通过类名调用实例变量，因此如果@classmethod试图同时通过cls和直接通过类名称调用实例变量（如下所示）：

# ...
    
    @classmethod
    def test1(cls):
        print(cls.name) # Instance variable by `cls`
        
        # Or

        print(Person.name) # Instance variable by class name
# ...

obj = Person("John")
obj.test1()

# Or

Person.test1()

出现以下错误：

AttributeError:类型对象“Person”没有属性“name”

如果@classmethod没有cls：

# ...
    
    @classmethod
    def test1(): # Without "cls"
        print("Test1")
  
# ...

obj = Person("John")
obj.test1()

# Or

Person.test1()

@无法调用classmethod，则出现如下错误：

TypeError:test1（）采用0个位置参数，但给出了1个

而且，cls的名称在约定中使用，因此其他名称而不是cls仍然有效，如下所示：

# ...

    @classmethod
    def test1(orange):
        print(orange.x)      # Class variable
        orange.test2(orange) # Instance method
        orange.test3()       # Class method
        orange.test4()       # Static method

# ...

obj = Person("John")
obj.test1()

# Or

Person.test1()

输出：

Hello
Test2
Test3
Test4

@静态方法：

例如，@staticmethod既可以按对象调用，也可以按类名直接调用，如下所示：

class Person:
    x = "Hello"
    def __init__(self, name):
        self.name = name

    @staticmethod # Here
    def test1():
        print("Test1")
    
    def test2(self):
        print("Test2")
        
    @classmethod
    def test3(cls):
        print("Test3")
        
    @staticmethod
    def test4():
        print("Test4")

obj = Person("John")
obj.test1() # By object

# Or

Person.test1() # By class name

输出：

Test1

而且，@staticmethod可以通过类名直接调用类变量和实例、类和静态方法，而不是实例变量，如下所示：

# ...
    
    @staticmethod
    def test1():
        print(Person.x)       # Class variable
        Person.test2("Test2") # Instance method
        Person.test3()        # Class method
        Person.test4()        # Static method
            
# ...

obj = Person("John")
obj.test1()

# Or

Person.test1()

输出：

Hello
Test2
Test3
Test4

并且，如果@staticmethod尝试调用实例变量，如下所示：

# ...
    
    @staticmethod
    def test1():
        print(Person.name) # Instance variable
            
# ...

obj = Person("John")
obj.test1()

# Or

Person.test1()

出现以下错误：

AttributeError:类型对象“Person”没有属性“name”

而且，@staticmethod不需要self或cls，因此如果@staticmmethod具有self或cl，则需要传递如下所示的参数：

# ...
    
    @staticmethod
    def test1(self): # With "self"
        print(self)

    # Or

    @staticmethod
    def test1(cls): # With "cls"
        print(cls)

# ...

obj = Person("John")
obj.test1("Test1") # With an argument

# Or

Person.test1("Test1") # With an argument

输出：

Test1

否则，如果不传递如下所示的参数：

# ...
    
    @staticmethod
    def test1(self): # With "self"
        print("Test1")

    # Or

    @staticmethod
    def test1(cls): # With "cls"
        print("Test1")

# ...

obj = Person("John")
obj.test1() # Without an argument

# Or

Person.test1() # Without an argument

出现以下错误：

TypeError:test1（）缺少1个必需的位置参数：“self”

TypeError:test1（）缺少1个必需的位置参数：“cls”

这是一篇关于这个问题的短文

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

我的贡献展示了@classmethod、@staticmethod和实例方法之间的区别，包括实例如何间接调用@staticmmethod。但是，与其从实例间接调用@staticmethod，不如将其私有化可能更“Python化”。这里没有演示从私有方法获取内容，但基本上是相同的概念。

#!python3

from os import system
system('cls')
# %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %

class DemoClass(object):
    # instance methods need a class instance and
    # can access the instance through 'self'
    def instance_method_1(self):
        return 'called from inside the instance_method_1()'

    def instance_method_2(self):
        # an instance outside the class indirectly calls the static_method
        return self.static_method() + ' via instance_method_2()'

    # class methods don't need a class instance, they can't access the
    # instance (self) but they have access to the class itself via 'cls'
    @classmethod
    def class_method(cls):
        return 'called from inside the class_method()'

    # static methods don't have access to 'cls' or 'self', they work like
    # regular functions but belong to the class' namespace
    @staticmethod
    def static_method():
        return 'called from inside the static_method()'
# %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %

# works even if the class hasn't been instantiated
print(DemoClass.class_method() + '\n')
''' called from inside the class_method() '''

# works even if the class hasn't been instantiated
print(DemoClass.static_method() + '\n')
''' called from inside the static_method() '''
# %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %

# >>>>> all methods types can be called on a class instance <<<<<
# instantiate the class
democlassObj = DemoClass()

# call instance_method_1()
print(democlassObj.instance_method_1() + '\n')
''' called from inside the instance_method_1() '''

# # indirectly call static_method through instance_method_2(), there's really no use
# for this since a @staticmethod can be called whether the class has been
# instantiated or not
print(democlassObj.instance_method_2() + '\n')
''' called from inside the static_method() via instance_method_2() '''

# call class_method()
print(democlassObj.class_method() + '\n')
'''  called from inside the class_method() '''

# call static_method()
print(democlassObj.static_method())
''' called from inside the static_method() '''

"""
# whether the class is instantiated or not, this doesn't work
print(DemoClass.instance_method_1() + '\n')
'''
TypeError: TypeError: unbound method instancemethod() must be called with
DemoClass instance as first argument (got nothing instead)
'''
"""

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

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

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

@staticmethod只是禁用默认函数作为方法描述符。classmethod将函数包装在可调用的容器中，该容器将引用作为第一个参数传递给所属类：

>>> class C(object):
...  pass
... 
>>> def f():
...  pass
... 
>>> staticmethod(f).__get__(None, C)
<function f at 0x5c1cf0>
>>> classmethod(f).__get__(None, C)
<bound method type.f of <class '__main__.C'>>

事实上，classmethod有运行时开销，但可以访问所属的类。或者，我建议使用元类并将类方法放在元类上：

>>> class CMeta(type):
...  def foo(cls):
...   print cls
... 
>>> class C(object):
...  __metaclass__ = CMeta
... 
>>> C.foo()
<class '__main__.C'>