Skip to content

Effortlessly Implement Hash Tables in Python


Build a Hash Table in Python With TDD

Invented over half a century ago, the hash table is a classic data structure that has been fundamental to programming. To this day, it helps solve many real-life problems, such as indexing database tables, caching computed values, or implementing sets. It often comes up in job interviews, and Python uses hash tables all over the place to make name lookups almost instantaneous.

Even though Python comes with its own hash table called dict, it can be helpful to understand how hash tables work behind the curtain. A coding assessment may even task you with building one. This tutorial will walk you through the steps of implementing a hash table from scratch as if there were none in Python. Along the way, you’ll face a few challenges that’ll introduce important concepts and give you an idea of why hash tables are so fast.

In addition to this, you’ll get a hands-on crash course in test-driven development (TDD) and will actively practice it while building your hash table in a step-by-step fashion. You’re not required to have any prior experience with TDD, but at the same time, you won’t get bored even if you do!

In this tutorial, you’ll learn:

  • How a hash table differs from a dictionary
  • How you can implement a hash table from scratch in Python
  • How you can deal with hash collisions and other challenges
  • What the desired properties of a hash function are
  • How Python’s hash() works behind the scenes

Get to Know the Hash Table Data Structure

Hash Table vs Dictionary

A dictionary in Python is a built-in data structure that uses a hash table under the hood. However, understanding the core concepts of a hash table will help you have a deeper understanding of dictionaries and how they work.

Hash Table: An Array With a Hash Function

At its core, a hash table is an array that uses a hash function to map keys to indices in the array. This allows for constant-time (O(1)) operations for key-value access, insertion, and deletion.

Understand the Hash Function

A hash function is a fundamental part of the hash table. It takes an input (the key) and returns an index in the array where the corresponding value will be stored.

Examine Python’s Built-in hash()

Python provides a built-in hash() function that can be used to generate hash values for many types of objects. Understanding how this function works will give you insights into the underlying mechanics of hash tables in Python.

Dive Deeper Into Python’s hash()

Going beyond the surface, you’ll explore the inner workings of the hash() function and understand how it handles various types of objects.

Identify Hash Function Properties

A good hash function has certain properties that make it effective. You’ll learn about these properties and why they are important for the efficient operation of hash tables.

Compare an Object’s Identity With Its Hash

You’ll see how an object’s identity (memory address) is different from its hash value and why it’s crucial to consider this distinction when implementing a hash table.

Make Your Own Hash Function

Building upon your understanding of hash functions, you’ll take on the task of creating your own hash function tailored to the specific needs of your hash table implementation.

Build a Hash Table Prototype in Python With TDD

In this section, you’ll dive into building a hash table from scratch using a test-driven development approach. This ensures that each component of the hash table is thoroughly tested and functioning correctly.

Take a Crash Course in Test-Driven Development

You’ll be introduced to the principles and workflow of test-driven development (TDD) and understand its benefits when building complex systems like a hash table.

Define a Custom HashTable Class

You’ll start by defining the foundation for your hash table: the HashTable class. This class will contain all the necessary methods for keys insertion, deletion, and retrieval.

Insert a Key-Value Pair

You’ll implement the method that allows inserting key-value pairs into the hash table.

Find a Value by Key

Using the hash function and indexing, you’ll learn how to retrieve the value stored at a specific key in the hash table.

Delete a Key-Value Pair

The method for deleting a key-value pair from the hash table will be implemented, taking into account possible collisions and other edge cases.

Update the Value of an Existing Pair

You’ll learn how to update the value associated with a given key in the hash table.

Get the Key-Value Pairs

You’ll implement a method to retrieve all the key-value pairs stored in the hash table.

Use Defensive Copying

To ensure data integrity, you’ll explore the concept of defensive copying and see how it can be applied to hash table operations.

Get the Keys and Values

Two separate methods will be implemented to retrieve the keys and values stored in the hash table.

Report the Hash Table’s Length

You’ll create a method to calculate and return the length of the hash table, i.e., the number of key-value pairs it contains.

Make the Hash Table Iterable

To enable using the hash table in loops and comprehensions, you’ll implement the necessary methods to make it iterable.

Represent the Hash Table in Text

You’ll learn how to create a textual representation of the hash table, making it easier to visualize and debug.

Test the Equality of Hash Tables

You’ll see how to compare two hash tables for equality and implement the necessary methods to ensure accurate comparison.

Resolve Hash Code Collisions

Hash collisions occur when different keys produce the same hash value. In this section, you’ll learn different strategies for resolving collisions.

Find Collided Keys Through Linear Probing

Using the technique of linear probing, you’ll understand how to handle hash collisions by searching for the next available index in the array.

Use Linear Probing in the HashTable Class

You’ll modify the HashTable class to incorporate linear probing for handling hash collisions.

Let the Hash Table Resize Automatically

To maintain a balanced load factor and prevent performance degradation, you’ll add a dynamic resizing mechanism to the hash table.

Calculate the Load Factor

You’ll explore the concept of the load factor and learn how to calculate it to determine the efficiency of the hash table.

Isolate Collided Keys With Separate Chaining

Using separate chaining, you’ll understand how to handle collisions by storing multiple values with the same hash in linked lists.

Retain Insertion Order in a Hash Table

In Python 3.7 and later, dictionaries maintain the order of key-value pairs. You’ll learn how to modify your hash table implementation to preserve the order of key insertions.

Use Hashable Keys

Not all objects can be used as keys in a hash table. You’ll understand the concept of hashability and its importance for the proper functioning of hash tables.

Hashability vs Immutability

You’ll explore the relationship between hashability and immutability and understand how they affect the ability to hash an object.

The Hash-Equal Contract

You’ll learn about the hash-equal contract and how it ensures consistency and correctness when working with hashable objects.


By the end of this tutorial, you’ll have a deep understanding of hash tables and how they work in Python. You’ll have built a hash table from scratch using test-driven development, and you’ll be equipped with the knowledge to handle hash collisions and create efficient hash functions. Understanding hash tables will help you become a better Python programmer and tackle complex programming problems more effectively.