Python类型提示：限制函数参数为特定对象而非字面量

from typing import Literal

def process_status(status: Literal["success", "failure"]):
    if status == "success":
        print("操作成功")
    else:
        print("操作失败")

process_status("success") # OK
# process_status("pending") # 类型检查器会报错

import numpy as np
from enum import Enum
from typing import Callable, Union

class MathOperation(Enum):
    SIN = np.sin
    COS = np.cos
    TAN = np.tan # 还可以添加更多

    def __call__(self, x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
        """使枚举成员可直接调用其封装的函数"""
        return self.value(x)

def apply_math_operation(op: MathOperation, value: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
    """
    根据传入的数学操作枚举成员，对值进行计算。
    """
    if op is MathOperation.SIN:
        print("执行正弦操作")
    elif op is MathOperation.COS:
        print("执行余弦操作")
    else:
        print(f"执行 {op.name} 操作")
    return op(value) # 直接调用枚举成员，它会调用其封装的函数

# 使用示例
result_sin = apply_math_operation(MathOperation.SIN, np.pi / 2)
print(f"sin(pi/2) = {result_sin}")

result_cos = apply_math_operation(MathOperation.COS, 0)
print(f"cos(0) = {result_cos}")

# 也可以直接调用枚举成员
result_tan = MathOperation.TAN(np.pi / 4)
print(f"tan(pi/4) = {result_tan}")

# 类型检查器会正确处理
# apply_math_operation("invalid", 1.0) # 类型检查器会报错

import numpy as np
from abc import ABC, abstractmethod
from typing import Union, Protocol

# 方式一：使用抽象基类 (ABC)
class NumericOperation(ABC):
    @abstractmethod
    def __call__(self, x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
        pass

class SinOperation(NumericOperation):
    def __call__(self, x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
        return np.sin(x)

class CosOperation(NumericOperation):
    def __call__(self, x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
        return np.cos(x)

# 方式二：使用Protocol (Python 3.8+)
class CallableNumeric(Protocol):
    def __call__(self, x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
        ...

def execute_operation_abc(op: NumericOperation, value: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
    """
    使用抽象基类作为类型提示。
    """
    print(f"执行 {op.__class__.__name__} 操作")
    return op(value)

def execute_operation_protocol(op: CallableNumeric, value: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
    """
    使用Protocol作为类型提示。
    注意：np.sin和np.cos本身就符合CallableNumeric协议。
    """
    print(f"执行一个符合CallableNumeric协议的操作")
    return op(value)

# 使用示例 (ABC)
sin_op_instance = SinOperation()
cos_op_instance = CosOperation()

result_abc_sin = execute_operation_abc(sin_op_instance, np.pi / 2)
print(f"结果 (ABC): {result_abc_sin}")

result_abc_cos = execute_operation_abc(cos_op_instance, 0)
print(f"结果 (ABC): {result_abc_cos}")

# 使用示例 (Protocol)
# 对于Protocol，np.sin和np.cos本身就符合 CallableNumeric 的签名
result_protocol_sin = execute_operation_protocol(np.sin, np.pi / 2)
print(f"结果 (Protocol): {result_protocol_sin}")

result_protocol_cos = execute_operation_protocol(np.cos, 0)
print(f"结果 (Protocol): {result_protocol_cos}")

import numpy as np
from typing import Callable, Union

# 定义一个类型别名，表示接受一个 float 或 ndarray，返回 float 或 ndarray 的可调用对象
NumericFunction = Callable[[Union[float, np.ndarray]], Union[float, np.ndarray]]

def process_generic_function(func: NumericFunction, value: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
    """
    处理一个通用的数值函数。
    """
    print(f"执行通用函数 {func.__name__ if hasattr(func, '__name__') else '未知函数'}")
    return func(value)

# 使用示例
result_sin_generic = process_generic_function(np.sin, np.pi / 2)
print(f"结果 (通用): {result_sin_generic}")

result_cos_generic = process_generic_function(np.cos, 0)
print(f"结果 (通用): {result_cos_generic}")

# 也可以传入其他符合签名的函数
def my_square(x: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
    return x * x

result_square = process_generic_function(my_square, 5)
print(f"结果 (通用): {result_square}")

# 类型检查器会报错，因为传入的不是一个可调用对象
# process_generic_function(123, 1.0)