Python不使用set和dict功能如何实现IntSet整数集合类？

底层使用Python内置list存储整数元素，全程规避set、dict的使用，插入元素前先做存在性校验保证集合内元素唯一，通过魔法方法实现和原生set一致的操作语法。

class IntSet:
    # 支持传入可迭代整数对象初始化集合
    def __init__(self, values=None):
        self._elements = []
        if values is not None:
            for v in values:
                if not isinstance(v, int):
                    raise TypeError("IntSet only supports integer elements")
                self.add(v)
    
    # 添加元素，重复元素自动忽略
    def add(self, value: int):
        if not isinstance(value, int):
            raise TypeError("Only integers can be added to IntSet")
        if value not in self._elements:
            self._elements.append(value)
    
    # 删除指定元素，元素不存在则抛出KeyError
    def remove(self, value: int):
        if value not in self._elements:
            raise KeyError(f"{value} not in IntSet")
        self._elements.remove(value)
    
    # 安全删除元素，元素不存在无任何操作
    def discard(self, value: int):
        if value in self._elements:
            self._elements.remove(value)
    
    # 清空集合所有元素
    def clear(self):
        self._elements = []
    
    # 支持in运算符判断元素是否存在
    def __contains__(self, value: int) -> bool:
        return value in self._elements
    
    # 支持len()函数获取集合元素数量
    def __len__(self) -> int:
        return len(self._elements)
    
    # 支持==运算符判断两个集合是否相等
    def __eq__(self, other) -> bool:
        if not isinstance(other, IntSet):
            return False
        return sorted(self._elements) == sorted(other._elements)
    
    # 支持|运算符求两个集合的并集
    def __or__(self, other: 'IntSet') -> 'IntSet':
        if not isinstance(other, IntSet):
            raise TypeError("Unsupported operand type for |")
        result = IntSet(self._elements)
        for v in other._elements:
            result.add(v)
        return result
    
    # 支持&运算符求两个集合的交集
    def __and__(self, other: 'IntSet') -> 'IntSet':
        if not isinstance(other, IntSet):
            raise TypeError("Unsupported operand type for &")
        result = IntSet()
        for v in self._elements:
            if v in other._elements:
                result.add(v)
        return result
    
    # 支持-运算符求两个集合的差集
    def __sub__(self, other: 'IntSet') -> 'IntSet':
        if not isinstance(other, IntSet):
            raise TypeError("Unsupported operand type for -")
        result = IntSet()
        for v in self._elements:
            if v not in other._elements:
                result.add(v)
        return result
    
    # 支持^运算符求两个集合的对称差集
    def __xor__(self, other: 'IntSet') -> 'IntSet':
        if not isinstance(other, IntSet):
            raise TypeError("Unsupported operand type for ^")
        return (self - other) | (other - self)
    
    # 打印集合时的格式化输出
    def __str__(self) -> str:
        return "{" + ", ".join(map(str, sorted(self._elements))) + "}"
    
    # repr场景下的格式化输出
    def __repr__(self) -> str:
        return f"IntSet({sorted(self._elements)})"

if __name__ == "__main__":
    # 初始化集合
    s1 = IntSet([1,2,3,4])
    s2 = IntSet([3,4,5,6])

    print(s1) # 输出 {1, 2, 3, 4}
    print(s2) # 输出 {3, 4, 5, 6}

    # 新增元素
    s1.add(7)
    print(s1) # 输出 {1, 2, 3, 4, 7}

    # 删除元素
    s1.remove(1)
    print(s1) # 输出 {2, 3, 4, 7}

    # 成员判断、长度获取
    print(3 in s1) # 输出 True
    print(len(s1)) # 输出 4

    # 集合运算
    print(s1 | s2) # 并集：{2, 3, 4, 5, 6, 7}
    print(s1 & s2) # 交集：{3, 4}
    print(s1 - s2) # 差集：{2, 7}
    print(s1 ^ s2) # 对称差集：{2, 5, 6, 7}

• 所有写入操作均会校验元素类型，严格限制仅整数可存入集合
• 实现了运算符重载，操作逻辑和语法和Python原生set完全对齐
• 输出默认对元素排序，符合常规集合的展示习惯
• 仅使用list作为底层存储，完全符合禁用set、dict的要求

内容的提问来源于stack exchange，提问作者Κλεομενης Μανουσαριδης