抽象集合

class Array:
    def __init__(self, size=8, init=None):
        self._size = size
        self._items = [init] * size

    def __getitem__(self, index):
        return self._items[index]

    def __setitem__(self, key, value):
        self._items[key] = value

    def __len__(self):
        return self._size

    def clear(self, value=None):
        for i in range(len(self._items)):
            self._items[i] = value

    def __iter__(self):
        for i in self._items:
            yield i


class Slot(object):
    def __init__(self, key, value, time=None):
        self.key, self.value, self.time = key, value, time


class Hashtable:
    UNUSED = None
    EMPTY = Slot(None, None)

    def __init__(self):
        self._table = Array(8, Hashtable.UNUSED)
        self.length = 0

    def __len__(self):
        return self.length

    def _hash(self, key, M=13):
        if self.length >= 0.8 * len(self._table):
            self.rehash(len(self._table))
        index = hash(key) % M

        i = 1
        while True:
            while index >= len(self._table):
                self.rehash(len(self._table))

            if self._table[index] is not None:
                if self._table[index].key == key:
                    self.length -= 1
                    return index

            if self._table[index] is not None and self._table[index] != Hashtable.EMPTY:
                index = (index + i * i) % M
                i += 1
            else:
                return index

    def find_key(self, key):
        for index, i in enumerate(self._table):
            if i != Hashtable.EMPTY and i != Hashtable.UNUSED:
                if i.key == key:
                    return index
        return False

    def rehash(self, length):
        old_table = self._table
        self._table = Array(length * 2, Hashtable.UNUSED)
        for index, obj in enumerate(old_table, 0):
            self._table[index] = obj

    def add(self, key, value, time=None):
        index = self._hash(key)
        self._table[index] = Slot(key, value, time)
        self.length += 1

    def __iter__(self):
        for obj in self._table:
            if obj != Hashtable.UNUSED and obj != Hashtable.EMPTY:
                yield obj.key

    def remove(self, key):
        index = self.find_key(key)
        if not index:
            raise NameError
        self._table[index] = Hashtable.EMPTY
        self.length -= 1

    def clear(self):
        self.length = 0
        self._table = Array(8, Hashtable.UNUSED)


class Hash_Set(Hashtable):
    def __init__(self):
        super().__init__()

    def add(self,key):
        super().add(key,True)

    def __and__(self, other):
        new_set=Hash_Set()
        for k in other:
            if k in self:
                new_set.add(k)
        return new_set

    def __or__(self, other):
        new_set = Hash_Set()
        for k in other:
            new_set.add(k)
        for k in self:
            new_set.add(k)
        return new_set

    def __sub__(self, other):
        new_set = Hash_Set()
        for k in self:
            if k not in other:
                new_set.add(k)
        return new_set

    def __xor__(self, other):
        new_set = Hash_Set()
        for k in self:
            if k not in other:
                new_set.add(k)
        for k in other:
            if k not in self:
                new_set.add(k)
        return new_set


a=Hash_Set()
a.add(1)
a.add(2)
a.add(3)
a.add(4)

b=Hash_Set()
b.add(3)
b.add(4)
b.add(5)

print('交集')
for k in a & b:
    print(k)

print('合集')
for k in a | b:
    print(k)

print('差集')
for k in a - b:
    print(k)

print('交叉补')
for k in a ^ b:
    print(k)