静态方法：

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

静态方法的优点：

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

类方法：

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

@类方法：

可以通过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”

实例方法：

+可以修改对象实例状态

+可以修改类状态

类方法：

-无法修改对象实例状态

+可以修改类状态

静态方法：

-无法修改对象实例状态

-无法修改类状态

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

让我先告诉一下用@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',)

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

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

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

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

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

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

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

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