@staticmethod和@classmethod之间的差异

用@staticmethod修饰的方法和用@classmethod修饰的方法有什么区别？

当前回答

我开始用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")

2017-10-10 10:10:50

其他回答

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

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

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

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

2020-03-02 16:01:43

我认为提供一个纯Python版本的staticmethod和classmethod将有助于在语言级别上理解它们之间的区别（请参阅Descriptor Howto Guide）。

这两个都是非数据描述符（如果您首先熟悉描述符，那么更容易理解它们）。

class StaticMethod(object):
    "Emulate PyStaticMethod_Type() in Objects/funcobject.c"

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

    def __get__(self, obj, objtype=None):
        return self.f


class ClassMethod(object):
    "Emulate PyClassMethod_Type() in Objects/funcobject.c"
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, cls=None):
        def inner(*args, **kwargs):
            if cls is None:
                cls = type(obj)
            return self.f(cls, *args, **kwargs)
        return inner

2019-11-20 09:50:33

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

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

2021-03-17 11:25:42

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

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

2016-09-20 09:03:29