Python 类居然能秒变函数？Callable 函数 +__call__方法实战

# 第一步：必须导入 Callable，不然会报错
from collections.abc import Callable

# 第二步：用 isinstance(对象, Callable) 判断
result = isinstance(要检查的对象, Callable)
print(result)  # 结果是 True（可调用）或 False（不可调用）

from collections.abc import Callable

# 1. 普通函数
def add(a, b):
    return a + b
print("普通函数:", isinstance(add, Callable))  # 输出：普通函数: True

# 2. lambda 表达式
lambda_func = lambda x: x * 2
print("lambda:", isinstance(lambda_func, Callable))  # 输出：lambda: True

# 3. 类本身
class MyClass:
    pass
print("类本身:", isinstance(MyClass, Callable))  # 输出：类本身: True

# 4. 类实例（无 __call__）
obj = MyClass()
print("无__call__的实例:", isinstance(obj, Callable))  # 输出：无__call__的实例: False

# 5. 内置函数
print("内置函数print:", isinstance(print, Callable))  # 输出：内置函数print: True

# 6. 普通变量
num = 123
print("普通变量:", isinstance(num, Callable))  # 输出：普通变量: False

from collections.abc import Callable

class MyFunctionLikeClass:
    # 定义 __call__ 方法，必须带 self（代表实例本身）
    def __call__(self):
        print("我是实例，但我能像函数一样被调用！")

# 1. 创建实例
obj = MyFunctionLikeClass()

# 2. 检查实例是否可调用（此时应该是 True 了）
print("有__call__的实例:", isinstance(obj, Callable))  # 输出：有__call__的实例: True

# 3. 像调用函数一样调用实例！
obj()  # 输出：我是实例，但我能像函数一样被调用！

from collections.abc import Callable

class Calculator:
    def __init__(self, operator):
        # 初始化时传入运算符（比如 +、*），保存为实例属性
        self.operator = operator

    # 定义带参数的 __call__，支持位置参数和关键字参数
    def __call__(self, a, b):
        if self.operator == "+":
            return a + b
        elif self.operator == "*":
            return a * b
        else:
            return f"不支持的运算符：{self.operator}"

# 1. 创建“加法计算器”实例（初始化时传 "+"）
add_calc = Calculator("+")
# 2. 像函数一样调用，传两个数
result1 = add_calc(3, 5)
print("3 + 5 =", result1)  # 输出：3 + 5 = 8

# 3. 再创建“乘法计算器”实例
mul_calc = Calculator("*")
result2 = mul_calc(4, 6)
print("4 * 6 =", result2)  # 输出：4 * 6 = 24

# 4. 检查这两个实例是否可调用
print("加法计算器可调用吗？", isinstance(add_calc, Callable))  # 输出：True
print("乘法计算器可调用吗？", isinstance(mul_calc, Callable))  # 输出：True

class Counter:
    def __init__(self, start=0):
        self.count = start  # 初始计数，默认从 0 开始

    def __call__(self):
        self.count += 1  # 每次调用，计数+1
        return self.count  # 返回当前计数

# 创建计数器实例，从 1 开始
counter = Counter(1)

# 像函数一样调用，每次调用计数+1
print(counter())  # 输出：2
print(counter())  # 输出：3
print(counter())  # 输出：4

# 查看当前计数（也能直接访问实例属性）
print("当前计数：", counter.count)  # 输出：4

from collections.abc import Callable

# 1. 准备各种元素
# 普通函数
def say_hello(name):
    return f"Hello, {name}!"

# 有 __call__ 的类（加法计算器）
class AddCalculator:
    def __call__(self, a, b):
        return a + b

# 无 __call__ 的类
class EmptyClass:
    pass

# 2. 创建混合列表（里面啥都有）
mixed_list = [
    say_hello,                  # 普通函数（可调用）
    AddCalculator(),            # 有__call__的实例（可调用）
    123,                        # 普通变量（不可调用）
    EmptyClass(),               # 无__call__的实例（不可调用）
    lambda x: x ** 2,           # lambda 表达式（可调用）
    "I'm a string"              # 字符串（不可调用）
]

# 3. 过滤可调用元素：用列表推导式 + Callable 检查
callable_items = [item for item in mixed_list if isinstance(item, Callable)]
print("过滤后的可调用元素：", [str(item) for item in callable_items])
# 输出大概是：[<function say_hello at 0x...>, <__main__.AddCalculator object at 0x...>, <function <lambda> at 0x...>]

# 4. 批量执行可调用元素，收集结果（注意：不同元素的参数可能不一样，需要适配）
results = []
for item in callable_items:
    # 适配不同元素的参数：这里根据实际情况判断
    if item == say_hello:
        res = item("Python")  # say_hello 需要 1 个参数
    elif isinstance(item, AddCalculator):
        res = item(5, 3)      # AddCalculator 需要 2 个参数
    elif item.__name__ == "<lambda>":  # 判断是不是 lambda
        res = item(4)         # lambda 需要 1 个参数
    results.append(res)

# 5. 打印结果
print("批量执行结果：", results)
# 输出：批量执行结果：['Hello, Python!', 8, 16]

# 没导入 Callable，直接用 isinstance
isinstance(print, Callable)  # 报错：NameError: name 'Callable' is not defined

from collections.abc import Callable
isinstance(print, Callable)  # 正确，返回 True

class MyClass:
    # __call__ 漏了 self，会报错
    def __call__(a, b):
        return a + b

obj = MyClass()
obj(1, 2)  # 报错：TypeError: __call__() missing 1 required positional argument: 'b'

class MyClass:
    def __call__(self, a, b):  # 加上 self
        return a + b

obj = MyClass()
print(obj(1, 2))  # 正确，输出 3

from collections.abc import Callable

class MyClass:
    pass  # 没有 __call__ 方法

# 误以为“类可调用”=“实例可调用”
print(isinstance(MyClass, Callable))  # 输出 True（类本身可调用）
obj = MyClass()
print(isinstance(obj, Callable))      # 输出 False（实例不可调用）
obj()  # 报错：TypeError: 'MyClass' object is not callable

from collections.abc import Callable

def add(a, b):
    return a + b

# 错把 add(1,2)（函数调用结果，是 3）当成对象检查
print(isinstance(add(1, 2), Callable))  # 输出 False

print(isinstance(add, Callable))  # 正确，输出 True

from collections.abc import Callable

def func():
    pass

print(callable(func))  # True
print(isinstance(func, Callable))  # True

from collections.abc import Callable

class WithCall:
    def __call__(self):
        pass

class WithoutCall:
    pass

# 类本身可调用
print(isinstance(WithCall, Callable))  # True
print(isinstance(WithoutCall, Callable))  # True

# 实例是否可调用，看有没有 __call__
print(isinstance(WithCall(), Callable))  # True
print(isinstance(WithoutCall(), Callable))  # False

class FactorialCache:
    def __init__(self):
        # 初始化缓存，保存 {数字: 阶乘结果}，0! = 1，1! = 1
        self.cache = {0: 1, 1: 1}

    def __call__(self, n):
        if not isinstance(n, int) or n < 0:
            raise ValueError("只能计算非负整数的阶乘")
        
        # 查缓存：有就直接返回
        if n in self.cache:
            return self.cache[n]
        
        # 没缓存：计算阶乘（从 2 开始算到 n）
        result = 1
        for i in range(2, n + 1):
            result *= i
            # 顺便把中间结果存缓存（比如算 5! 时，存 2!、3!、4!）
            self.cache[i] = result
        
        return result

# 测试
fact = FactorialCache()
print(fact(5))  # 输出 120（第一次计算，存缓存）
print(fact(3))  # 输出 6（直接从缓存取）
print(fact(10)) # 输出 3628800（计算 6!-10!，存缓存）