类方法通过@classmethod定义，接收cls参数，可访问类属性和创建实例，常用于替代构造器；静态方法用@staticmethod定义，无特殊参数，仅为逻辑分组的普通函数。
Python的类方法和静态方法，初看起来可能有点让人迷惑，它们都定义在类里面，但作用和调用方式却大相径庭。简单来说，类方法是与类本身绑定，而非类的某个特定实例；它能访问和修改类级别的属性，通常用于创建替代构造器或管理类状态。静态方法则更像是一个“寄居”在类命名空间下的普通函数，它既不关心实例，也不关心类，纯粹是为了代码组织上的便利。理解它们，关键在于把握它们各自的“绑定”对象和设计意图。
解决方案
在Python中，我们通过装饰器
@classmethod和
@staticmethod来定义类方法和静态方法。
类方法（Class Method）
类方法接收的第一个参数是
cls（这是一个惯例，代表类本身），而不是
self（代表实例）。这意味着它可以通过
cls访问和修改类的属性，或者调用类的其他方法。
立即学习“Python免费学习笔记（深入）”；
class MyClass:
class_attribute = "我是类属性"
def __init__(self, value):
self.instance_attribute = value
@classmethod
def class_method_example(cls, new_value):
print(f"这是一个类方法，接收的类是: {cls}")
print(f"当前类属性: {cls.class_attribute}")
cls.class_attribute = new_value # 修改类属性
print(f"修改后的类属性: {cls.class_attribute}")
return cls(f"通过类方法创建的实例，值是: {new_value}") # 返回一个新实例
# 调用方式
# 可以通过类直接调用
MyClass.class_method_example("新值A")
# 也可以通过实例调用，但实际上还是作用于类
instance_a = MyClass("原始值")
instance_a.class_method_example("新值B")
print(MyClass.class_attribute) # 验证类属性已被修改
instance_b = MyClass.class_method_example("再次修改")
print(instance_b.instance_attribute)静态方法（Static Method）
静态方法不接收任何特殊的第一个参数（既不是
self也不是
cls）。它本质上就是一个定义在类内部的普通函数，与类的实例或类本身的状态没有任何关联。它被放在类中，通常只是为了逻辑上的归属感，或者避免污染全局命名空间。
class MyUtility:
@staticmethod
def add(x, y):
print("这是一个静态方法")
return x + y
@staticmethod
def is_positive(number):
return number > 0
# 调用方式
# 可以通过类直接调用
result = MyUtility.add(5, 3)
print(f"5 + 3 = {result}")
# 也可以通过实例调用（但不推荐，因为它不依赖实例）
util_instance = MyUtility()
print(f"Is 10 positive? {util_instance.is_positive(10)}")类方法与实例方法的根本区别是什么？
谈到类方法，我们很难不把它和实例方法拿出来对比，毕竟它们都是类中定义的方法。核心区别在于它们被“绑定”到的对象不同，以及它们处理的数据范围。实例方法，就像我们平时最常用的那样，它的第一个参数是
self，指向的是类的具体实例。这意味着实例方法能够访问和修改该实例的属性，它是围绕着“这个特定的对象”来操作的。比如，你有一个
Person类，
person.walk()方法就是针对
Person这个具体的人来执行走路动作，它可能会改变
Person的位置属性。
而类方法，它的第一个参数是
cls，指向的是类本身。它操作的是类级别的属性，比如
Person类的
population属性，或者用来创建
Person类的不同实例（例如，
Person.from_birth_year(1990)这种工厂方法）。它不关心某个具体的
Person实例的状态，而是关心整个
Person类的数据或行为。如果一个方法需要修改或访问类属性，或者需要创建类的不同实例，那么类方法往往是更自然的选择。
我什么时候应该优先选择静态方法而非普通函数？
这是一个很有意思的问题，因为静态方法从功能上看，确实和一个定义在类外部的普通函数没什么两样。它们都不需要访问实例或类的状态。那么，为什么还要把它放在类里面呢？
在我看来，主要出于组织和命名空间管理的考量。想象一下，你有一个
MathOperations类，里面有一些辅助函数，比如
add、
subtract、
is_prime等。这些函数并不依赖于
MathOperations类的任何特定实例，也不需要访问
MathOperations类的任何类属性。如果把它们定义成普通的全局函数，可能会导致全局命名空间变得混乱，或者让人感觉它们和
MathOperations类之间缺乏明确的关联。
通过将这些辅助函数定义为静态方法，我们实际上是说：“看，这些功能虽然不直接操作类或实例数据，但它们在逻辑上属于这个类所代表的领域。”它提供了一种清晰的代码封装方式，让相关的功能聚合在一起。当你看到
MathOperations.add(2, 3)时，你立刻就能明白
add是
MathOperations提供的一个功能，即使它内部没有任何与
MathOperations实例或类状态相关的操作。这种做法提升了代码的可读性和可维护性，特别是在大型项目中，能够有效避免命名冲突。
在实际项目中，类方法有哪些常见的应用场景？
类方法在实际项目中有着非常实用的价值，它们不仅仅是语法上的一个点缀，更是解决特定设计问题的利器。我个人觉得，最常见且最有说服力的场景是工厂方法（Factory Methods）和替代构造器（Alternative Constructors）。
举个例子，我们经常需要从不同格式的数据中创建同一个类的实例。比如，你有一个
Date类，你可能想从一个
YYYY-MM-DD格式的字符串创建日期对象，也可能想从一个时间戳创建。这时，就可以使用类方法：
from datetime import datetime
class MyDate:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
@classmethod
def from_string(cls, date_string): # date_string 格式: "YYYY-MM-DD"
year, month, day = map(int, date_string.split('-'))
return cls(year, month, day)
@classmethod
def from_timestamp(cls, timestamp):
dt_object = datetime.fromtimestamp(timestamp)
return cls(dt_object.year, dt_object.month, dt_object.day)
def __repr__(self):
return f"MyDate({self.year}, {self.month}, {self.day})"
# 使用类方法创建实例
date_from_str = MyDate.from_string("2023-10-26")
print(date_from_str)
import time
current_timestamp = time.time()
date_from_ts = MyDate.from_timestamp(current_timestamp)
print(date_from_ts)这里，
from_string和
from_timestamp就是
MyDate类的替代构造器。它们接收不同的输入，但最终都返回一个
MyDate实例。这样做的好处是，它们都封装在
MyDate类内部，清晰地表明了它们是创建
MyDate对象的方式，而且它们都返回
cls(...)，这意味着如果
MyDate被子类继承，这些工厂方法也能正确地创建子类的实例，而不需要我们手动去修改。
另一个场景是管理类级别的状态。例如，如果你想追踪某个类的所有实例的数量，或者维护一个所有实例的注册表，类方法就可以派上用场：
class Logger:
_log_count = 0 # 类属性，记录日志条数
def __init__(self, message):
self.message = message
Logger._log_count += 1 # 每创建一个实例，就增加计数
@classmethod
def get_log_count(cls):
return cls._log_count
def __repr__(self):
return f"Logger('{self.message}')"
log1 = Logger("User logged in")
log2 = Logger("Data saved")
log3 = Logger("Error occurred")
print(f"Total log entries: {Logger.get_log_count()}")通过
get_log_count这个类方法，我们可以方便地获取到当前
Logger类的实例总数，而不需要访问任何特定的
Logger实例。这展示了类方法在处理与类整体相关的逻辑时的强大之处。
