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

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

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

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

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

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

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

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

我将用一个例子来解释基本的区别。

class A(object):
    x = 0

    def say_hi(self):
        pass

    @staticmethod
    def say_hi_static():
        pass

    @classmethod
    def say_hi_class(cls):
        pass

    def run_self(self):
        self.x += 1
        print self.x # outputs 1
        self.say_hi()
        self.say_hi_static()
        self.say_hi_class()

    @staticmethod
    def run_static():
        print A.x  # outputs 0
        # A.say_hi() #  wrong
        A.say_hi_static()
        A.say_hi_class()

    @classmethod
    def run_class(cls):
        print cls.x # outputs 0
        # cls.say_hi() #  wrong
        cls.say_hi_static()
        cls.say_hi_class()

1-我们可以直接调用静态和类方法，而无需初始化

# A.run_self() #  wrong
A.run_static()
A.run_class()

2-静态方法不能调用self方法，但可以调用其他静态和类方法

3-静态方法属于类，根本不会使用对象。

4-类方法不绑定到对象，而是绑定到类。

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

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

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

要决定是使用@staticmethod还是@classmethod，必须查看方法内部。如果您的方法访问类中的其他变量/方法，请使用@classmethod。另一方面，如果您的方法不涉及类的任何其他部分，则使用@staticmethod。

class Apple:

    _counter = 0

    @staticmethod
    def about_apple():
        print('Apple is good for you.')

        # note you can still access other member of the class
        # but you have to use the class instance 
        # which is not very nice, because you have repeat yourself
        # 
        # For example:
        # @staticmethod
        #    print('Number of apples have been juiced: %s' % Apple._counter)
        #
        # @classmethod
        #    print('Number of apples have been juiced: %s' % cls._counter)
        #
        #    @classmethod is especially useful when you move your function to another class,
        #       you don't have to rename the referenced class 

    @classmethod
    def make_apple_juice(cls, number_of_apples):
        print('Making juice:')
        for i in range(number_of_apples):
            cls._juice_this(i)

    @classmethod
    def _juice_this(cls, apple):
        print('Juicing apple %d...' % apple)
        cls._counter += 1