扩展 Python 内置类型：继承 int 和 list 的正确方法

摘要：在 Python 中直接子类化并重写内置类型（如 int 和 list）的行为是不被鼓励的，并且可能导致代码不稳定。本文解释了原因，并提供了一种使用包装类来实现类似功能的更安全、更符合 Python 惯例的方法。

尝试扩展 Python 的内置类型（如 int 和 list）可能会遇到一些意想不到的困难。例如，你可能希望为 int 或 list 添加自定义方法，如 toString()。然而，直接子类化这些内置类型并添加方法，然后期望所有 int 或 list 对象都具备这些方法，通常不会如你所愿。

class int(int):
     def __new__(cls, value): return super().__new__(cls, value)
     def toString(self) -> str: return str(self)

c = int(8)
d = 8

print(c.toString())
# print(d.toString())     # Error: 'int' object has no attribute 'toString'


class list(list):
     def __init__(self, li): super(list, self).__init__(li)
     def toString(self) -> str: return ' '.join(str(x) for x in self)

a = list([1,2,3])
b = [1,2,3]

print(a.toString())
# print(b.toString())   # Error: 'list' object has no attribute 'toString'

上述代码展示了尝试扩展 int 和 list 类型，并添加 toString() 方法的例子。然而，只有通过 int() 或 list() 构造函数创建的对象才能访问到 toString() 方法。直接赋值创建的对象（如 d = 8 或 b = [1, 2, 3]）仍然是原始的 int 或 list 类型，因此不具备 toString() 方法。

为什么不应该重写内置类型？

Python 的设计者有意不允许直接重写内置类型。这是为了保证代码的稳定性。如果 [1, 2, 3] 突然因为某些模块的导入而表现出不同的行为，这会破坏代码的可预测性。想象一下，如果所有 int 对象都具有了自定义的行为，这可能会导致各种意想不到的问题。

正确的姿势：使用包装类

在 Python 中，实现类似功能的更安全、更符合惯例的方法是使用包装类。创建一个新的类，该类包含一个 int 或 list 对象作为其属性，并提供自定义的方法来操作该对象。

class StringableInt:
    def __init__(self, value: int):
        self.value = value

    def to_string(self) -> str:
        return str(self.value)


class StringableList:
    def __init__(self, li: list):
        self.data = li

    def to_string(self) -> str:
        return ' '.join(str(x) for x in self.data)


c = StringableInt(8)
d = StringableList([1, 2, 3])

print(c.to_string())  # 输出: 8
print(d.to_string())  # 输出: 1 2 3

在这个例子中，StringableInt 和 StringableList 是包装类，它们分别包含一个 int 和 list 对象。to_string() 方法是这些类提供的自定义方法，用于将内部对象转换为字符串。

注意事项：

• 命名： 避免使用与内置类型相同的名称（例如 int 或 list）来命名你的包装类。这可以避免混淆。
• 方法名： 遵循 Python 的命名惯例，使用下划线分隔单词（例如 to_string 而不是 toString）。
• 类型注册： 如果你的包装类需要与某些类型检查或接口兼容，可以考虑使用 numbers.Integral.register(StringableInt) 进行注册。

总结：

虽然在 Python 中直接扩展内置类型可能很诱人，但使用包装类通常是更安全、更灵活的选择。这种方法避免了潜在的冲突和不稳定性，并允许你以一种更可控的方式添加自定义功能。 虽然有一些第三方库（如 extype）允许你扩展内置类型，但通常不建议这样做，除非你非常清楚自己在做什么，并充分了解潜在的风险。