@python2.4中添加了修饰符。如果您使用的是python<2.4，则可以使用classmethod（）和staticmethod（）函数。

例如，如果您想要创建一个工厂方法（一个函数，它返回一个类的不同实现的实例，具体取决于它获得的参数），您可以执行以下操作：

class Cluster(object):

    def _is_cluster_for(cls, name):
        """
        see if this class is the cluster with this name
        this is a classmethod
        """ 
        return cls.__name__ == name
    _is_cluster_for = classmethod(_is_cluster_for)

    #static method
    def getCluster(name):
        """
        static factory method, should be in Cluster class
        returns a cluster object for the given name
        """
        for cls in Cluster.__subclasses__():
            if cls._is_cluster_for(name):
                return cls()
    getCluster = staticmethod(getCluster)

还要注意，这是一个使用类方法和静态方法的好例子，静态方法显然属于类，因为它在内部使用了类Cluster。类方法只需要关于类的信息，而不需要对象的实例。

将_is_cluster_for方法设置为类方法的另一个好处是，子类可以决定更改其实现，这可能是因为它非常通用，可以处理多种类型的集群，因此仅检查类的名称是不够的。

对iPython中其他相同方法的快速破解表明，@staticmethod产生了边际性能增益（以纳秒为单位），但在其他方面它似乎没有任何作用。此外，在编译过程中通过staticmethod（）处理方法的额外工作（这在运行脚本时任何代码执行之前发生）可能会抵消任何性能提升。

为了代码的可读性，我会避免@staticmethod，除非您的方法将用于纳秒计数的工作量。

也许一些示例代码会有所帮助：注意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>

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

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-类方法不绑定到对象，而是绑定到类。

要决定是使用@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

类方法将类作为隐式第一参数接收，就像实例方法接收实例一样。它是一个绑定到类而不是类的对象的方法。它可以访问类的状态，因为它使用指向类而不是对象实例的类参数。它可以修改将应用于类的所有实例的类状态。例如，它可以修改将适用于所有实例的类变量。

另一方面，与类方法或实例方法相比，静态方法不接收隐式第一个参数。并且无法访问或修改类状态。它只属于类，因为从设计的角度来看，这是正确的方法。但就功能而言，在运行时，它并不与类绑定。

作为指导，使用静态方法作为实用程序，使用类方法作为工厂。或者可以定义一个单例。并使用实例方法对实例的状态和行为进行建模。

希望我清楚！