用@staticmethod修饰的方法和用@classmethod修饰的方法有什么区别？
当前回答
一个非常重要的实际差异发生在子类化时。如果你不介意的话，我会劫持@unsubu的例子：
class A:
def foo(self, x):
print("executing foo(%s, %s)" % (self, x))
@classmethod
def class_foo(cls, x):
print("executing class_foo(%s, %s)" % (cls, x))
@staticmethod
def static_foo(x):
print("executing static_foo(%s)" % x)
class B(A):
pass
在class_foo中，该方法知道它是在哪个类上调用的：
A.class_foo(1)
# => executing class_foo(<class '__main__.A'>, 1)
B.class_foo(1)
# => executing class_foo(<class '__main__.B'>, 1)
在static_foo中，无法确定它是在A还是B上调用的：
A.static_foo(1)
# => executing static_foo(1)
B.static_foo(1)
# => executing static_foo(1)
注意，这并不意味着您不能在静态方法中使用其他方法，您只需直接引用类，这意味着子类的静态方法仍将引用父类：
class A:
@classmethod
def class_qux(cls, x):
print(f"executing class_qux({cls}, {x})")
@classmethod
def class_bar(cls, x):
cls.class_qux(x)
@staticmethod
def static_bar(x):
A.class_qux(x)
class B(A):
pass
A.class_bar(1)
# => executing class_qux(<class '__main__.A'>, 1)
B.class_bar(1)
# => executing class_qux(<class '__main__.B'>, 1)
A.static_bar(1)
# => executing class_qux(<class '__main__.A'>, 1)
B.static_bar(1)
# => executing class_qux(<class '__main__.A'>, 1)
其他回答
首先，让我们从一个示例代码开始，我们将使用它来理解这两个概念：
class Employee:
NO_OF_EMPLOYEES = 0
def __init__(self, first_name, last_name, salary):
self.first_name = first_name
self.last_name = last_name
self.salary = salary
self.increment_employees()
def give_raise(self, amount):
self.salary += amount
@classmethod
def employee_from_full_name(cls, full_name, salary):
split_name = full_name.split(' ')
first_name = split_name[0]
last_name = split_name[1]
return cls(first_name, last_name, salary)
@classmethod
def increment_employees(cls):
cls.NO_OF_EMPLOYEES += 1
@staticmethod
def get_employee_legal_obligations_txt():
legal_obligations = """
1. An employee must complete 8 hours per working day
2. ...
"""
return legal_obligations
Class方法
类方法接受类本身作为隐式参数，以及（可选地）定义中指定的任何其他参数。重要的是要理解类方法不能访问对象实例（就像实例方法一样）。因此，类方法不能用于更改实例化对象的状态，而是能够更改该类的所有实例之间共享的类状态。当我们需要访问类本身时，类方法通常很有用——例如，当我们想要创建工厂方法时，即创建类实例的方法。换句话说，类方法可以作为替代构造函数。
在我们的示例代码中，可以通过提供三个参数来构造Employee的实例；first_name、last_name和薪水。
employee_1 = Employee('Andrew', 'Brown', 85000)
print(employee_1.first_name)
print(employee_1.salary)
'Andrew'
85000
现在，让我们假设有可能在单个字段中提供雇员的姓名，在该字段中，名字和姓氏用空格分隔。在本例中，我们可以使用名为employee_from_full_name的类方法，该方法总共接受三个参数。第一个是类本身，这是一个隐式参数，这意味着在调用方法时不会提供它-Python将自动为我们执行此操作：
employee_2 = Employee.employee_from_full_name('John Black', 95000)
print(employee_2.first_name)
print(employee_2.salary)
'John'
95000
请注意，也可以从对象实例调用employee_from_full_name，尽管在这种情况下，这没有什么意义：
employee_1 = Employee('Andrew', 'Brown', 85000)
employee_2 = employee_1.employee_from_full_name('John Black', 95000)
我们可能想要创建类方法的另一个原因是，当我们需要更改类的状态时。在我们的示例中，类变量NO_OF_EMPLOYEES跟踪当前为公司工作的员工数量。每次创建Employee的新实例时都会调用此方法，并相应地更新计数：
employee_1 = Employee('Andrew', 'Brown', 85000)
print(f'Number of employees: {Employee.NO_OF_EMPLOYEES}')
employee_2 = Employee.employee_from_full_name('John Black', 95000)
print(f'Number of employees: {Employee.NO_OF_EMPLOYEES}')
Number of employees: 1
Number of employees: 2
静态方法
另一方面，在静态方法中，实例（即self）和类本身（即cls）都不会作为隐式参数传递。这意味着此类方法不能访问类本身或其实例。现在有人可能会争辩说，静态方法在类的上下文中并不有用，因为它们也可以放在助手模块中，而不是作为类的成员添加它们。在面向对象的编程中，将类构造成逻辑块非常重要，因此，当我们需要在类下添加方法时，静态方法非常有用，因为它在逻辑上属于该类。在我们的示例中，名为get_eemployee_legal_entributions_txt的静态方法只返回一个字符串，该字符串包含公司每个员工的法律义务。此函数不与类本身或任何实例交互。它可能被放置在不同的帮助器模块中，但是，它只与这个类相关，因此我们必须将它放置在Employee类下。
可以直接从类本身访问静态方法
print(Employee.get_employee_legal_obligations_txt())
1. An employee must complete 8 hours per working day
2. ...
或从类的实例：
employee_1 = Employee('Andrew', 'Brown', 85000)
print(employee_1.get_employee_legal_obligations_txt())
1. An employee must complete 8 hours per working day
2. ...
工具书类
Python中静态方法和类方法的区别是什么？
关于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类方法的事情，但一旦发布，我发现真正需要的是类方法。但要摆脱静态方法为时已晚。
实例方法：
+可以修改对象实例状态
+可以修改类状态
类方法：
-无法修改对象实例状态
+可以修改类状态
静态方法：
-无法修改对象实例状态
-无法修改类状态
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只是禁用默认函数作为方法描述符。classmethod将函数包装在可调用的容器中，该容器将引用作为第一个参数传递给所属类：
>>> class C(object):
... pass
...
>>> def f():
... pass
...
>>> staticmethod(f).__get__(None, C)
<function f at 0x5c1cf0>
>>> classmethod(f).__get__(None, C)
<bound method type.f of <class '__main__.C'>>
事实上，classmethod有运行时开销，但可以访问所属的类。或者，我建议使用元类并将类方法放在元类上：
>>> class CMeta(type):
... def foo(cls):
... print cls
...
>>> class C(object):
... __metaclass__ = CMeta
...
>>> C.foo()
<class '__main__.C'>
顾名思义，类方法用于更改类而不是对象。要对类进行更改，它们将修改类属性（而不是对象属性），因为这就是更新类的方式。这就是类方法将类（通常用“cls”表示）作为第一个参数的原因。
class A(object):
m=54
@classmethod
def class_method(cls):
print "m is %d" % cls.m
另一方面，静态方法用于执行未绑定到类的功能，即它们不会读取或写入类变量。因此，静态方法不将类作为参数。使用它们是为了使类可以执行与类的目的不直接相关的功能。
class X(object):
m=54 #will not be referenced
@staticmethod
def static_method():
print "Referencing/calling a variable or function outside this class. E.g. Some global variable/function."
推荐文章
- Numpy Max vs amax vs maximum
- 我应该在.gitignore文件中添加Django迁移文件吗?
- 每n行有熊猫
- 实例属性attribute_name定义在__init__之外
- 如何获取在Python中捕获的异常的名称?
- 第一次出现的值大于现有值的Numpy
- 如何从Python函数中返回两个值?
- 前一个月的Python日期
- Python中方括号括起来的列表和圆括号括起来的列表有什么区别?
- Python日志记录不输出任何东西
- 接口方法的最终参数-有什么意义?
- 每n秒运行特定代码
- SQLAlchemy是否有与Django的get_or_create等价的函数?
- 如何将python datetime转换为字符串，具有可读格式的日期?
- 美丽的汤和提取div及其内容的ID
