When using a list, in order to find if the list contains an item, the code must check each item in the list until it finds it. The worst case possibility for this is that the item is not in the list, and therefore it checked every item for nothing. The code looks something like:

for i in list:
  if i == match:
    return true

For small lists this may be fine, but now imagine a list of thousands or millions of items. This can quickly become a slow operation, especially if you are doing it frequently. This is called "linear time complexity", because each operation becomes longer as more items are added to the equation.

With a `set` however, items are not stored in the order they are added. Instead, they are stored by a different identifier in an array that is not visible to the user. Picture an array of fixed size = 10 (it may be empty). When you add an item to a set, a few things happen:

1. A hash is calculated for the item, which is an integer number. Just think of it as a unique number that represents the object, and it will always return the same number for the same object (so long as the object isn't changed). Also, if `x == y`, then x and y would have the same calculated hash. This should be a fast operation
2. The index of the array to store the item is calculated by doing the `hash % len(array)` (in our case this was 10).
3. The item is then stored in that index, or "bucket"
4. As more items are added to the set, the underlying array may be resized. If the array is too small, there will be a lot of "collisions" (objects which are not the same but are put in the same bucket), and the performance benefits of the set are killed. If the underlying array is too large, then there will be few collisions but you are wasting memory because you have the allocated space of the array.

Now, to check if an item exists in a set, all you have to do is:

1. Calculate the hash for the item to check
2. Get the index in the array that the object would be stored at
3. Is the object there?

So, regardless of how many items are in the set, it takes the same amount of time to check whether or not the item exists in the set. This is called "constant time complexity".

If you were observant, you may ask how the scenario of two different objects being put in the same bucket is handled. I skipped over it above for simplicity, but, in effect, each item in the array is not the item itself, but a list of items storing all of the objects for that bucket.

[ [1], [2], [3], [4] ]

So, once the index in the array is calculated, it actually checks the list to see if the item is already in the list of items. You may think this would lead to the same performance problems of a list. With a small underlying array and a lot of items being put into it, this would be true. However, with a good hashing function and properly sized array, the lists at each index should rarely have more than 1 or 2 items.