我开始用C++学习编程语言，然后是Java，然后是Python，所以这个问题也困扰了我，直到我理解了每种语言的简单用法。

类方法：Python不像Java和C++那样没有构造函数重载。为了实现这一点，可以使用classmethod。以下示例将对此进行解释

让我们考虑一个Person类，它接受两个参数first_name和last_name，并创建Person的实例。

class Person(object):

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

现在，如果您需要仅使用一个名称（仅使用first_name）创建一个类，那么在Python中不能这样做。

当您尝试创建对象（实例）时，这将给您一个错误。

class Person(object):

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

    def __init__(self, first_name):
        self.first_name = first_name

然而，您可以使用@classmethod实现以下相同的功能

class Person(object):

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

    @classmethod
    def get_person(cls, first_name):
        return cls(first_name, "")

静态方法：这相当简单，它不绑定到实例或类，您可以使用类名简单地调用它。

所以，在上面的示例中，假设您需要验证first_name不应超过20个字符，您可以简单地这样做。

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

您可以使用类名调用

Person.validate_name("Gaurang Shah")

实例方法：

+可以修改对象实例状态

+可以修改类状态

类方法：

-无法修改对象实例状态

+可以修改类状态

静态方法：

-无法修改对象实例状态

-无法修改类状态

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，print_name方法应该写两次，因为类的名称应该写在打印行中。

class Parent:
   _class_name = "Parent"

   @staticmethod
   def print_name():
       print(Parent._class_name)


class Child(Parent):
   _class_name = "Child"

   @staticmethod
   def print_name():
       print(Child._class_name)


Parent.print_name()
Child.print_name()

但是，对于@classmethod，不需要编写print_name方法两次。

class Parent:
    _class_name = "Parent"

    @classmethod
    def print_name(cls):
        print(cls._class_name)


class Child(Parent):
    _class_name = "Child"


Parent.print_name()
Child.print_name()

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官方文档。

@classmethod：可用于创建对该类创建的所有实例的共享全局访问。。。。。比如由多个用户更新记录。。。。我特别发现它在创建单件时也很有用。：）

@静态方法：与关联的类或实例无关。。。但为了可读性，可以使用静态方法

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

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

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

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

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