Python中__init__方法重载的Pythonic实践

import typing

class Foo():
    @typing.overload
    def __init__(self) -> None: 
        ...
    @typing.overload
    def __init__(self, number: int) -> None: 
        ...
    @typing.overload
    def __init__(self, string: str, number: float) -> None: 
        ...
    @typing.overload
    def __init__(self, number: float) -> None: 
        ...

    def __init__(self, string: str = None, number: typing.Union[int,float] = None) -> None:
        # 实际的运行时逻辑
        if isinstance(string, str):
            print(f'String string: {string}')
        # ... 其他逻辑

import typing

class Foo:
    def __init__(self, arg1: typing.Union[str, int, float, None] = None, 
                 arg2: typing.Union[int, float, None] = None) -> None:

        string_val: typing.Optional[str] = None
        number_val: typing.Optional[typing.Union[int, float]] = None

        # 使用match语句处理不同参数组合 (Python 3.10+)
        match (arg1, arg2):
            case (None, None):
                # 无参数构造
                print("Foo() called")
            case (str(s), None):
                # Foo("some_string")
                string_val = s
                print(f"Foo(string='{s}') called")
            case (int(n) | float(n), None):
                # Foo(123) 或 Foo(1.0)
                number_val = n
                print(f"Foo(number={n}) called")
            case (str(s), (int(n) | float(n))):
                # Foo("some_string", 123) 或 Foo("some_string", 1.0)
                string_val = s
                number_val = n
                print(f"Foo(string='{s}', number={n}) called")
            case _:
                # 处理其他未预期的参数组合
                raise TypeError(f"Invalid arguments for Foo: ({arg1}, {arg2})")

        # 根据解析出的值进行后续处理
        if string_val is not None:
            print(f'内部处理：字符串参数为: {string_val}')
        if number_val is not None:
            print(f'内部处理：数字参数为: {number_val}')

        # 假设我们有一个内部属性来存储这些值
        self._string = string_val
        self._number = number_val

# 实例化测试
if __name__ == '__main__':
    print("--- Test 1: Foo(1.0) ---")
    test1 = Foo(1.0) # 期望 number = 1.0
    print("\n--- Test 2: Foo(6) ---")
    test2 = Foo(6)   # 期望 number = 6
    print("\n--- Test 3: Foo('Test 3', 3.0) ---")
    test3 = Foo('Test 3', 3.0) # 期望 string = 'Test 3', number = 3.0
    print("\n--- Test 4: Foo('Test 4', 10) ---")
    test4 = Foo('Test 4', 10) # 期望 string = 'Test 4', number = 10
    print("\n--- Test 5: Foo() ---")
    test5 = Foo() # 期望无参数
    print("\n--- Test 6: Foo(number=5.5) ---")
    # 使用命名参数，直接指定参数
    test6 = Foo(number=5.5) # 期望 number = 5.5，arg1为None

class Foo:
    def __init__(self, string: str = None, number: typing.Union[int, float] = None) -> None:
        # ... 内部逻辑，根据string和number的值进行处理
        if string is not None:
            print(f"字符串参数: {string}")
        if number is not None:
            print(f"数字参数: {number}")

# 使用命名参数调用
test_named_arg = Foo(number=1.0) # string为None，number为1.0
test_named_arg_2 = Foo(string="hello", number=10)