staticmethod无法访问继承层次结构中对象、类或父类的属性。它可以直接在类中调用（无需创建对象）。

classmethod无法访问对象的属性。但是，它可以访问继承层次结构中的类和父类的属性。它可以直接在类中调用（无需创建对象）。如果在对象处调用，则它与不访问self的普通方法相同<属性>并访问self__第__类<属性>。

假设我们有一个b=2的类，我们将创建一个对象，并将其重新设置为b=4。Staticmethod无法访问以前的任何内容。Classmethod只能通过cls.b访问.b==2。正常方法可以通过self访问：.b==4和.b==2__第__.b类。

我们可以遵循KISS风格（保持简单，愚蠢）：不要使用静态方法和类方法，不要在没有实例化它们的情况下使用类，只访问对象的属性self.attribute。有些语言是这样实现OOP的，我认为这不是坏主意

顾名思义，类方法用于更改类而不是对象。要对类进行更改，它们将修改类属性（而不是对象属性），因为这就是更新类的方式。这就是类方法将类（通常用“cls”表示）作为第一个参数的原因。

class A(object):
    m=54

    @classmethod
    def class_method(cls):
        print "m is %d" % cls.m

另一方面，静态方法用于执行未绑定到类的功能，即它们不会读取或写入类变量。因此，静态方法不将类作为参数。使用它们是为了使类可以执行与类的目的不直接相关的功能。

class X(object):
    m=54 #will not be referenced

    @staticmethod
    def static_method():
        print "Referencing/calling a variable or function outside this class. E.g. Some global variable/function."

静态方法是一种对所调用的类或实例一无所知的方法。它只获取传递的参数，而不是隐式的第一个参数。它在Python中基本上是无用的——您可以只使用模块函数而不是静态方法。

另一方面，类方法是一种方法，它将被调用的类或被调用的实例的类作为第一个参数传递。当您希望该方法成为类的工厂时，这很有用：因为它获得了作为第一个参数调用的实际类，所以即使涉及子类，您也可以始终实例化正确的类。例如，观察类方法dict.fromkeys（）在子类上调用时如何返回子类的实例：

>>> class DictSubclass(dict):
...     def __repr__(self):
...         return "DictSubclass"
... 
>>> dict.fromkeys("abc")
{'a': None, 'c': None, 'b': None}
>>> DictSubclass.fromkeys("abc")
DictSubclass
>>> 

实例方法：

+可以修改对象实例状态

+可以修改类状态

类方法：

-无法修改对象实例状态

+可以修改类状态

静态方法：

-无法修改对象实例状态

-无法修改类状态

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

也许一些示例代码会有所帮助：注意foo、class_foo和static_foo的调用签名的不同：

class A(object):
    def foo(self, x):
        print(f"executing foo({self}, {x})")

    @classmethod
    def class_foo(cls, x):
        print(f"executing class_foo({cls}, {x})")

    @staticmethod
    def static_foo(x):
        print(f"executing static_foo({x})")

a = A()

下面是对象实例调用方法的常用方法。对象实例a作为第一个参数隐式传递。

a.foo(1)
# executing foo(<__main__.A object at 0xb7dbef0c>, 1)

使用classmethods，对象实例的类作为第一个参数而不是self隐式传递。

a.class_foo(1)
# executing class_foo(<class '__main__.A'>, 1)

也可以使用类调用class_foo。事实上，如果你定义了类方法，这可能是因为您打算从类而不是从类实例调用它。A.foo（1）会引发TypeError，但A.class_foo（1）工作正常：

A.class_foo(1)
# executing class_foo(<class '__main__.A'>, 1)

人们发现类方法的一个用途是创建可继承的替代构造函数。

使用staticmethods，self（对象实例）和cls（类）都不会作为第一个参数隐式传递。它们的行为类似于普通函数，只是您可以从实例或类调用它们：

a.static_foo(1)
# executing static_foo(1)

A.static_foo('hi')
# executing static_foo(hi)

静态方法用于将与类有某种逻辑联系的函数分组到该类。

foo只是一个函数，但当你调用.foo时，你不只是得到函数，您将得到函数的“部分应用”版本，其中对象实例a作为函数的第一个参数。foo需要2个参数，而a.foo只需要1个参数。

a绑定到foo。这就是以下术语“约束”的含义：

print(a.foo)
# <bound method A.foo of <__main__.A object at 0xb7d52f0c>>

对于.class_foo，a不绑定到class_foo，而类a绑定到class-foo。

print(a.class_foo)
# <bound method type.class_foo of <class '__main__.A'>>

这里，对于staticmethod，即使它是一个方法，a.static_foo也只返回一个没有参数约束的好的ole函数。static_foo需要1个参数，并且.static_foo也需要1个参数。

print(a.static_foo)
# <function static_foo at 0xb7d479cc>

当然，当用类A调用static_foo时也会发生同样的情况。

print(A.static_foo)
# <function static_foo at 0xb7d479cc>

静态方法：

没有自参数的简单函数。处理类属性；而不是实例属性。可以通过类和实例调用。内置函数staticmethod（）用于创建它们。

静态方法的优点：

它在类作用域中本地化函数名它将功能代码移动到使用位置附近与模块级函数相比，导入更方便，因为不必专门导入每个方法@静态方法定义some_static_method（*args，**kwds）：通过

类方法：

将第一个参数作为类名的函数。可以通过类和实例调用。这些是用内置函数中的classmethod创建的。@分类法定义some_class_method（cls，*args，**kwds）：通过