只有第一个参数不同：

normal方法：当前对象作为（附加）第一个参数自动传递classmethod：当前对象的类自动作为（附加的）第一个参数传递staticmethod：不会自动传递额外的参数。传递给函数的就是得到的。

更详细地说。。。

正常方法

“标准”方法，如在所有面向对象的语言中。当调用对象的方法时，会自动为其提供一个额外的参数self作为其第一个参数。即，方法

def f(self, x, y)

必须使用2个参数调用。self是自动传递的，它是对象本身。类似于这个神奇地出现在例如java/c++中，只有在python中才显式显示。

实际上，第一个参数不必称为self，但它是标准的约定，所以请保留它

类方法

装饰方法时

@classmethod
def f(cls, x, y)

自动提供的参数不是self，而是self的类。

静态法

装饰方法时

@staticmethod
def f(x, y)

该方法根本没有给出任何自动参数。它只提供调用它的参数。

用法

classmethod主要用于替代构造函数。staticmethod不使用对象的状态，甚至不使用类本身的结构。它可以是类外部的函数。它只放在类中，用于对具有类似功能的函数进行分组（例如，像Java的Math类静态方法）

class Point
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    def frompolar(cls, radius, angle):
        """The `cls` argument is the `Point` class itself"""
        return cls(radius * cos(angle), radius * sin(angle))

    @staticmethod
    def angle(x, y):
        """this could be outside the class, but we put it here 
just because we think it is logically related to the class."""
        return atan(y, x)


p1 = Point(3, 2)
p2 = Point.frompolar(3, pi/4)

angle = Point.angle(3, 2)

关于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类方法的事情，但一旦发布，我发现真正需要的是类方法。但要摆脱静态方法为时已晚。

太长，读不下去了

静态方法本质上是绑定到类（及其实例）的函数

类方法本质上是一种可继承的静态方法。

有关详细信息，请参阅其他人的优秀答案。

当存在继承时，就会出现差异。

假设有两个类——父类和子类。如果要使用@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()

基本上，@classmethod生成的方法的第一个参数是从中调用的类（而不是类实例），@staticmethod没有任何隐式参数。

只有第一个参数不同：

normal方法：当前对象作为（附加）第一个参数自动传递classmethod：当前对象的类自动作为（附加的）第一个参数传递staticmethod：不会自动传递额外的参数。传递给函数的就是得到的。

更详细地说。。。

正常方法

“标准”方法，如在所有面向对象的语言中。当调用对象的方法时，会自动为其提供一个额外的参数self作为其第一个参数。即，方法

def f(self, x, y)

必须使用2个参数调用。self是自动传递的，它是对象本身。类似于这个神奇地出现在例如java/c++中，只有在python中才显式显示。

实际上，第一个参数不必称为self，但它是标准的约定，所以请保留它

类方法

装饰方法时

@classmethod
def f(cls, x, y)

自动提供的参数不是self，而是self的类。

静态法

装饰方法时

@staticmethod
def f(x, y)

该方法根本没有给出任何自动参数。它只提供调用它的参数。

用法

classmethod主要用于替代构造函数。staticmethod不使用对象的状态，甚至不使用类本身的结构。它可以是类外部的函数。它只放在类中，用于对具有类似功能的函数进行分组（例如，像Java的Math类静态方法）

class Point
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    def frompolar(cls, radius, angle):
        """The `cls` argument is the `Point` class itself"""
        return cls(radius * cos(angle), radius * sin(angle))

    @staticmethod
    def angle(x, y):
        """this could be outside the class, but we put it here 
just because we think it is logically related to the class."""
        return atan(y, x)


p1 = Point(3, 2)
p2 = Point.frompolar(3, pi/4)

angle = Point.angle(3, 2)