深入理解Python类型提示：Literal的界限与可调用对象的策略

from typing import Literal

def process_status(status: Literal["success", "failure", "pending"]):
    if status == "success":
        print("操作成功")
    else:
        print(f"当前状态: {status}")

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

import numpy as np
from typing import Literal

# 错误的使用方式，类型检查器会报错
# def foo(f: Literal[np.sin, np.cos]):
#     pass

import numpy as np
from typing import Callable

# 定义一个函数，它接受一个参数为float，返回值为float的函数
def foo(f: Callable[[float], float], x: float) -> float:
    """
    接收一个函数 f 和一个浮点数 x，并返回 f(x) 的结果。
    """
    return f(x)

# 示例
result_sin = foo(np.sin, np.pi / 2)
result_cos = foo(np.cos, 0)
result_tan = foo(np.tan, np.pi / 4)

print(f"np.sin(pi/2) = {result_sin}") # 输出：1.0
print(f"np.cos(0) = {result_cos}")   # 输出：1.0
print(f"np.tan(pi/4) = {result_tan}") # 输出：1.0

# 传递其他符合签名的函数也是类型安全的
def custom_func(val: float) -> float:
    return val * 2
result_custom = foo(custom_func, 5.0)
print(f"custom_func(5.0) = {result_custom}") # 输出：10.0

import numpy as np
from typing import Callable, Union

def foo_with_validation(f: Callable[[float], float], x: float) -> float:
    """
    接收一个函数 f 和一个浮点数 x，并返回 f(x) 的结果。
    f 必须是 np.sin 或 np.cos。
    """
    if f is not np.sin and f is not np.cos:
        raise ValueError("函数 f 必须是 np.sin 或 np.cos。")
    return f(x)

# 示例
print(f"np.sin(0) = {foo_with_validation(np.sin, 0)}")
print(f"np.cos(np.pi) = {foo_with_validation(np.cos, np.pi)}")

try:
    foo_with_validation(np.tan, np.pi / 4)
except ValueError as e:
    print(f"错误: {e}") # 输出：错误: 函数 f 必须是 np.sin 或 np.cos。

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

class MathOperation(Enum):
    SIN = "sin"
    COS = "cos"

    def get_function(self) -> Callable[[float], float]:
        if self == MathOperation.SIN:
            return np.sin
        elif self == MathOperation.COS:
            return np.cos
        else:
            # 理论上不会发生，因为枚举成员已限定
            raise NotImplementedError(f"Operation {self.value} not implemented.")

def apply_operation(op: MathOperation, x: float) -> float:
    """
    根据枚举操作应用相应的数学函数。
    """
    func = op.get_function()
    return func(x)

# 示例
print(f"apply_operation(MathOperation.SIN, np.pi / 2) = {apply_operation(MathOperation.SIN, np.pi / 2)}")
print(f"apply_operation(MathOperation.COS, 0) = {apply_operation(MathOperation.COS, 0)}")

# 类型检查器会确保传入的是 MathOperation 的成员
# apply_operation("sin", 1.0) # 类型检查器会报错

import numpy as np
from typing import Protocol, runtime_checkable

@runtime_checkable
class MathStrategy(Protocol):
    """
    定义一个数学策略的协议。
    """
    def apply(self, x: float) -> float:
        ...

class SinStrategy:
    def apply(self, x: float) -> float:
        return np.sin(x)

class CosStrategy:
    def apply(self, x: float) -> float:
        return np.cos(x)

def execute_strategy(strategy: MathStrategy, x: float) -> float:
    """
    执行给定的数学策略。
    """
    return strategy.apply(x)

# 示例
sin_strat = SinStrategy()
cos_strat = CosStrategy()

print(f"execute_strategy(sin_strat, np.pi / 2) = {execute_strategy(sin_strat, np.pi / 2)}")
print(f"execute_strategy(cos_strat, 0) = {execute_strategy(cos_strat, 0)}")

# 传入其他符合协议的对象也是类型安全的
class CustomStrategy:
    def apply(self, x: float) -> float:
        return x * x

custom_strat = CustomStrategy()
print(f"execute_strategy(custom_strat, 5.0) = {execute_strategy(custom_strat, 5.0)}")