@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'>

实例方法：

+可以修改对象实例状态

+可以修改类状态

类方法：

-无法修改对象实例状态

+可以修改类状态

静态方法：

-无法修改对象实例状态

-无法修改类状态

class MyClass:
    ''' 
    Instance method has a mandatory first attribute self which represent the instance itself. 
    Instance method must be called by a instantiated instance.
    '''
    def method(self):
        return 'instance method called', self
    
    '''
    Class method has a mandatory first attribute cls which represent the class itself. 
    Class method can be called by an instance or by the class directly. 
    Its most common using scenario is to define a factory method.
    '''
    @classmethod
    def class_method(cls):
        return 'class method called', cls
    
    '''
    Static method doesn’t have any attributes of instances or the class. 
    It also can be called by an instance or by the class directly. 
    Its most common using scenario is to define some helper or utility functions which are closely relative to the class.
    '''
    @staticmethod
    def static_method():
        return 'static method called'


obj = MyClass()
print(obj.method())
print(obj.class_method()) # MyClass.class_method()
print(obj.static_method()) # MyClass.static_method()

输出：

('instance method called', <__main__.MyClass object at 0x100fb3940>)
('class method called', <class '__main__.MyClass'>)
static method called

实例方法实际上可以访问对象实例，所以这是我的类对象的一个实例，而使用类方法，我们可以访问类本身。但不适用于任何对象，因为类方法并不真正关心现有的对象。但是，您可以同时调用对象实例上的类方法和静态方法。这将起作用，但实际上并没有什么不同，所以当你在这里调用静态方法时，它会起作用，它会知道你要调用哪个方法。

静态方法用于执行一些实用程序任务，类方法用于工厂方法。工厂方法可以为不同的用例返回类对象。

最后，举一个简短的例子来更好地理解：

class Student:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

    @classmethod
    def get_from_string(cls, name_string: str):
        first_name, last_name = name_string.split()
        if Student.validate_name(first_name) and Student.validate_name(last_name):
            return cls(first_name, last_name)
        else:
            print('Invalid Names')

    @staticmethod
    def validate_name(name):
        return len(name) <= 10


stackoverflow_student = Student.get_from_string('Name Surname')
print(stackoverflow_student.first_name) # Name
print(stackoverflow_student.last_name) # Surname

关于staticmethod vs classmethod的另一个考虑是继承。假设你有以下课程：

class Foo(object):
    @staticmethod
    def bar():
        return "In Foo"

然后您需要在子类中重写bar（）：

class Foo2(Foo):
    @staticmethod
    def bar():
        return "In Foo2"

这是可行的，但请注意，现在子类（Foo2）中的bar（）实现不能再利用该类特有的任何特性。例如，假设Foo2有一个名为magic（）的方法，您希望在Foo2实现bar（）时使用该方法：

class Foo2(Foo):
    @staticmethod
    def bar():
        return "In Foo2"
    @staticmethod
    def magic():
        return "Something useful you'd like to use in bar, but now can't" 

这里的解决方法是在bar（）中调用Foo2.magic（），但随后您重复自己的操作（如果Foo2的名称发生更改，您必须记住更新bar（）方法）。

对我来说，这稍微违反了开放/封闭原则，因为在Foo中做出的决定会影响您重构派生类中的公共代码的能力（即扩展的开放性较低）。如果bar（）是一个类方法，我们就可以了：

class Foo(object):
    @classmethod
    def bar(cls):
        return "In Foo"

class Foo2(Foo):
    @classmethod
    def bar(cls):
        return "In Foo2 " + cls.magic()
    @classmethod
    def magic(cls):
        return "MAGIC"

print Foo2().bar()

给出：In Foo2 MAGIC

此外：历史笔记：Guido Van Rossum（Python的创建者）曾将静态方法称为“意外”：https://mail.python.org/pipermail/python-ideas/2012-May/014969.html

我们都知道静态方法有多有限。（它们基本上是一个意外——回到Python 2.2时代，当我发明新型类和描述符时，我想实现类方法，但一开始我不理解它们，意外地先实现了静态方法。然后，删除它们，只提供类方法已经太晚了。

也：https://mail.python.org/pipermail/python-ideas/2016-July/041189.html

老实说，staticmethod是一个错误——我试图做一些类似Java类方法的事情，但一旦发布，我发现真正需要的是类方法。但要摆脱静态方法为时已晚。

Python中@staticmethod和@classmethod之间有什么区别？

您可能已经看到了类似于此伪代码的Python代码，它演示了各种方法类型的签名，并提供了一个文档字符串来解释每种类型：

class Foo(object):

    def a_normal_instance_method(self, arg_1, kwarg_2=None):
        '''
        Return a value that is a function of the instance with its
        attributes, and other arguments such as arg_1 and kwarg2
        '''

    @staticmethod
    def a_static_method(arg_0):
        '''
        Return a value that is a function of arg_0. It does not know the 
        instance or class it is called from.
        '''

    @classmethod
    def a_class_method(cls, arg1):
        '''
        Return a value that is a function of the class and other arguments.
        respects subclassing, it is called with the class it is called from.
        '''

普通实例方法

首先，我将解释a_nonormal_instance_method。这就是所谓的“实例方法”。当使用实例方法时，它被用作部分函数（与在源代码中查看时为所有值定义的总函数相反），也就是说，当使用时，第一个参数被预定义为对象的实例及其所有给定属性。它绑定了对象的实例，并且必须从对象的实例调用它。通常，它将访问实例的各种属性。

例如，这是一个字符串的实例：

', '

如果我们使用实例方法join来连接另一个可迭代的字符串，很明显，它是实例的函数，除了是可迭代列表['a'，'b'，'c']的函数之外：

>>> ', '.join(['a', 'b', 'c'])
'a, b, c'

绑定的方法

实例方法可以通过点查找绑定，以便稍后使用。

例如，这将str.join方法绑定到“：”实例：

>>> join_with_colons = ':'.join 

稍后，我们可以将其用作已经绑定了第一个参数的函数。这样，它就像实例上的分部函数一样工作：

>>> join_with_colons('abcde')
'a:b:c:d:e'
>>> join_with_colons(['FF', 'FF', 'FF', 'FF', 'FF', 'FF'])
'FF:FF:FF:FF:FF:FF'

静态方法

静态方法不将实例作为参数。

它非常类似于模块级函数。

但是，模块级函数必须存在于模块中，并且必须专门导入到使用它的其他地方。

然而，如果它附加到对象，它将通过导入和继承方便地跟随对象。

静态方法的一个示例是str.maketrans，它是从Python 3中的字符串模块移动来的。它使转换表适合str.translate使用。从字符串的实例中使用它似乎很愚蠢，如下所示，但从字符串模块导入函数相当笨拙，能够从类中调用它很好，如str.maketrans中所示

# demonstrate same function whether called from instance or not:
>>> ', '.maketrans('ABC', 'abc')
{65: 97, 66: 98, 67: 99}
>>> str.maketrans('ABC', 'abc')
{65: 97, 66: 98, 67: 99}

在python 2中，您必须从越来越无用的字符串模块导入此函数：

>>> import string
>>> 'ABCDEFG'.translate(string.maketrans('ABC', 'abc'))
'abcDEFG'

Class方法

类方法与实例方法相似，因为它接受隐式的第一个参数，但不是接受实例，而是接受类。为了更好地使用语义，它们通常被用作替代构造函数，它将支持继承。

内置类方法最典型的例子是dict.fromkeys。它被用作dict的另一个构造函数（非常适合当你知道你的键是什么并且想要它们的默认值时）

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

当我们对dict进行子类化时，我们可以使用相同的构造函数来创建子类的实例。

>>> class MyDict(dict): 'A dict subclass, use to demo classmethods'
>>> md = MyDict.fromkeys(['a', 'b', 'c'])
>>> md
{'a': None, 'c': None, 'b': None}
>>> type(md)
<class '__main__.MyDict'>

请参阅panda源代码以了解其他类似的替代构造函数示例，也可以参阅关于classmethod和staticmethod的Python官方文档。

关于如何在Python中使用静态、类或抽象方法的权威指南是本主题的一个很好的链接，总结如下。

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

Python不必为对象实例化绑定方法。它简化了代码的可读性，并且不依赖于对象本身的状态；

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

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

让我先告诉一下用@classmethod修饰的方法和@staticmethod修饰的方法之间的相似性。

相似性：它们都可以在类本身上调用，而不仅仅是类的实例。所以，在某种意义上，这两种方法都是Class的方法。

区别：类方法将接收类本身作为第一个参数，而静态方法不接收。

因此，在某种意义上，静态方法并不绑定到类本身，只是因为它可能具有相关功能而挂在那里。

>>> class Klaus:
        @classmethod
        def classmthd(*args):
            return args

        @staticmethod
        def staticmthd(*args):
            return args

# 1. Call classmethod without any arg
>>> Klaus.classmthd()  
(__main__.Klaus,)  # the class gets passed as the first argument

# 2. Call classmethod with 1 arg
>>> Klaus.classmthd('chumma')
(__main__.Klaus, 'chumma')

# 3. Call staticmethod without any arg
>>> Klaus.staticmthd()  
()

# 4. Call staticmethod with 1 arg
>>> Klaus.staticmthd('chumma')
('chumma',)