Python中创建既作类型又作值的单例对象：策略与权衡

class Client:
    def partial_update(
            self,
            obj_id: int,
            obj_field: int | None | NotSet = NotSet, # 期望 NotSet 既是类型也是值
            another_field: str | None | NotSet = NotSet,
            # ... 其他字段
    ):
        # 如果 obj_field 未明确指定，则不更新
        if obj_field is NotSet:
            print("obj_field 未设置，不更新。")
        else:
            # 否则，更新 obj_field，即使其值为 None
            print(f"obj_field 设置为: {obj_field}，执行更新。")

        if another_field is NotSet:
            print("another_field 未设置，不更新。")
        else:
            print(f"another_field 设置为: {another_field}，执行更新。")

from types import EllipsisType

def partial_update_with_ellipsis(
   obj_field: int | None | EllipsisType = ...,
):
   if obj_field is ...:
       print("obj_field 未设置 (使用 Ellipsis)")
   else:
       print(f"obj_field 设置为: {obj_field}")

partial_update_with_ellipsis()
partial_update_with_ellipsis(None)
partial_update_with_ellipsis(10)

class NotSetType:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance

NotSet = NotSetType()

def partial_update_custom_singleton(
   obj_field: int | None | NotSetType = NotSet, # 注意这里是 NotSetType
):
   if obj_field is NotSet:
       print("obj_field 未设置 (自定义单例)")
   else:
       print(f"obj_field 设置为: {obj_field}")

partial_update_custom_singleton()
partial_update_custom_singleton(None)
partial_update_custom_singleton(20)

# 定义 NotSetType 类
class NotSetType:
    _instance = None # 用于存储单例实例

    def __new__(cls):
        """
        重写 __new__ 方法以确保只创建一个实例。
        """
        if cls._instance is None:
            # 如果实例不存在，则创建并存储
            cls._instance = super().__new__(cls)
        return cls._instance # 返回唯一的实例

    def __repr__(self):
        """
        为实例提供友好的字符串表示。
        """
        return "<NotSet>"

    def __str__(self):
        """
        为实例提供友好的字符串表示。
        """
        return "NotSet"

# 创建 NotSet 单例实例
NotSet = NotSetType()

# 示例应用
class UserProfile:
    def __init__(self, name: str, email: str | None = None):
        self.name = name
        self.email = email

    def update_profile(
            self,
            name: str | NotSetType = NotSet,
            email: str | None | NotSetType = NotSet
    ):
        """
        根据提供的参数更新用户资料。
        如果参数为 NotSet，则不更新对应字段。
        """
        if name is not NotSet:
            self.name = name
            print(f"更新姓名: {self.name}")

        if email is not NotSet:
            self.email = email
            print(f"更新邮箱: {self.email}")

        print(f"当前资料: Name={self.name}, Email={self.email}")

# 使用示例
user = UserProfile("Alice", "alice@example.com")
print("--- 初始资料 ---")
print(f"Name: {user.name}, Email: {user.email}")

print("\n--- 第一次更新 (只更新姓名) ---")
user.update_profile(name="Alicia")

print("\n--- 第二次更新 (更新邮箱为 None) ---")
user.update_profile(email=None)

print("\n--- 第三次更新 (同时更新姓名和邮箱) ---")
user.update_profile(name="Bob", email="bob@example.com")

print("\n--- 第四次更新 (不提供任何参数) ---")
user.update_profile()

# 验证 NotSet 的单例特性
assert NotSet is NotSetType()
print(f"\nNotSet 的类型是: {type(NotSet)}")
print(f"NotSet 的值是: {NotSet}")

class Meta(type):
    """
    自定义元类，用于创建一个类，使其在创建时返回其自身的一个实例。
    """
    def __new__(cls, name, bases, dct):
        # 调用父类 (type) 的 __new__ 来创建 NotSet 类本身
        actual_class = super().__new__(cls, name, bases, dct)
        # 然后，通过调用刚刚创建的类 (actual_class) 来获取它的一个实例
        # 这里的 actual_class() 会调用 NotSet 类的 __new__ 方法
        # 如果 NotSet 类没有自定义 __new__，则会调用 type 的 __new__
        # 关键在于，我们返回的是这个类的“实例”，而这个“实例”就是这个类本身
        return actual_class() # 返回 NotSet 类的实例

class NotSet(type, metaclass=Meta):
    """
    使用 Meta 元类创建的 NotSet 类。
    它的行为使得 NotSet 既是类型又是其自身的实例。
    """
    def __new__(cls):
        # 确保 NotSet 也是一个单例，尽管 Meta 元类已经处理了大部分
        if not hasattr(cls, '_instance'):
            cls._instance = super().__new__(cls)
        return cls._instance

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

    def __str__(self):
        return "NotSet"

# 验证 NotSet 的特殊行为
print(f"NotSet: {NotSet}")
print(f"type(NotSet): {type(NotSet)}")
print(f"NotSet is type(NotSet): {NotSet is type(NotSet)}") # 预期为 True

# 示例应用 (与之前的 partial_update 类似)
def partial_update_metaclass(
   obj_id: int,
   obj_field: int | None | NotSet = NotSet, # 现在 NotSet 可以直接作为类型提示
):
    if obj_field is NotSet:
        print('obj_field 未设置 (元类实现)')
    else:
        print(f'obj_field 设置为: {obj_field}')

partial_update_metaclass(1)
partial_update_metaclass(1, None)
partial_update_metaclass(1, 42)

class Client:
    def __init__(self, initial_obj_id: int):
        self.obj_id = initial_obj_id
        self.obj_field = None
        self.another_field = "default"

    def partial_update_kwargs(self, **kwargs):
        """
        使用 **kwargs 更新对象属性。
        """
        print(f"--- 更新前: obj_id={self.obj_id}, obj_field={self.obj_field}, another_field={self.another_field} ---")
        for field, value in kwargs.items():
            if hasattr(self, field):
                setattr(self, field, value)
                print(f"更新字段 '{field}' 为: {value}")
            else:
                print(f"警告: 字段 '{field}' 不存在。")
        print(f"--- 更新后: obj_id={self.obj_id}, obj_field={self.obj_field}, another_field={self.another_field} ---")

# 使用示例
client_instance = Client(100)
client_instance.partial_update_kwargs(obj_field=50)
client_instance.partial_update_kwargs(another_field="new_value", obj_field=None)
client_instance.partial_update_kwargs() # 不提供任何参数，不更新