Python 哨兵值模式(Sentinel Value Pattern)的具体使用

def get_user(name, default=None):
    return cache.get(name, default)

# 问题：调用者如何区分"没传 default"和"传了 None 作为 default"？
get_user("alice")           # 没传 default
get_user("alice", None)     # 传了 None
get_user("alice", "guest")  # 传了 "guest"

_MISSING = object()

def greet(name, greeting=_MISSING):
    if greeting is _MISSING:
        greeting = "Hello"
    return f"{greeting}, {name}!"

greet("Alice")             # "Hello, Alice!"
greet("Alice", None)       # "None, Alice!"   ← None 被正常处理
greet("Alice", "Hi")       # "Hi, Alice!"

class _MissingType:
    """表示"未提供"的哨兵类型，全局单例。"""
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __repr__(self):
        return "<MISSING>"

    def __bool__(self):
        return False  # 可以在 if not x 中使用

MISSING = _MissingType()

# inspect 模块
from inspect import Parameter
Parameter.empty  # 内置哨兵，表示"无默认值"

# functools.lru_cache 内部
_sentinel = object()  # 用于缓存 miss 判断

# dataclasses.field
from dataclasses import field, MISSING
# MISSING 是 dataclasses 模块定义的哨兵，用于区分"没有默认值"和"默认值为 None"

import dataclasses

@dataclasses.dataclass
class Config:
    host: str
    port: int = 8080
    timeout: float = dataclasses.field(default=None)  # 显式 None
    # 若不提供 default 或 default_factory，字段的 default 就是 MISSING

from typing import Union

class _MissingType:
    def __repr__(self): return "<MISSING>"

MISSING = _MissingType()

# Python 3.10+ 写法
def process(value: int | _MissingType = MISSING) -> str:
    if value is MISSING:
        return "no value provided"
    return f"got {value}"

class _Sentinel:
    _created = False

    def __new__(cls):
        if cls._created:
            raise RuntimeError(f"{cls.__name__} is a singleton")
        instance = super().__new__(cls)
        cls._created = True
        return instance

    def __init_subclass__(cls, **kwargs):
        raise TypeError("Cannot subclass a sentinel type")

    def __copy__(self): return self
    def __deepcopy__(self, memo): return self
    def __reduce__(self): return (self.__class__, ())

MISSING = _Sentinel()

class _Missing:
    def __repr__(self): return "<MISSING>"
    def __bool__(self): return False

MISSING = _Missing()

class Cache:
    def __init__(self):
        self._store: dict = {}

    def get(self, key: str, default=MISSING):
        """
        default=MISSING  → 键不存在时抛出 KeyError
        default=None     → 键不存在时返回 None
        default=<任意值>  → 键不存在时返回该值
        """
        if key in self._store:
            return self._store[key]
        if default is MISSING:
            raise KeyError(f"Key '{key}' not found")
        return default

    def set(self, key: str, value=MISSING):
        if value is MISSING:
            raise ValueError("Must provide a value (even None is allowed)")
        self._store[key] = value

cache = Cache()
cache.set("user", None)       # ✅ 存入 None 是合法的
cache.get("user")             # → None
cache.get("missing_key")      # → KeyError
cache.get("missing_key", None)  # → None（不抛错）
cache.get("missing_key", "fallback")  # → "fallback"