让对象像函数一样工作：深入理解 Python `__call__` 的作用与实战场景

让对象像函数一样工作：深入理解 Python __call__ 的作用与实战场景

在 Python 的世界里，函数可以被调用，类可以被调用，甚至某些对象也可以被调用。初学者第一次看到 obj() 这种写法时，往往会下意识认为：只有函数才应该这样用。但 Python 的优雅之处正在于此------它并不把"函数"和"对象"割裂开，而是提供了一套统一的对象模型：只要一个对象实现了 __call__ 方法，它就可以像函数一样被调用。

这篇文章想回答一个看似简单、实则很有价值的问题：

__call__ 的作用是什么？什么场景下会让对象可调用？

如果你正在学习 Python 编程，理解 __call__ 可以帮助你看懂装饰器、回调、框架源码和高级 API 设计；如果你已经有多年开发经验，掌握它则能让你写出更灵活、更具表达力的 Python 代码。

---

一、__call__ 到底是什么？

在 Python 中，__call__ 是一个特殊方法，也叫魔术方法。它的作用很直接：

让一个对象可以像函数一样被调用。

例如：

class Greeter:
    def __call__(self, name):
        return f"你好，{name}！欢迎学习 Python。"

greeter = Greeter()

print(greeter("Alex"))

输出：

你好，Alex！欢迎学习 Python。

这里的 greeter 不是函数，而是 Greeter 类的实例对象。但因为它实现了 __call__ 方法，所以可以使用 greeter("Alex") 这种函数调用语法。

从概念上说：

greeter("Alex")

大致等价于：

greeter.__call__("Alex")

也就是说，obj(...) 的背后，本质上是在触发对象的调用行为。

---

二、如何判断一个对象是否可调用？

Python 提供了内置函数 callable()，可以判断对象是否可调用。

def hello():
    pass

class User:
    pass

class Task:
    def __call__(self):
        print("任务执行中")

print(callable(hello))   # True
print(callable(User))    # True，类本身可以被调用，用于创建实例
print(callable(User()))  # False，普通实例不可调用
print(callable(Task()))  # True，实现了 __call__

这里有一个非常重要的点：类本身通常是可调用的。当我们写：

user = User()

其实就是在调用类对象。类的调用过程通常会触发对象创建流程，也就是 __new__ 和 __init__。

从这个角度看，Python 里的"调用"并不只是函数的专利，而是一种对象协议。

---

三、__call__ 与普通方法有什么区别？

很多人会问：既然可以定义普通方法，为什么还需要 __call__？

比如下面两种写法都能完成问候功能：

class Greeter:
    def greet(self, name):
        return f"Hello, {name}"

greeter = Greeter()
print(greeter.greet("Alex"))

以及：

class Greeter:
    def __call__(self, name):
        return f"Hello, {name}"

greeter = Greeter()
print(greeter("Alex"))

区别不在于"能不能实现"，而在于"表达意图"。

普通方法更适合描述对象的多个行为，比如：

user.login()
user.logout()
user.update_profile()

而 __call__ 更适合表达：

这个对象本身就是一个可以执行的动作。

比如：

validator(data)
handler(request)
processor(item)
timer(func)

这种写法更接近函数式编程的风格，也常见于框架、装饰器、任务系统、机器学习模型和中间件设计中。

---

四、实战场景一：带状态的函数对象

普通函数也可以完成很多工作，但函数自身不适合长期保存复杂状态。虽然可以使用闭包，但当状态越来越复杂时，类会更清晰。

假设我们要实现一个计数器，每调用一次就记录调用次数。

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

counter = Counter()

print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

这个例子非常适合说明 __call__ 的价值：它让对象同时拥有两种能力。

第一，它像函数一样易用。

第二，它像对象一样可以保存状态。

这类模式在数据处理、限流器、重试器、统计器、缓存器中都非常常见。

例如，一个简单的限流判断器：

class RequestLimiter:
    def __init__(self, max_times):
        self.max_times = max_times
        self.current = 0

    def __call__(self):
        if self.current >= self.max_times:
            return False
        self.current += 1
        return True

limiter = RequestLimiter(3)

for _ in range(5):
    if limiter():
        print("允许请求")
    else:
        print("请求被拒绝")

输出：

允许请求
允许请求
允许请求
请求被拒绝
请求被拒绝

这个对象不是单纯的数据容器，而是一个可以被调用的策略对象。

---

五、实战场景二：用类实现装饰器

很多 Python 教程都会讲函数装饰器，但在大型项目中，类装饰器也非常实用。尤其是当装饰器需要保存配置或状态时，__call__ 就派上用场了。

先看一个函数版装饰器：

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} 花费时间：{end - start:.4f} 秒")
        return result
    return wrapper

@timer
def compute_sum(n):
    return sum(range(n))

print(compute_sum(1_000_000))

如果我们希望装饰器支持参数，例如自定义日志前缀，就可以用类来实现：

import time
from functools import wraps

class Timer:
    def __init__(self, prefix="耗时"):
        self.prefix = prefix

    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start = time.perf_counter()
            result = func(*args, **kwargs)
            end = time.perf_counter()
            print(f"[{self.prefix}] {func.__name__}: {end - start:.4f} 秒")
            return result
        return wrapper

@Timer(prefix="性能统计")
def compute_sum(n):
    return sum(range(n))

print(compute_sum(1_000_000))

这里的关键点在于：

@Timer(prefix="性能统计")

会先创建一个 Timer 实例，然后这个实例被当作装饰器调用。也就是说，它需要实现 __call__。

这种模式在权限校验、日志记录、缓存、重试、事务管理等场景中都非常常见。

---

六、实战场景三：策略模式与可替换算法

在真实项目中，我们经常需要根据不同条件选择不同算法。比如电商系统中的折扣策略：

class NoDiscount:
    def __call__(self, price):
        return price

class PercentageDiscount:
    def __init__(self, percent):
        self.percent = percent

    def __call__(self, price):
        return price * (1 - self.percent)

class FixedDiscount:
    def __init__(self, amount):
        self.amount = amount

    def __call__(self, price):
        return max(0, price - self.amount)

def checkout(price, discount_strategy):
    final_price = discount_strategy(price)
    print(f"原价：{price}，实付：{final_price:.2f}")

checkout(100, NoDiscount())
checkout(100, PercentageDiscount(0.2))
checkout(100, FixedDiscount(30))

输出：

原价：100，实付：100.00
原价：100，实付：80.00
原价：100，实付：70.00

这里的 discount_strategy 不关心传入的是函数还是对象，只关心它是否可调用。

这正是 Python 的鸭子类型思想：

不看你是什么类型，只看你能不能完成这件事。

我们甚至可以直接传函数：

def vip_discount(price):
    return price * 0.5

checkout(100, vip_discount)

因此，__call__ 可以让对象无缝融入函数式接口，让代码更加灵活。

---

七、实战场景四：数据校验器

在后端开发、自动化脚本、数据分析流程中，数据校验是非常常见的需求。我们可以把校验规则封装成可调用对象。

class LengthValidator:
    def __init__(self, min_length=0, max_length=100):
        self.min_length = min_length
        self.max_length = max_length

    def __call__(self, value):
        length = len(value)
        if length < self.min_length:
            raise ValueError(f"长度不能小于 {self.min_length}")
        if length > self.max_length:
            raise ValueError(f"长度不能大于 {self.max_length}")
        return True

username_validator = LengthValidator(min_length=3, max_length=12)

username_validator("alex")      # 通过
username_validator("pythonista") # 通过

如果输入不合法：

username_validator("a")

会抛出：

ValueError: 长度不能小于 3

这类设计特别适合表单校验、配置校验、接口参数校验和数据清洗。相比直接写一个函数，可调用对象可以携带配置，例如最小长度、最大长度、错误提示规则等。

---

八、实战场景五：回调函数与框架接口

很多框架允许我们传入一个"可调用对象"，而不一定要求传入函数。比如事件系统中，我们可以这样设计：

class EventBus:
    def __init__(self):
        self.handlers = []

    def register(self, handler):
        if not callable(handler):
            raise TypeError("handler 必须是可调用对象")
        self.handlers.append(handler)

    def emit(self, event):
        for handler in self.handlers:
            handler(event)

class PrintHandler:
    def __call__(self, event):
        print(f"收到事件：{event}")

bus = EventBus()
bus.register(PrintHandler())
bus.register(lambda event: print(f"lambda 处理：{event}"))

bus.emit("USER_LOGIN")

输出：

收到事件：USER_LOGIN
lambda 处理：USER_LOGIN

这种设计的好处是接口更开放。调用者可以传函数、lambda、类实例，甚至是绑定方法。只要它能被调用，就可以加入系统。

这也是 Python 生态中许多优秀框架的设计哲学：接口面向行为，而不是面向具体类型。

---

九、__call__、__init__ 和 __new__ 的关系

很多人容易把 __call__ 和 __init__ 混淆。

简单来说：

• __new__：负责创建对象。
• __init__：负责初始化对象。
• __call__：负责让对象实例可以被调用。

例如：

class Demo:
    def __new__(cls, *args, **kwargs):
        print("__new__：创建对象")
        return super().__new__(cls)

    def __init__(self, name):
        print("__init__：初始化对象")
        self.name = name

    def __call__(self):
        print(f"__call__：调用对象 {self.name}")

demo = Demo("Python")
demo()

输出：

__new__：创建对象
__init__：初始化对象
__call__：调用对象 Python

可以用一个简单流程图理解：
#mermaid-svg-UYJjxdFKTy9dqNbW{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-UYJjxdFKTy9dqNbW .error-icon{fill:#552222;}#mermaid-svg-UYJjxdFKTy9dqNbW .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-UYJjxdFKTy9dqNbW .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-UYJjxdFKTy9dqNbW .marker{fill:#333333;stroke:#333333;}#mermaid-svg-UYJjxdFKTy9dqNbW .marker.cross{stroke:#333333;}#mermaid-svg-UYJjxdFKTy9dqNbW svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-UYJjxdFKTy9dqNbW p{margin:0;}#mermaid-svg-UYJjxdFKTy9dqNbW .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW .cluster-label text{fill:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW .cluster-label span{color:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW .cluster-label span p{background-color:transparent;}#mermaid-svg-UYJjxdFKTy9dqNbW .label text,#mermaid-svg-UYJjxdFKTy9dqNbW span{fill:#333;color:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW .node rect,#mermaid-svg-UYJjxdFKTy9dqNbW .node circle,#mermaid-svg-UYJjxdFKTy9dqNbW .node ellipse,#mermaid-svg-UYJjxdFKTy9dqNbW .node polygon,#mermaid-svg-UYJjxdFKTy9dqNbW .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-UYJjxdFKTy9dqNbW .rough-node .label text,#mermaid-svg-UYJjxdFKTy9dqNbW .node .label text,#mermaid-svg-UYJjxdFKTy9dqNbW .image-shape .label,#mermaid-svg-UYJjxdFKTy9dqNbW .icon-shape .label{text-anchor:middle;}#mermaid-svg-UYJjxdFKTy9dqNbW .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-UYJjxdFKTy9dqNbW .rough-node .label,#mermaid-svg-UYJjxdFKTy9dqNbW .node .label,#mermaid-svg-UYJjxdFKTy9dqNbW .image-shape .label,#mermaid-svg-UYJjxdFKTy9dqNbW .icon-shape .label{text-align:center;}#mermaid-svg-UYJjxdFKTy9dqNbW .node.clickable{cursor:pointer;}#mermaid-svg-UYJjxdFKTy9dqNbW .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-UYJjxdFKTy9dqNbW .arrowheadPath{fill:#333333;}#mermaid-svg-UYJjxdFKTy9dqNbW .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-UYJjxdFKTy9dqNbW .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-UYJjxdFKTy9dqNbW .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-UYJjxdFKTy9dqNbW .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-UYJjxdFKTy9dqNbW .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-UYJjxdFKTy9dqNbW .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-UYJjxdFKTy9dqNbW .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-UYJjxdFKTy9dqNbW .cluster text{fill:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW .cluster span{color:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-UYJjxdFKTy9dqNbW .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-UYJjxdFKTy9dqNbW rect.text{fill:none;stroke-width:0;}#mermaid-svg-UYJjxdFKTy9dqNbW .icon-shape,#mermaid-svg-UYJjxdFKTy9dqNbW .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-UYJjxdFKTy9dqNbW .icon-shape p,#mermaid-svg-UYJjxdFKTy9dqNbW .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-UYJjxdFKTy9dqNbW .icon-shape .label rect,#mermaid-svg-UYJjxdFKTy9dqNbW .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-UYJjxdFKTy9dqNbW .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-UYJjxdFKTy9dqNbW .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-UYJjxdFKTy9dqNbW :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} Demo Python
调用类 Demo
new 创建实例
init 初始化实例
得到 demo 对象
demo 调用对象
call 执行业务逻辑

需要注意：类之所以能被调用，是因为类对象背后有元类机制。默认情况下，普通类的元类是 type，而 type 实现了调用类创建实例的行为。

---

十、进阶细节：不要随便给实例动态绑定 __call__

有些开发者可能会尝试这样写：

class A:
    pass

a = A()
a.__call__ = lambda: "hello"

print(a.__call__())

这可以正常输出：

hello

但如果你写：

print(a())

通常会得到：

TypeError: 'A' object is not callable

原因是，像 __call__ 这样的特殊方法，通常需要定义在类上，而不是只放在某个实例对象上。Python 在处理特殊方法调用时，会走类型层面的查找机制。

正确写法是：

class A:
    def __call__(self):
        return "hello"

a = A()
print(a())

这一点在阅读源码或做元编程时尤其重要。

---

十一、什么时候应该让对象可调用？

__call__ 很强大，但并不意味着所有类都应该实现它。一个实用判断标准是：

当一个对象的核心职责可以被理解为"执行某个动作"时，可以考虑实现 __call__。

典型场景包括：

1. 对象需要保存状态，同时又希望像函数一样使用

比如计数器、限流器、缓存器、统计器。

class Accumulator:
    def __init__(self):
        self.total = 0

    def __call__(self, value):
        self.total += value
        return self.total

acc = Accumulator()
print(acc(10))  # 10
print(acc(5))   # 15

2. 对象用于封装一套策略

比如折扣策略、排序策略、推荐策略、风控策略。

class RiskRule:
    def __init__(self, max_amount):
        self.max_amount = max_amount

    def __call__(self, order):
        return order["amount"] <= self.max_amount

rule = RiskRule(max_amount=5000)

order = {"id": 1, "amount": 3200}
print(rule(order))  # True

3. 对象作为回调或处理器

比如事件处理器、消息消费者、任务执行器。

class MessageHandler:
    def __call__(self, message):
        print(f"处理消息：{message}")

handler = MessageHandler()
handler("订单已支付")

4. 用类实现装饰器

当装饰器需要参数、状态、配置时，类装饰器往往比嵌套函数更清晰。

class Retry:
    def __init__(self, times):
        self.times = times

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            last_error = None
            for _ in range(self.times):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
            raise last_error
        return wrapper

@Retry(times=3)
def unstable_task():
    print("尝试执行任务")
    raise RuntimeError("失败")

在生产代码中，还可以进一步加入日志、异常分类、退避时间和告警机制。

---

十二、最佳实践：如何优雅地使用 __call__

1. 保持调用语义清晰

看到下面代码时，读者应该能猜到它在做什么：

validator(data)
processor(item)
strategy(price)
handler(event)

如果调用行为不直观，就不要滥用 __call__。例如：

user()
config()
database()

这些写法就可能让人困惑，因为读者不知道"调用用户""调用配置""调用数据库"到底意味着什么。

2. 避免在 __call__ 中塞入过多职责

__call__ 应该代表对象最核心的动作。如果逻辑过多，可以拆成私有方法：

class DataProcessor:
    def __call__(self, data):
        data = self._clean(data)
        data = self._transform(data)
        return self._save(data)

    def _clean(self, data):
        return data

    def _transform(self, data):
        return data

    def _save(self, data):
        return data

这样既保留了调用接口的简洁，也让内部逻辑更容易测试和维护。

3. 配合类型提示提升可读性

Python 的动态类型很灵活，但在团队协作中，类型提示可以显著降低理解成本。

from typing import Callable

def run_task(task: Callable[[str], None]) -> None:
    task("start")

class Logger:
    def __call__(self, message: str) -> None:
        print(f"[LOG] {message}")

run_task(Logger())

这里的 Callable[[str], None] 表示：传入的对象必须可以被调用，接收一个字符串参数，返回 None。

4. 使用 callable() 做防御性检查

当你在设计框架、插件系统或任务系统时，可以检查用户传入的对象是否可调用：

def register_callback(callback):
    if not callable(callback):
        raise TypeError("callback 必须是可调用对象")
    print("注册成功")

这比直接调用后再报错更友好，也更容易定位问题。

---

十三、一个完整实践案例：轻量级数据处理流水线

下面我们用 __call__ 设计一个简单的数据处理流水线。每个处理步骤都是一个可调用对象，流水线负责按顺序执行它们。

class StripText:
    def __call__(self, text):
        return text.strip()

class ToLower:
    def __call__(self, text):
        return text.lower()

class RemoveSymbol:
    def __init__(self, symbol):
        self.symbol = symbol

    def __call__(self, text):
        return text.replace(self.symbol, "")

class Pipeline:
    def __init__(self, steps):
        for step in steps:
            if not callable(step):
                raise TypeError(f"{step} 不是可调用对象")
        self.steps = steps

    def __call__(self, value):
        for step in self.steps:
            value = step(value)
        return value

pipeline = Pipeline([
    StripText(),
    ToLower(),
    RemoveSymbol("!"),
])

result = pipeline("  Hello Python!!!  ")
print(result)

输出：

hello python

这个案例虽小，但非常接近真实工程中的设计方式。数据清洗、机器学习特征处理、Web 中间件、日志过滤器、ETL 流程，都可以采用类似思想。

它的优势包括：

• 每个步骤独立，便于测试。
• 流水线可组合，便于扩展。
• 对外接口统一，只需要调用 pipeline(data)。
• 支持函数、lambda 和对象混用。

例如：

pipeline = Pipeline([
    str.strip,
    str.lower,
    lambda s: s.replace("!", ""),
])

这就是 Python 编程的魅力：简洁、开放、灵活，又不失工程化能力。

---

十四、常见误区与避坑指南

误区一：为了炫技而使用 __call__

__call__ 不是为了让代码"看起来高级"，而是为了让接口更自然。如果普通方法更清楚，就应该使用普通方法。

user.save()
order.cancel()
cache.clear()

这些方法语义明确，没有必要改成：

user()
order()
cache()

误区二：忽略可测试性

可调用对象依然是对象，应该像普通类一样编写单元测试。

def test_length_validator():
    validator = LengthValidator(min_length=2, max_length=5)
    assert validator("abc") is True

对于异常场景，也要测试：

import pytest

def test_length_validator_too_short():
    validator = LengthValidator(min_length=2)
    with pytest.raises(ValueError):
        validator("a")

误区三：调用参数设计过于复杂

__call__ 的参数应该尽量简洁。如果参数太多，说明对象职责可能过重。

不推荐：

processor(data, user, config, logger, retry, timeout, mode)

更推荐把稳定配置放到 __init__，把每次调用变化的数据放到 __call__：

class Processor:
    def __init__(self, config, logger, retry, timeout):
        self.config = config
        self.logger = logger
        self.retry = retry
        self.timeout = timeout

    def __call__(self, data):
        ...

---

十五、总结：__call__ 是对象与函数之间的桥梁

__call__ 的核心作用，是让对象具备函数调用能力。它把"对象的状态"和"函数的简洁调用方式"结合在一起，让我们可以写出更灵活、更优雅的 Python 代码。

当你遇到以下需求时，可以考虑使用 __call__：

• 需要一个带状态的函数。
• 需要封装策略、规则或处理器。
• 需要实现类装饰器。
• 需要设计回调、插件或中间件接口。
• 需要让对象融入函数式调用风格。

但也要记住，优秀的 Python 代码不是魔术方法越多越好，而是语义清晰、职责明确、易读易测。__call__ 是一把锋利的工具，用得好，可以让 API 像自然语言一样流畅；用得不好，也会让团队成员一头雾水。

Python 的学习之路，往往就是这样：刚开始我们学习语法，后来学习库，再后来学习设计。__call__ 看起来只是一个特殊方法，却连接着函数式编程、面向对象编程、框架设计和工程实践。理解它，你会更容易读懂高级代码，也更有能力写出让别人愿意使用的接口。

最后留两个问题给你：

你在项目中见过哪些优雅的可调用对象设计？

如果让你设计一个可扩展的数据处理框架，你会选择函数、类方法，还是 __call__？

欢迎在评论区分享你的经验。真正的 Python 最佳实践，往往不是写在文档里，而是在一次次真实项目、调试和重构中生长出来的。