Python 实现函数重载（function overloading）：根据不同的参数类型执行不同的逻辑

[mimo-x]

函数方法重载

from typing import Any, List
from functools import singledispatch

@singledispatch
def process(data: Any) -> Any:
    pass

@process.register(int)
def _(data: int) -> int:
    return data * 2

@process.register(str)
def _(data: str) -> str:
    return data.upper()

@process.register(list)
def _(data: List[int]) -> List[int]:
    return [item * 2 for item in data]

print(process(1))
print(process("hello"))
print(process([1,2,3]))

[mimo-x]

类中方法重载

from typing import Any, List
from functools import singledispatchmethod

class Process:
    def __init__(self, data: Any) -> None:
        self.data = data

    @singledispatchmethod
    def process(self, data: Any) -> Any:
        return data
    
    @process.register(int)
    def _(self, data: int) -> int:
        return data * 2

    @process.register(str)
    def _(self, data: str) -> str:
        return data.upper()

    @process.register(list)
    def _(self, data: List[int]) -> List[int]:
        return [item * 2 for item in data]

# 使用示例
if __name__ == "__main__":
    processor = Process(None)
    print(processor.process(1))      # 输出: 2
    print(processor.process("hello")) # 输出: HELLO
    print(processor.process([1,2,3])) # 输出: [2, 4, 6]

[mimo-x]

错误示例

from typing import Any, Union
from functools import singledispatchmethod
from datetime import datetime

# 使用大量if-else的版本
class DataProcessor:
    def process_data(self, data: Any) -> str:
        if isinstance(data, str):
            return f"处理字符串: {data.upper()}"
        elif isinstance(data, int):
            return f"处理整数: {data * 2}"
        elif isinstance(data, float):
            return f"处理浮点数: {data:.2f}"
        elif isinstance(data, list):
            return f"处理列表: {[x * 2 if isinstance(x, (int, float)) else x for x in data]}"
        elif isinstance(data, dict):
            return f"处理字典: {dict((k, v * 2 if isinstance(v, (int, float)) else v) for k, v in data.items())}"
        elif isinstance(data, datetime):
            return f"处理日期: {data.strftime('%Y-%m-%d %H:%M:%S')}"
        else:
            return f"未知类型: {type(data)}"

# 使用singledispatchmethod优化的版本
class OptimizedDataProcessor:
    @singledispatchmethod
    def process_data(self, data: Any) -> str:
        return f"未知类型: {type(data)}"
    
    @process_data.register(str)
    def _(self, data: str) -> str:
        return f"处理字符串: {data.upper()}"
    
    @process_data.register(int)
    def _(self, data: int) -> str:
        return f"处理整数: {data * 2}"
    
    @process_data.register(float)
    def _(self, data: float) -> str:
        return f"处理浮点数: {data:.2f}"
    
    @process_data.register(list)
    def _(self, data: list) -> str:
        return f"处理列表: {[x * 2 if isinstance(x, (int, float)) else x for x in data]}"
    
    @process_data.register(dict)
    def _(self, data: dict) -> str:
        return f"处理字典: {dict((k, v * 2 if isinstance(v, (int, float)) else v) for k, v in data.items())}"
    
    @process_data.register(datetime)
    def _(self, data: datetime) -> str:
        return f"处理日期: {data.strftime('%Y-%m-%d %H:%M:%S')}"

# 测试代码
if __name__ == "__main__":
    # 测试原始版本
    print("=== 原始版本（使用if-else）===")
    processor = DataProcessor()
    print(processor.process_data("hello"))
    print(processor.process_data(42))
    print(processor.process_data(3.14159))
    print(processor.process_data([1, 2, 3]))
    print(processor.process_data({"a": 1, "b": 2}))
    print(processor.process_data(datetime.now()))
    
    print("\n=== 优化版本（使用singledispatchmethod）===")
    optimized = OptimizedDataProcessor()
    print(optimized.process_data("hello"))
    print(optimized.process_data(42))
    print(optimized.process_data(3.14159))
    print(optimized.process_data([1, 2, 3]))
    print(optimized.process_data({"a": 1, "b": 2}))
    print(optimized.process_data(datetime.now()))