Python Optional与Union

Optional 和 Union 处理可选值和多类型值，增强类型注解的表达能力。

Optional 可选类型

from typing import Optional

# Optional[T] 等价于 Union[T, None]
def find_user(id: int) -> Optional[str]:
    if id > 0:
        return 'Alice'
    return None

# 使用 Optional 变量
name: Optional[str] = find_user(1)
name = None  # 允许赋值 None

Optional 使用场景

from typing import Optional

# 函数可能返回 None
def parse_int(value: str) -> Optional[int]:
    try:
        return int(value)
    except ValueError:
        return None

# 参数可能为 None
def greet(name: Optional[str] = None) -> str:
    if name is None:
        return "Hello, World"
    return f"Hello, {name}"

# 属性可能为 None
class User:
    def __init__(self, name: str, email: Optional[str] = None):
        self.name = name
        self.email = email

处理 Optional 值

from typing import Optional

def process(value: Optional[int]) -> int:
    # 必须处理 None 情况
    if value is None:
        return 0
    return value * 2

# 类型检查会要求处理 None
def unsafe_process(value: Optional[int]) -> int:
    return value * 2  # mypy 报错：value 可能为 None

# 安全处理方式
def safe_process(value: Optional[int]) -> int:
    if value is None:
        return 0
    return value * 2

# 使用断言
def assert_process(value: Optional[int]) -> int:
    assert value is not None
    return value * 2

Union 联合类型

from typing import Union

# Union[T1, T2, T3] 表示多种类型之一
def process(value: Union[int, str, float]) -> str:
    return str(value)

# 使用 Union 变量
data: Union[int, str] = 10
data = "hello"  # 允许赋值 str

# 多类型参数
def display(value: Union[int, str, bool]) -> str:
    if isinstance(value, bool):
        return "Boolean"
    return str(value)

Python 3.10+ | 语法

# Python 3.10+ 可用 | 替代 Union

# Optional 等价于 T | None
def find_user(id: int) -> str | None:
    if id > 0:
        return 'Alice'
    return None

# Union 等价于 | 连接
def process(value: int | str | float) -> str:
    return str(value)

# 嵌套使用
data: list[int | str] = [1, 'hello', 2]

Union 类型检查

from typing import Union

def process(value: Union[int, str]) -> str:
    # 类型检查要求处理每种类型
    if isinstance(value, int):
        return f"Number: {value}"
    elif isinstance(value, str):
        return f"String: {value}"
    else:
        return "Unknown"

# 不安全使用
def unsafe(value: Union[int, str]) -> int:
    return value + 1  # 报错：str 不能 + 1

Optional vs Union

from typing import Optional, Union

# Optional[T] 是 Union[T, None] 的简写
value: Optional[int] = None
value: Union[int, None] = None  # 完全等价

# Optional 用于单类型 + None
def get_name() -> Optional[str]:
    return None

# Union 用于多类型组合
def get_id() -> Union[int, str, None]:
    return 'A001'

# Python 3.10+ 简化
def get_id_new() -> int | str | None:
    return 'A001'

实际应用示例

from typing import Optional, Union, List

# 配置值可能为 None
class Config:
    def __init__(
        self,
        host: str,
        port: Optional[int] = None,
        timeout: Union[int, float] = 30
    ):
        self.host = host
        self.port = port or 80
        self.timeout = timeout

# API 返回多种格式
def fetch_data() -> Union[dict, List[dict], None]:
    # 返回单个对象、列表或 None
    pass

# 多类型输入
def format_value(value: Union[int, str, float]) -> str:
    if isinstance(value, float):
        return f"{value:.2f}"
    return str(value)

类型收窄

from typing import Union

def process(value: Union[int, str]) -> int:
    # isinstance 后类型被收窄
    if isinstance(value, int):
        # value 类型为 int
        return value * 2
    else:
        # value 类型为 str
        return len(value)

# None 检查收窄
from typing import Optional

def handle(value: Optional[str]) -> str:
    if value is None:
        return "empty"
    # value 类型为 str（已收窄）
    return value.upper()

类型对比

要点总结

• Optional[T] 表示值可能为 T 或 None
• 使用 Optional 必须处理 None 情况
• Union[T1, T2] 表示多种类型之一
• isinstance 检查后类型自动收窄
• Python 3.10+ 使用 | 替代 Union
• Optional 是 Union[T, None] 的简写
• 多类型组合使用 Union 或 |
• Optional 和 Union 增强类型表达能力