While Python doesn't have a built-in data structure explicitly called a *"hash table"*, it provides the *dictionary*, which is a form of a hash table. Python dictionaries are unordered collections of *key-value pairs*, where the key is unique and holds a corresponding value. Thanks to a process known as *"hashing"*, dictionaries enable efficient retrieval, addition, and removal of entries.

**Note:** If you're a Python programmer and have ever used a dictionary to store data as key-value pairs, you've already benefited from hash table technology without necessarily knowing it! **Python dictionaries are implemented using hash tables!**

**Link:** You can read more about dictionaries in Python in our "Guide to Dictionaries in Python".

In this guide, we'll delve into the world of hash tables. We'll start with the basics, explaining what hash tables are and how they work. We'll also explore Python's implementation of hash tables via dictionaries, provide a step-by-step guide to creating a hash table in Python, and even touch on how to handle hash collisions. Along the way, we'll demonstrate the utility and efficiency of hash tables with real-world examples and handy Python snippets.

### Defining Hash Tables: Key-Value Pair Data Structure

Since dictionaries in Python are essentially an implementation of hash tables, let's first focus on what hash tables actually are, and dive into Python implementation afterward.

Hash tables are a type of data structure that provides a mechanism to store data in an *associative manner*. In a hash table, data is stored in an *array format*, but each data value has its own *unique key*, which is used to identify the data. This mechanism is based on key-value pairs, making the retrieval of data a swift process.

The analogy often used to explain this concept is a real-world dictionary. In a dictionary, you use a known word (the "key") to find its meaning (the "value"). If you know the word, you can quickly find its definition. Similarly, in a hash table, if you know the key, you can quickly retrieve its value.

Essentially, we are trying to store key-value pairs in the most efficient way possible.

For example, say we want to create a hash table that stores the birth month of various people. The people's names are our keys and their birth months are the values:

```
+-----------------------+
| Key | Value |
+-----------------------+
| Alice | January |
| Bob | May |
| Charlie | January |
| David | August |
| Eve | December |
| Brian | May |
+-----------------------+
```

To store these key-value pairs in a hash table, we'll first need a way to convert the value of keys to the appropriate indexes of the array that represents a hash table. That's where a **hash function** comes into play! Being the backbone of a hash table implementation, this function processes the key and returns the corresponding index in the data storage array - just as we need.

The goal of a

good hash functionis to distribute the keys evenly across the array, minimizing the chance of collisions (where two keys produce the same index).

In reality, hash functions are much more complex, but for simplicity, let's use a hash function that maps each name to an index by taking the ASCII value of the first letter of the name modulo the size of the table:

```
def simple_hash(key, array_size):
return ord(key[0]) % array_size
```

This hash function is *simple*, but it *could lead to collisions* because different keys might start with the same letter and hence the resulting indices will be the same. For example, say our array has the size of `10`

, running the `simple_hash(key, 10)`

for each of our keys will give us:

Alternatively, we can reshape this data in a more concise way:

```
+---------------------+
| Key | Index |
+---------------------+
| Alice | 5 |
| Bob | 6 |
| Charlie | 7 |
| David | 8 |
| Eve | 9 |
| Brian | 6 |
+---------------------+
```

Here, `Bob`

and `Brian`

have the same index in the resulting array, which results in *a collision*. We'll talk more about collisions in the latter sections - both in terms of creating hash functions that minimize the chance of collisions and resolving collisions when they occur.

Designing robust hash functions is one of the most important aspects of hash table efficiency!

**Note:** In Python, dictionaries are an implementation of a hash table, where the keys are hashed, and the resulting hash value determines where in the dictionary's underlying data storage the corresponding value is placed.

In the following sections, we'll dive deeper into the inner workings of hash tables, discussing their operations, potential issues (like collisions), and solutions to these problems.

### Demystifying the Role of Hash Functions in Hash Tables

Hash functions are the *heart and soul* of hash tables. They serve as a bridge between the keys and their associated values, providing a means of efficiently storing and retrieving data. Understanding the role of hash functions in hash tables is crucial to grasp how this powerful data structure operates.

#### What is a Hash Function?

In the context of hash tables, a hash function is a special function that takes a *key as input* and *returns an index* which the corresponding value should be stored or retrieved from. It transforms the key into a * hash* - a number that corresponds to an index in the array that forms the underlying structure of the hash table.

The hash function needs to be * deterministic*, meaning that it should always produce the same hash for the same key. This way, whenever you want to retrieve a value, you can use the hash function on the key to find out where the value is stored.

#### The Role of Hash Functions in Hash Tables

The main objective of a hash function in a hash table is to distribute the keys *as uniformly as possible* across the array. This is important because the uniform distribution of keys allows for a constant time complexity of *O(1)* for data operations such as insertions, deletions, and retrievals *on average*.

**Link:** You can read more about the Big-O notation in our article "Big O Notation and Algorithm Analysis with Python Examples".

To illustrate how a hash function works in a hash table, let's again take a look at the example from the previous section:

```
+-----------------------+
| Key | Value |
+-----------------------+
| Alice | January |
| Bob | May |
| Charlie | January |
| David | August |
| Eve | December |
| Brian | May |
+-----------------------+
```

As before, assume we have a hash function, `simple_hash(key)`

, and a hash table of size `10`

.

As we've seen before, running, say, `"Alice"`

through the `simple_hash()`

function returns the index `5`

. That means we can find the element with the key `"Alice"`

and the value `"January"`

in the array representing the hash table, on the index `5`

(6th element of that array):

And that applies to each key of our original data. Running each key through the hash function will give us the integer value - an index in the hash table array where that element is stored:

```
+---------------------+
| Key | Index |
+---------------------+
| Alice | 5 |
| Bob | 6 |
| Charlie | 7 |
| David | 8 |
| Eve | 9 |
| Brian | 6 |
+---------------------+
```

This can easily translate to the array representing a hash table - an element with the key `"Alice"`

will be stored under index `5`

, `"Bob"`

under index `6`

, and so on:

**Note:** Under the index `6`

there are two elements - `{"Bob", "February"}`

and `{"Brian", "May"}`

. In the illustration above, that collision was solved using the method called *separate chaining*, which we'll talk about more later in this article.

When we want to retrieve the value associated with the key `"Alice"`

, we again pass the key to the hash function, which returns the index `5`

. We then immediately access the value at index `3`

of the hash table, which is `"January"`

.

#### Challenges with Hash Functions

While the idea behind hash functions is fairly straightforward, **designing a good hash function can be challenging**. A primary concern is what's known as a *collision*, which occurs when two different keys hash to the same index in the array.

Just take a look at the

`"Bob"`

and`"Brian"`

keys in our example. They have the same index, meaning they are stored in the same place in the hash table array. In its essence, this is an example of a hashing collision.

The likelihood of *collisions* is dictated by the hash function and the size of the hash table. While it's virtually impossible to completely avoid collisions for any non-trivial amount of data, a good hash function coupled with an appropriately sized hash table will minimize the chances of collisions.

Different strategies such as *open addressing* and *separate chaining* can be used to resolve collisions when they occur, which we'll cover in a later section.

### Analyzing Time Complexity of Hash Tables: A Comparison

One of the key benefits of using hash tables, which sets them apart from many other data structures, is their time complexity for basic operations. Time complexity is a computational concept that refers to the amount of time an operation or a function takes to run, as a function of the size of the input to the program.

When discussing time complexity, we generally refer to three cases:

**Best Case:**The minimum time required for executing an operation.**Average Case:**The average time needed for executing an operation.**Worst Case:**The maximum time needed for executing an operation.

Hash tables are especially noteworthy for their *impressive time complexity in the average case scenario*. In that scenario, basic operations in hash tables (inserting, deleting, and accessing elements) have a

**constant time complexity of O(1)**.

The constant time complexity implies that the time taken to perform these operations remains constant, regardless of the number of elements in the hash table.

This makes these operations extremely efficient, especially when dealing with large datasets.

While the average case time complexity for hash tables is O(1), *the worst-case scenario is a different story*. If multiple keys hash to the same index (a situation known as a

*collision*), the time complexity can degrade to

**O(n)**, where

*n*is the number of keys mapped to the same index.

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually *learn* it!

This scenario occurs because, when resolving collisions, additional steps must be taken to store and retrieve data, typically by traversing a linked list of entries that hash to the same index.

**Note:** With a well-designed hash function and a correctly sized hash table, this worst-case scenario is generally the exception rather than the norm. A good hash function paired with appropriate collision resolution strategies can keep collisions to a minimum.

#### Comparing to Other Data Structures

When compared to other data structures, *hash tables stand out for their efficiency*. For instance, operations like search, insertion, and deletion in a balanced binary search tree or a balanced AVL Tree have a time complexity of *O(log n)*, which, although not bad, is not as efficient as the *O(1)* time complexity that hash tables offer in the average case.

While arrays and linked lists offer *O(1)* time complexity for some operations, they can't maintain this level of efficiency across all basic operations. For example, searching in an unsorted array or linked list takes *O(n)* time, and insertion in an array takes *O(n)* time in the worst case.

### Python's Approach to Hash Tables: An Introduction to Dictionaries

Python provides a built-in data structure that implements the functionality of a hash table called a dictionary, often referred to as a "dict". Dictionaries are one of Python's most powerful data structures, and understanding how they work can significantly boost your programming skills.

**Advice:** You can read a more comprehensive overview of dictionaries in Python in our "Guide to Dictionaries in Python".

#### What are Dictionaries?

In Python, dictionaries (dicts) are unordered collections of key-value pairs. Keys in a dictionary are unique and immutable, which means they can't be changed once they're set. This property is essential for the correct functioning of a hash table. Values, on the other hand, can be of any type and are mutable, meaning you can change them.

A key-value pair in a dictionary is also known as an item. Each key in a dictionary is associated (or mapped) to a single value, forming a key-value pair:

```
my_dict = {"Alice": "January", "Bob": "May", "Charlie": "January"}
```

#### How do Dictionaries Work in Python?

Behind the scenes, *Python's dictionaries operate as a hash table*. When you create a dictionary and add a key-value pair, Python applies a hash function to the key, which results in a hash value. This hash value then determines where in memory the corresponding value will be stored.

The beauty of this is that when you want to retrieve the value, Python applies the same hash function to the key, which rapidly guides Python to where the value is stored, regardless of the size of the dictionary:

```
my_dict = {}
my_dict["Alice"] = "January" # Hash function determines the location for "January"
print(my_dict["Alice"]) # "January"
```

#### Key Operations and Time Complexity

Python's built-in dictionary data structure makes performing basic hash table operations—such as insertions, access, and deletions a breeze. These operations typically have an average time complexity of O(1), making them remarkably efficient.

**Note:** As with hash tables, the worst-case time complexity can be *O(n)*, but this happens rarely, only when there are hash collisions.

**Inserting key-value pairs** into a Python dictionary is straightforward. You simply assign a value to a key using the assignment operator (`=`

). If the key doesn't already exist in the dictionary, it's added. If it does exist, its current value is replaced with the new value:

```
my_dict = {}
my_dict["Alice"] = "January"
my_dict["Bob"] = "May"
print(my_dict) # Outputs: {'Alice': 'January', 'Bob': 'May'}
```

**Accessing a value** in a Python dictionary is just as simple as inserting one. You can access the value associated with a particular key by referencing the key in square brackets. If you attempt to access a key that doesn't exist in the dictionary, Python will raise a `KeyError`

:

```
print(my_dict["Alice"]) # Outputs: Python
# Raises KeyError: 'Charlie'
print(my_dict["Charlie"])
```

To prevent this error, you can use the dictionary's `get()`

method, which allows you to return a default value if the key doesn't exist:

```
print(my_dict.get("Charlie", "Unknown")) # Outputs: Unknown
```

**Note:** Similarly, the `setdefault()`

method can be used to safely insert a key-value pair into the dictionary if the key doesn't already exist:

```
my_dict.setdefault("new_key", "default_value")
```

You can **remove a key-value pair** from a Python dictionary using the `del`

keyword. If the key exists in the dictionary, it's removed along with its value. If the key doesn't exist, Python will also raise a `KeyError`

:

```
del my_dict["Bob"]
print(my_dict) # Outputs: {'Alice': 'January'}
# Raises KeyError: 'Bob'
del my_dict["Bob"]
```

Like with access, if you want to prevent an error when trying to delete a key that doesn't exist, you can use the dictionary's `pop()`

method, which removes a key, returns its value if it exists, and returns a default value if it doesn't:

```
print(my_dict.pop("Bob", "Unknown")) # Outputs: Unknown
```

All-in-all, Python dictionaries serve as a high-level, user-friendly implementation of a hash table. They are easy to use, yet powerful and efficient, making them an excellent tool for handling a wide variety of programming tasks.

**Advice:** If you're testing for membership (i.e., whether an item is in a collection), a dictionary (or a set) is often a more efficient choice than a list or a tuple, especially for larger collections. That's because dictionaries and sets use hash tables, which allow them to test for membership in constant time (*O(1)*), as opposed to lists or tuples, which take linear time (*O(n)*).

In the next sections, we will dive deeper into the practical aspects of using dictionaries in Python, including creating dictionaries (hash tables), performing operations, and handling collisions.

### How to Create Your First Hash Table in Python

Python's dictionaries provide a ready-made implementation of hash tables, allowing you to store and retrieve key-value pairs with excellent efficiency. However, to understand hash tables thoroughly, it can be beneficial to implement one from scratch. In this section, we'll guide you through creating a simple hash table in Python.

We'll start by defining a `HashTable`

class. The hash table will be represented by a list (the `table`

), and we will use a very simple hash function that calculates the remainder of the ASCII value of the key string's first character divided by the size of the table:

```
class HashTable:
def __init__(self, size):
self.size = size
self.table = [None]*size
def _hash(self, key):
return ord(key[0]) % self.size
```

In this class, we have the `__init__()`

method to initialize the hash table, and a `_hash()`

method, which is our simple hash function.

Now, we'll add methods to our `HashTable`

class for adding key-value pairs, getting values by key, and removing entries:

```
class HashTable:
def __init__(self, size):
self.size = size
self.table = [None]*size
def _hash(self, key):
return ord(key[0]) % self.size
def set(self, key, value):
hash_index = self._hash(key)
self.table[hash_index] = (key, value)
def get(self, key):
hash_index = self._hash(key)
if self.table[hash_index] is not None:
return self.table[hash_index][1]
raise KeyError(f'Key {key} not found')
def remove(self, key):
hash_index = self._hash(key)
if self.table[hash_index] is not None:
self.table[hash_index] = None
else:
raise KeyError(f'Key {key} not found')
```

The `set()`

method adds a key-value pair to the table, while the `get()`

method retrieves a value by its key. The `remove()`

method deletes a key-value pair from the hash table.

**Note:** If the key doesn't exist, the `get`

and `remove`

methods raise a `KeyError`

.

Now, we can create a hash table and use it to store and retrieve data:

```
# Create a hash table of size 10
hash_table = HashTable(10)
# Add some key-value pairs
hash_table.set('Alice', 'January')
hash_table.set('Bob', 'May')
# Retrieve a value
print(hash_table.get('Alice')) # Outputs: 'January'
# Remove a key-value pair
hash_table.remove('Bob')
# This will raise a KeyError, as 'Bob' was removed
print(hash_table.get('Bob'))
```

**Note:** The above hash table implementation is quite simple and does not handle hash collisions. In real-world use, you'd need a more sophisticated hash function and collision resolution strategy.

### Resolving Collisions in Python Hash Tables

Hash collisions are an inevitable part of using hash tables. A hash collision occurs when two different keys hash to the same index in the hash table. As Python dictionaries are an implementation of hash tables, they also need a way to handle these collisions.

Python's built-in hash table implementation uses a method called * "open addressing"* to handle hash collisions. However, to better understand the collision resolution process, let's discuss a simpler method called

*.*

**"separate chaining"**#### Separate Chaining

Separate chaining is a collision resolution method in which each slot in the hash table holds a linked list of key-value pairs. When a collision occurs (i.e., two keys hash to the same index), the key-value pair is simply appended to the end of the linked list at the colliding index.

Remember, we had a collision in our example because both `"Bob"`

and `"Brian"`

had the same index - `6`

. Let's use that example to illustrate the mechanism behind separate chaining. If we were to assume that the `"Bob"`

element was added to the hash table first, we'd run into the problem when trying to store the `"Brian"`

element since the index `6`

was already taken.

Solving this situation using separate chaining would include adding the `"Brian"`

element as the second element of the linked list assigned to index `6`

(the `"Bob"`

element is the first element of that list). And that's all there is to it, just as shown in the following illustration:

Here's how we might modify our `HashTable`

class from the previous example to use separate chaining:

```
class HashTable:
def __init__(self, size):
self.size = size
self.table = [[] for _ in range(size)]
def _hash(self, key):
return ord(key[0]) % self.size
def set(self, key, value):
hash_index = self._hash(key)
for kvp in self.table[hash_index]:
if kvp[0] == key:
kvp[1] = value
return
self.table[hash_index].append([key, value])
def get(self, key):
hash_index = self._hash(key)
for kvp in self.table[hash_index]:
if kvp[0] == key:
return kvp[1]
raise KeyError(f'Key {key} not found')
def remove(self, key):
hash_index = self._hash(key)
for i, kvp in enumerate(self.table[hash_index]):
if kvp[0] == key:
self.table[hash_index].pop(i)
return
raise KeyError(f'Key {key} not found')
```

In this updated implementation, the `table`

is initialized as a list of empty lists (i.e., each slot is an empty linked list). In the `set()`

method, we iterate over the linked list at the hashed index, updating the value if the key already exists. If it doesn't, we append a new key-value pair to the list.

The `get()`

and `remove()`

methods also need to iterate over the linked list at the hashed index to find the key they're looking for.

While this approach solves the problem of collisions, it does lead to an increase in time complexity when collisions are frequent.

#### Open Addressing

The method used by Python dictionaries to handle collisions is more sophisticated than separate chaining. Python uses a form of open addressing called * "probing"*.

In probing, when a collision occurs, the hash table checks the next available slot and places the key-value pair there instead. The process of finding the next available slot is called "probing", and several strategies can be used, such as:

*Linear probing*- checking one slot at a time in order*Quadratic probing*- checking slots in increasing powers of two

**Note:** The specific method Python uses is more complex than any of these, but it ensures that lookups, insertions, and deletions remain close to *O(1)* time complexity even in cases where collisions are frequent.

Let's just take a quick look at the collision example from the previous section, and show how would we treat it using the open addressing method. Say we have a hash table with only one element - `{"Bob", "May"}`

on the index number `6`

. Now, we wouldn't be able to add the `"Brian"`

element to the hash table due to the collision. But, the mechanism of linear probing tells us to store it in the first empty index - `7`

. That's it, easy right?