Python 3 如何用元编程和 typehints 实现类函数重载

在Python里实现真正的函数重载比较麻烦，因为Python不支持像C++那样的原生重载。不过我们可以用functools.singledispatch配合类型提示来模拟。

最简单的方案是用singledispatch装饰器：

from functools import singledispatch
from typing import Union

@singledispatch
def process(data):
    raise NotImplementedError("Unsupported type")

@process.register
def _(data: int):
    return f"Processing integer: {data}"

@process.register  
def _(data: str):
    return f"Processing string: {data}"

@process.register
def _(data: list):
    return f"Processing list with {len(data)} items"

# 使用示例
print(process(42))        # Processing integer: 42
print(process("hello"))   # Processing string: hello  
print(process([1, 2, 3])) # Processing list with 3 items

对于类方法，可以用singledispatchmethod：

from functools import singledispatchmethod

class Processor:
    @singledispatchmethod
    def handle(self, data):
        raise NotImplementedError("Unsupported type")
    
    @handle.register
    def _(self, data: int):
        return f"Handling int: {data}"
    
    @handle.register
    def _(self, data: str):
        return f"Handling str: {data}"

如果你想要更花哨的元编程方案，可以自己写装饰器来收集重载函数：

from inspect import signature
from typing import get_type_hints, Dict, Callable, Any

class Overload:
    def __init__(self):
        self._registry: Dict[tuple, Callable] = {}
    
    def register(self, func: Callable):
        sig = signature(func)
        type_hints = get_type_hints(func)
        key = tuple(type_hints.get(param, Any) for param in sig.parameters if param != 'self')
        self._registry[key] = func
        return self
    
    def __call__(self, *args, **kwargs):
        from typing import get_type_hints
        arg_types = tuple(type(arg) for arg in args)
        
        # 寻找匹配的函数
        for key, func in self._registry.items():
            if len(key) == len(arg_types) and all(
                isinstance(arg, expected) if expected is not Any else True
                for arg, expected in zip(arg_types, key)
            ):
                return func(*args, **kwargs)
        raise TypeError("No matching overload found")

# 使用示例
overload_func = Overload()

@overload_func.register
def func(x: int) -> str:
    return f"int: {x}"

@overload_func.register  
def func(x: str) -> str:
    return f"str: {x}"

print(func(10))   # int: 10
print(func("hi")) # str: hi

不过说实话，Python的动态类型特性让重载没那么必要，通常用可选参数或者联合类型就能搞定。

总结：用singledispatch最省事。