Python 编程进阶第 50 讲：`staticmethod` 和 `classmethod` 的区别是什么？

Python 编程进阶第 50 讲：staticmethod 和 classmethod 的区别是什么？

在 Python 编程中，很多初学者第一次看到 @staticmethod 和 @classmethod 时，都会有一种熟悉又陌生的感觉：它们看起来都写在类里面，都可以通过类名调用，也都不像普通实例方法那样直接操作某个对象。于是问题来了：它们到底有什么区别？什么时候该用 staticmethod，什么时候该用 classmethod？

这个问题看似基础，却非常能体现一个开发者对 Python 面向对象编程的理解深度。写业务代码时，你可能只是“能跑就行”；但当你开始设计框架、封装工具类、编写可扩展模块时，staticmethod 和 classmethod 的选择就会影响代码的可读性、可维护性和扩展能力。

本文将从基础语法讲起，结合实战案例、常见误区和最佳实践，系统梳理二者的区别。

一、先理解普通实例方法

在正式比较 staticmethod 和 classmethod 之前，我们先看 Python 中最常见的实例方法。

class User:
    def __init__(self, name):
        self.name = name

    def say_hello(self):
        return f"你好，我是 {self.name}"

user = User("Alex")
print(user.say_hello())

这里的 say_hello 就是一个实例方法。它的第一个参数通常叫 self，表示当前对象本身。

调用时：

user.say_hello()

Python 实际上会帮你把 user 自动传进去：

User.say_hello(user)

也就是说，实例方法依赖具体对象。如果方法内部需要访问实例属性，比如 self.name、self.age，就应该使用实例方法。

二、什么是 staticmethod？

staticmethod，中文通常称为“静态方法”。它定义在类里面，但不接收 self，也不接收 cls。

它更像是一个“放在类命名空间里的普通函数”。

class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b

print(MathUtils.add(3, 5))

输出：

8

你也可以通过实例调用：

utils = MathUtils()
print(utils.add(3, 5))

但这通常不是推荐写法，因为这个方法并不依赖某个具体实例。

staticmethod 的核心特点

staticmethod 有三个关键特征：

1. 不访问实例对象，因此没有 self。
2. 不访问类对象，因此没有 cls。
3. 逻辑上属于这个类，但功能上像普通函数。

例如，在一个订单系统中，我们可能需要判断金额是否合法：

class Order:
    @staticmethod
    def is_valid_amount(amount):
        return isinstance(amount, (int, float)) and amount > 0

print(Order.is_valid_amount(99.9))
print(Order.is_valid_amount(-10))

这个方法不需要访问某个订单实例，也不需要访问订单类本身。它只是一个和订单相关的工具函数，因此可以写成 staticmethod。

三、什么是 classmethod？

classmethod，中文通常称为“类方法”。它的第一个参数不是 self，而是 cls，表示当前类本身。

class User:
    count = 0

    def __init__(self, name):
        self.name = name
        User.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

user1 = User("Alex")
user2 = User("Bob")

print(User.get_count())

输出：

2

classmethod 可以访问类属性，也可以调用类构造器创建对象。它最常见的用途之一，就是提供“替代构造方法”。

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split("-"))
        return cls(year, month, day)

date = Date.from_string("2026-07-01")
print(date.year, date.month, date.day)

这里的 from_string 并不是简单的工具函数。它需要根据字符串创建一个 Date 对象，所以用 classmethod 非常合适。

四、核心区别：一句话讲清楚

如果用一句话总结：

staticmethod 不关心类和实例，只是放在类里的工具函数；classmethod 关心类本身，通常用于访问类属性、修改类状态或创建类对象。

可以用下面这个对比来理解：

class Example:
    class_value = "我是类属性"

    def instance_method(self):
        print("实例方法可以访问 self:", self)

    @staticmethod
    def static_method():
        print("静态方法不接收 self 或 cls")

    @classmethod
    def class_method(cls):
        print("类方法可以访问 cls:", cls.class_value)

调用方式：

obj = Example()

obj.instance_method()
Example.static_method()
Example.class_method()

它们最大的区别不是“能不能通过类调用”，而是：方法内部是否需要访问实例或类。

五、一个更贴近实际开发的例子

假设我们正在开发一个用户注册模块，需要完成三件事：

1. 校验邮箱格式。
2. 根据邮箱创建用户。
3. 统计用户数量。

我们可以这样设计：

import re

class User:
    total_users = 0

    def __init__(self, email):
        if not self.is_valid_email(email):
            raise ValueError("邮箱格式不正确")

        self.email = email
        User.total_users += 1

    @staticmethod
    def is_valid_email(email):
        pattern = r"^[\w\.-]+@[\w\.-]+\.\w+$"
        return re.match(pattern, email) is not None

    @classmethod
    def from_username(cls, username):
        email = f"{username}@example.com"
        return cls(email)

    @classmethod
    def get_total_users(cls):
        return cls.total_users


user1 = User("alex@example.com")
user2 = User.from_username("bob")

print(user1.email)
print(user2.email)
print(User.get_total_users())

在这个例子中：

is_valid_email 是 staticmethod，因为它只负责校验邮箱字符串，不依赖实例，也不依赖类。

from_username 是 classmethod，因为它需要通过 cls(email) 创建当前类的实例。

get_total_users 也是 classmethod，因为它访问了类属性 total_users。

这样的设计让代码职责非常清晰：谁负责校验，谁负责构造，谁负责访问类状态，一目了然。

六、为什么 classmethod 比直接写类名更灵活？

很多人会问：既然可以直接写 User.total_users，为什么还要用 cls.total_users？

关键在于继承。

看下面这个例子：

class Animal:
    category = "animal"

    @classmethod
    def show_category(cls):
        return cls.category

class Dog(Animal):
    category = "dog"

print(Animal.show_category())
print(Dog.show_category())

输出：

animal
dog

当我们调用 Dog.show_category() 时，cls 指向的是 Dog，而不是 Animal。

这就是 classmethod 的强大之处：它天然支持继承和多态。

再看一个替代构造方法的例子：

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"], data["price"])

class DiscountProduct(Product):
    def __init__(self, name, price, discount):
        super().__init__(name, price)
        self.discount = discount

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"], data["price"], data.get("discount", 1.0))

data = {
    "name": "Python 实战课程",
    "price": 199,
    "discount": 0.8
}

product = DiscountProduct.from_dict(data)
print(product.name, product.price, product.discount)

如果你在父类里硬编码 Product(...)，子类继承时就会变得僵硬。而使用 cls(...)，可以让构造逻辑跟随调用者变化，这正是 Python 面向对象设计中非常优雅的一点。

七、什么时候用 staticmethod？

以下场景适合使用 staticmethod。

第一，方法逻辑和类有关，但不需要访问类状态或实例状态。

class PasswordUtils:
    @staticmethod
    def is_strong(password):
        return (
            len(password) >= 8
            and any(char.isdigit() for char in password)
            and any(char.isalpha() for char in password)
        )

第二，你想把相关工具函数收纳到一个类中，提升代码组织性。

class FileUtils:
    @staticmethod
    def get_extension(filename):
        return filename.split(".")[-1]

print(FileUtils.get_extension("report.pdf"))

第三，这个函数是纯函数，不改变外部状态。

class PriceCalculator:
    @staticmethod
    def add_tax(price, tax_rate):
        return price * (1 + tax_rate)

不过要注意：不要滥用 staticmethod。如果一个函数和类的关系并不强，把它放在模块级函数中往往更自然。

比如下面这样也很好：

def add_tax(price, tax_rate):
    return price * (1 + tax_rate)

Python 并不强迫你把所有东西都塞进类里。保持简单，是 Python 编程最佳实践之一。

八、什么时候用 classmethod？

以下场景更适合使用 classmethod。

第一，提供替代构造方法。

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_string(cls, text):
        name, age = text.split(",")
        return cls(name, int(age))

user = User.from_string("Alex,28")

第二，访问或修改类属性。

class Config:
    env = "development"

    @classmethod
    def set_env(cls, env):
        cls.env = env

    @classmethod
    def get_env(cls):
        return cls.env

Config.set_env("production")
print(Config.get_env())

第三，需要支持继承和多态。

class BaseParser:
    parser_name = "base"

    @classmethod
    def create(cls):
        return cls()

class JsonParser(BaseParser):
    parser_name = "json"

parser = JsonParser.create()
print(type(parser).__name__)

输出：

JsonParser

这里如果用 staticmethod，就无法自然地拿到调用它的类。

九、常见误区：不是所有工具方法都要放进类里

很多从 Java、C# 转向 Python 的开发者，刚开始会习惯性创建大量工具类：

class StringUtils:
    @staticmethod
    def trim(value):
        return value.strip()

    @staticmethod
    def lower(value):
        return value.lower()

这在某些团队规范中可以接受，但在 Python 中，模块本身就是天然的命名空间。更 Pythonic 的写法可能是：

def trim(value):
    return value.strip()

def lower(value):
    return value.lower()

然后在其他文件中导入：

from string_utils import trim, lower

所以，staticmethod 不是“工具函数的唯一归宿”。如果函数不需要类作为组织边界，模块函数往往更清爽。

十、装饰器背后的机制

从本质上看，staticmethod 和 classmethod 都是内置装饰器。

普通实例方法会进行方法绑定，把实例自动传给 self。

class Demo:
    def method(self):
        pass

demo = Demo()
print(demo.method)

你会看到它是一个 bound method，也就是已经绑定到实例的方法。

而 staticmethod 不会绑定实例或类：

class Demo:
    @staticmethod
    def method():
        print("static")

demo = Demo()
demo.method()
Demo.method()

两种调用都不会自动传入额外参数。

classmethod 则会绑定类：

class Demo:
    @classmethod
    def method(cls):
        print(cls)

Demo.method()

输出类似：

<class '__main__.Demo'>

理解这个机制之后，你会发现它们不是魔法，而是 Python 描述符协议和方法绑定机制的一种应用。

十一、项目实践：用三种方法设计一个配置类

下面我们用一个配置管理类，把实例方法、静态方法和类方法放在一起比较。

class AppConfig:
    default_timeout = 30

    def __init__(self, app_name, timeout=None):
        self.app_name = app_name
        self.timeout = timeout or self.default_timeout

    def describe(self):
        return f"{self.app_name} timeout={self.timeout}"

    @staticmethod
    def is_valid_timeout(timeout):
        return isinstance(timeout, int) and timeout > 0

    @classmethod
    def from_dict(cls, data):
        app_name = data.get("app_name", "default-app")
        timeout = data.get("timeout", cls.default_timeout)

        if not cls.is_valid_timeout(timeout):
            raise ValueError("timeout 必须是正整数")

        return cls(app_name, timeout)


config_data = {
    "app_name": "payment-service",
    "timeout": 60
}

config = AppConfig.from_dict(config_data)
print(config.describe())

这个例子非常典型：

describe 是实例方法，因为它描述的是某个具体配置对象。

is_valid_timeout 是静态方法，因为它只是校验一个值。

from_dict 是类方法，因为它负责根据字典创建当前类的实例。

这种写法不仅清晰，而且方便测试。

十二、单元测试怎么写？

好的设计应该让测试变得简单。比如我们可以这样测试：

def test_valid_timeout():
    assert AppConfig.is_valid_timeout(10) is True
    assert AppConfig.is_valid_timeout(-1) is False
    assert AppConfig.is_valid_timeout("30") is False

def test_from_dict():
    data = {"app_name": "api", "timeout": 20}
    config = AppConfig.from_dict(data)

    assert config.app_name == "api"
    assert config.timeout == 20

静态方法通常很好测，因为它不依赖对象状态。

类方法也比较容易测，因为它通常有明确输入和输出。尤其是 from_dict、from_json、from_env 这类替代构造方法，在工程项目中非常常见。

十三、性能上有区别吗？

从性能角度看，staticmethod、classmethod 和实例方法之间确实有调用机制差异，但在绝大多数业务场景中，这点差异微乎其微。

真正应该优先考虑的是：

代码是否清晰？

职责是否明确？

是否方便继承？

是否方便测试？

是否符合团队约定？

在 Python 实战中，过早追求这类微小性能差异，往往不如把精力放在算法优化、数据库查询优化、I/O 优化和架构设计上。

十四、最佳实践总结

在实际项目中，可以遵循下面这套判断规则：

如果方法需要访问实例属性，用实例方法。

def method(self):
    ...

如果方法不需要访问实例和类，只是和类主题相关的工具函数，用 staticmethod。

@staticmethod
def method():
    ...

如果方法需要访问类属性、修改类状态，或者通过当前类创建对象，用 classmethod。

@classmethod
def method(cls):
    ...

更进一步，如果一个函数既不依赖实例，也不依赖类，并且和类关系不强，优先考虑把它写成模块级函数。

十五、一个直观示意图

可以用下面这个简单关系图理解三者：

实例方法 instance method
    ↓
接收 self
    ↓
操作具体对象状态

静态方法 staticmethod
    ↓
不接收 self / cls
    ↓
像普通函数，放在类中做逻辑归类

类方法 classmethod
    ↓
接收 cls
    ↓
操作类状态，或创建当前类/子类对象

如果用一句更有画面感的话说：

实例方法像“对象自己的动作”。

静态方法像“挂在类门口的一把工具”。

类方法像“类自己掌握的一套工厂能力”。

十六、面试中如何回答？

如果面试官问：staticmethod 和 classmethod 的区别是什么？

你可以这样回答：

staticmethod 是静态方法，不会自动接收实例对象或类对象，适合放置与类相关但不依赖类状态和实例状态的工具函数。classmethod 是类方法，第一个参数是 cls，表示当前类本身，适合访问类属性、修改类状态，或者实现替代构造方法。二者都可以通过类名调用，但核心区别在于 classmethod 关心类，staticmethod 不关心类和实例。使用 classmethod 时，在继承场景下可以保持更好的扩展性，因为 cls 会指向实际调用它的类。

这个回答既有定义，也有使用场景，还点到了继承扩展性，比较完整。

十七、结语：写好 Python，不只是会语法

Python 的魅力不只是语法简洁，更在于它鼓励我们用清晰、自然、贴近问题本身的方式组织代码。

staticmethod 和 classmethod 的区别，看起来只是两个装饰器的区别，背后其实是三个重要问题：

这个方法属于对象，还是属于类？

它是否需要状态？

它未来是否需要被继承和扩展？

当你能回答这些问题时，你写出的 Python 代码就会从“能运行”走向“好维护”，从“完成任务”走向“具备设计感”。

在日常 Python 编程、Python教程学习、Python实战项目和 Python最佳实践积累中，这类细节非常值得反复打磨。真正优秀的工程能力，往往就藏在这些看似微小的选择里。

你在项目中更常用 staticmethod，还是 classmethod？有没有因为选错方法类型导致代码难以扩展的经历？欢迎在评论区分享你的经验，也许你的一个真实案例，就能帮助另一位开发者少走很多弯路。