哈希表删掉一个键，为什么后面的键也会突然查不到？

"""Fixed-capacity integer-key map teaching deletion, not Python dict internals."""
from itertools import product

EMPTY, DELETED = object(), object()


def require(condition, message):
    if not condition:
        raise AssertionError(message)


class LinearMap:
    def __init__(self, capacity):
        if type(capacity) is not int or capacity < 1:
            raise ValueError("positive integer capacity required")
        self.slots = [EMPTY] * capacity

    def probes(self, key):
        if type(key) is not int:
            raise TypeError("integer keys required")
        for offset in range(len(self.slots)):
            yield (key + offset) % len(self.slots)

    def get(self, key):
        for index in self.probes(key):
            slot = self.slots[index]
            if slot is EMPTY:
                break
            if slot is not DELETED and slot[0] == key:
                return slot[1]
        raise KeyError(key)

    def put(self, key, value):
        first_deleted = None
        for index in self.probes(key):
            slot = self.slots[index]
            if slot is DELETED:
                if first_deleted is None:
                    first_deleted = index
            elif slot is EMPTY:
                target = index if first_deleted is None else first_deleted
                self.slots[target] = (key, value)
                return
            elif slot[0] == key:
                self.slots[index] = (key, value)
                return
        if first_deleted is not None:
            self.slots[first_deleted] = (key, value)
            return
        raise OverflowError("table is full")

    def delete(self, key):
        for index in self.probes(key):
            slot = self.slots[index]
            if slot is EMPTY:
                return False
            if slot is not DELETED and slot[0] == key:
                self.slots[index] = DELETED
                return True
        return False

    def items(self):
        return [slot for slot in self.slots if slot is not EMPTY and slot is not DELETED]

    def state(self):
        return ["EMPTY" if x is EMPTY else "DELETED" if x is DELETED
                else f"{x[0]}:{x[1]}" for x in self.slots]


def check_map(table, expected):
    items = table.items()
    require(len(items) == len(expected), "duplicate key or missing entry")
    require(dict(items) == expected, "contents differ from oracle")
    for key in (-3, 0, 3, 6, 9):
        try:
            value = table.get(key)
        except KeyError:
            require(key not in expected, "lost reachable key")
        else:
            require(key in expected and value == expected[key], "wrong lookup")


def main():
    table = LinearMap(5)
    for key, value in [(4, "A"), (9, "B"), (14, "C")]:
        table.put(key, value)
    print(f"insert={table.state()}")
    require(table.delete(9), "delete existing")
    print(f"delete9={table.state()}; get14={table.get(14)}")
    table.put(14, "C2")
    require(len(table.items()) == 2, "update must not create duplicate")
    print(f"update14={table.state()}")
    table.put(19, "D")
    print(f"insert19={table.state()}")
    full = LinearMap(3)
    for key in (0, 3, 6):
        full.put(key, str(key))
    full.delete(3)
    full.put(6, "updated")
    require(len(full.items()) == 2, "full-table update crosses tombstone")
    full.put(9, "reused")
    print(f"no_empty_slots={full.state()}")
    try:
        full.put(12, "overflow")
    except OverflowError:
        print("full_insert=OverflowError")
    else:
        raise AssertionError("full table accepted new key")
    require(not full.delete(12), "absent delete must terminate")
    for key in (0, 6, 9):
        full.delete(key)
    require(all(slot is DELETED for slot in full.slots), "all tombstones")
    full.put(-3, "negative")
    require(full.get(-3) == "negative", "negative key and all tombstones")
    print(f"all_deleted_then_insert={full.state()}")
    cases = 0
    actions = [(op, key) for op in ("put", "delete") for key in (0, 3, 6)]
    for length in range(6):
        for sequence in product(actions, repeat=length):
            current, expected = LinearMap(3), {}
            for step, (op, key) in enumerate(sequence):
                if op == "put":
                    current.put(key, step)
                    expected[key] = step
                else:
                    existed = key in expected
                    require(current.delete(key) == existed, "delete result")
                    expected.pop(key, None)
                check_map(current, expected)
            cases += 1
    print(f"oracle_sequences={cases}; maximum_length=5")
    print("PASS")


if __name__ == "__main__":
    main()