Two keys can land in the same bucket. That's called a collision, and it's normal. The simplest fix is chaining: each bucket holds a short list of (key, value) pairs, and a lookup only searches that one list.

class HashTable:
    def __init__(self, size=8):
        self.buckets = [[] for _ in range(size)]

    def _bucket(self, key):
        return self.buckets[hash(key) % len(self.buckets)]

    def put(self, key, value):
        bucket = self._bucket(key)
        for i, (k, v) in enumerate(bucket):
            if k == key:
                bucket[i] = (key, value)
                return
        bucket.append((key, value))

    def get(self, key):
        for k, v in self._bucket(key):
            if k == key:
                return v
        raise KeyError(key)

table = HashTable()
table.put("ada", 36)
table.put("ben", 29)
table.put("ada", 37)
print(table.get("ada"), table.get("ben"))

As long as the buckets stay short, a lookup only checks a handful of pairs. Python's dictionaries make sure they do: when the table gets too full, they make a bigger one and move every key across. That's why dictionary and set lookups are O(1) on average.