Python typing.Callable详解 - 可调用对象类型标注完全指南

from typing import Callable

# 基本用法：指定参数类型和返回值类型
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

# 不指定参数类型的可调用对象
func: Callable[..., str]

# 仅表示可调用，不指定签名
func: Callable

# 使用类型变量
from typing import TypeVar
T = TypeVar('T')
R = TypeVar('R')
def higher_order(f: Callable[[T], R], value: T) -> R:
    return f(value)

from typing import Callable

def apply_operation(
    a: int,
    b: int,
    operation: Callable[[int, int], int]
) -> int:
    """将操作函数应用到两个整数上"""
    return operation(a, b)

# 定义几个操作函数
def add(x: int, y: int) -> int:
    return x + y

def multiply(x: int, y: int) -> int:
    return x * y

def power(x: int, y: int) -> int:
    return x ** y

# 使用不同的操作
print(f"3 + 5 = {apply_operation(3, 5, add)}")
print(f"3 * 5 = {apply_operation(3, 5, multiply)}")
print(f"3 ** 5 = {apply_operation(3, 5, power)}")

# 使用lambda
print(f"10 - 3 = {apply_operation(10, 3, lambda x, y: x - y)}")

3 + 5 = 8
3 * 5 = 15
3 ** 5 = 243
10 - 3 = 7

from typing import Callable, List

# 定义排序策略类型
SortStrategy = Callable[[List[int]], List[int]]

def bubble_sort(data: List[int]) -> List[int]:
    """冒泡排序"""
    result = data.copy()
    n = len(result)
    for i in range(n):
        for j in range(0, n - i - 1):
            if result[j] > result[j + 1]:
                result[j], result[j + 1] = result[j + 1], result[j]
    return result

def selection_sort(data: List[int]) -> List[int]:
    """选择排序"""
    result = data.copy()
    n = len(result)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if result[j] < result[min_idx]:
                min_idx = j
        result[i], result[min_idx] = result[min_idx], result[i]
    return result

def sort_numbers(
    data: List[int],
    strategy: SortStrategy
) -> List[int]:
    """使用指定策略排序"""
    return strategy(data)

numbers = [64, 34, 25, 12, 22, 11, 90]

print(f"原始数据: {numbers}")
print(f"冒泡排序: {sort_numbers(numbers, bubble_sort)}")
print(f"选择排序: {sort_numbers(numbers, selection_sort)}")

原始数据: [64, 34, 25, 12, 22, 11, 90]
冒泡排序: [11, 12, 22, 25, 34, 64, 90]
选择排序: [11, 12, 22, 25, 34, 64, 90]

from typing import Callable, Dict, List, Any

class EventBus:
    """简单的事件总线"""

    def __init__(self) -> None:
        self._handlers: Dict[str, List[Callable[[Any], None]]] = {}

    def subscribe(self, event: str, handler: Callable[[Any], None]) -> None:
        """订阅事件"""
        if event not in self._handlers:
            self._handlers[event] = []
        self._handlers[event].append(handler)

    def publish(self, event: str, data: Any) -> None:
        """发布事件"""
        if event in self._handlers:
            for handler in self._handlers[event]:
                handler(data)

# 创建事件总线
bus = EventBus()

# 定义事件处理器
def on_user_created(data: Any) -> None:
    print(f"  [用户创建] 新用户: {data}")

def on_user_deleted(data: Any) -> None:
    print(f"  [用户删除] 删除用户: {data}")

def log_event(data: Any) -> None:
    print(f"  [日志] 事件数据: {data}")

# 订阅事件
bus.subscribe("user_created", on_user_created)
bus.subscribe("user_created", log_event)
bus.subscribe("user_deleted", on_user_deleted)

# 发布事件
print("发布 user_created 事件:")
bus.publish("user_created", {"name": "Alice", "id": 1})

print("\n发布 user_deleted 事件:")
bus.publish("user_deleted", {"id": 1})

发布 user_created 事件:
  [用户创建] 新用户: {'name': 'Alice', 'id': 1}
  [日志] 事件数据: {'name': 'Alice', 'id': 1}

发布 user_deleted 事件:
  [用户删除] 删除用户: {'id': 1}