just tiff me logo

Cracking the Code: Enhancing Python Performance with Dictionaries and Sets!

dict vs set

Table of Contents

In Python, we have two essential tools: dictionaries and sets. Dictionaries are like phone books, helping us quickly find information by a name (key). Sets, on the other hand, are like unique lists, handy for keeping a list of distinct items.
Let’s explore these two tools, see how they work, and when to use each one in our Python programs.

Understanding Dictionaries and Sets

Before delving into performance and memory comparisons, let’s grasp the fundamentals of dictionaries and sets.


  • A dictionary is a collection of key-value pairs.
  • Each key is unique and associated with a value.
  • In Python versions before 3.7, dictionaries are unordered collections. Starting from Python 3.7, dictionaries maintain the insertion order as well.
  • Dictionaries are implemented using a hash table, which allows for fast retrieval of values based on their keys. This makes dictionary lookups very efficient, typically O(1) on average, regardless of the size of the dictionary.
Think of a dictionary like, well, a real dictionary. In a real dictionary, you look up a word and find its meaning. In programming, you look up a “key” (like a word) and get a “value” (like a meaning).
So, if you want to find John Doe’s phone number, you just look up “John Doe” and you’ll get his phone number directly! No need to go through the entire list.
					# Creating a dictionary of names and phone numbers
phone_book = {
    "John Doe": "123-456-7890",
    "Jane Smith": "987-654-3210",
    # ...more entries

# Looking up John Doe's phone number
johns_number = phone_book["John Doe"]
print(johns_number)  # Output: 123-456-7890


  • A set is a collection of unique elements.
  • Sets, like dictionaries, were unordered before Python 3.7, but since Python 3.7, they also maintain the insertion order.
  • Sets are also implemented using a hash table for fast membership tests (checking if an element is in the set). Like dictionary lookups, set membership tests are also typically O(1) on average.
  • Sets are particularly useful when you need to maintain a collection of distinct items and perform operations like intersection, union, and difference between sets.
					# Creating a set of favorite fruits
my_fruits = {"apple", "banana", "orange"}

# Checking if "banana" is in the set
print("banana" in muy_fruits) # output: True

Understanding Hash Table

Behind the scenes, both dictionaries and set use a trick called a “hash table.”

Hash Tables

Think of hash tables as super-smart organizers. They use a trick called a “hash function.” This function takes a name or some data (like a key) and turns it into a secret code (like a magical index). This code acts like a map that shows exactly where your data is stored. So, when you want to find something, you just follow the map directly to the right spot!
Example: Imagine turning names into special codes like “John” becomes “399” and “Jane” becomes “382.” These codes help you find stuff super quickly.
					# Hash function example: turning names into codes
def hash_function(name):
    code = 0
    for char in name:
        code += ord(char)  # Turning characters into numbers
    return code

john_hash = hash_function("John")
jane_hash = hash_function("Jane")
Hash value of John: 74 + 111 + 104 + 110 = 399
Hash value of Jane: 74 + 97 + 110 + 101 = 382

How does hash table work?

To create a hash table from scratch, we start with some allocated memory, similar to what we started with for arrays. For an array, if we want to insert data, we simply find the smallest unused bucket and insert our data there (and resize if necessary). For hash tables, we must first figure out the placement of the data in this contiguous chunk of memory.

1. Allocating Memory

When we build a hash table from scratch, we begin by setting aside a specific chunk of memory, just like when we create an array. This chunk of memory will be used to store our data in an organized way.
With arrays, when we want to add data, we find an empty slot and put the data there. It’s like placing books on empty shelves in a bookshelf. But for hash tables, it’s a bit different. We need to figure out where to put data in this chunk of memory.

2. Placement of Data

For hash tables, it’s not as simple as just finding an empty slot. We need to be smarter about where we put our data. It’s like if you have a bunch of puzzle pieces and you need to fit them together in a specific way.
When we add new data to a hash table, we have to consider two things: the special code we get from the hash function (called the hashed value) and how the data compares to other data. These two things help us decide where the data should go in the memory.
Example: Imagine you have different sizes of toy boxes and you need to fit them into a storage space. You can’t just put them randomly; you need to figure out the best way to arrange them.

3. Hashing and Masking

The first thing we do is take the key (like a name or word) and run it through a hash function. This gives us a unique number, our “magic code.”
But, this code could be really big, and we need to fit it within the space we have allocated for the hash table.
To fit the code in our allocated space, we use a special trick called a mask. The mask sets a limit on how big the code can be.
Now that our code fits within the space, we need to find the right spot in the hash table. The code helps us pick an initial spot, like a map showing where to start.
8 chairs (memory blocks) are allocated for the people along with their belonging. All the people names (keys) are hashed to create a unique code. Let’s say we want to add John and Jane.
Follow the same method which the code is created by adding up the values of the letters in the name, as above hash function example.
					Hash value for "John": 399
Hash value for "Jane": 382
However, there’re only 8 slots available. so, the masking process happens. This mask is like a rule that says, “Only numbers up to 7 are allowed.”
So, when you get a big code like these, you apply the mask, and it becomes code & 0b111 (which is 6 in binary). This magically makes big numbers fit within your 8-chair seating arrangement.
Now, we’ll apply a mask to these hash values to fit them within a seating arrangement of 8 chairs:
					mask = 0b111 # which is 7 in decimal
For "John":

Hash value: 74 + 111 + 104 + 110 = 399
Applying the mask: 399 & 0b111 = 7
So, "John" (key) would sit in chair index 7 with his belongings (data).

For "Jane":

Hash value:  74 + 97 + 110 + 101 = 382
Applying the mask: 382 & 0b111 = 6
So, "Jane" (key) would sit in chair index 6 with her belonging (data).

4. Comparing and Adjusting

But what if the spot we picked is already taken?
Here’s where the second thing comes in: we compare the data at that spot with the new data we’re adding. If they’re the same, we don’t need to do anything. If they’re different, we need to find a new spot nearby.
Let’s say we want to add Abby. Follow the same procedure:
					Hash value for "Abby": 65 + 98 + 98 + 121 = 382
Applying the mask: 382 & 0b111 = 6
“Abby” (key) would sit in chair index 6 with her belonging (data). However, Jane is already assigned to that spot. So, We have to assign Abby to the new available spot.

How Dictionary uses hash table?

When you put something in the dictionary, it takes the key, runs it through a special math formula (called a hash function), and gets a unique code. This code acts like an address where the value is stored.
When you want to find something, like a phone number, the dictionary takes the key, uses the same magic formula, gets the code, and instantly knows where the value is. It’s like finding a treasure using a map!
Instead of having to remember complicated, boring numbers for each piece of data, we use keys. Keys can be anything you like, like names, words, or symbols. So, instead of an order like numbers (1, 2, 3), you can have keys like “apple,” “banana,” and “orange.”
Example: Think of keys as special names for your data. You say the key (like “banana”) and boom, you’re right where you need to be.
					# Creating a dictionary with keys and values
fruit_colors = {
    "apple": "red",
    "banana": "yellow",
    # ...more entries

# Finding the color of a fruit using its key
banana_color = fruit_colors["banana"]
print(banana_color)  # Output: "yellow"

How sets use hash table?

Sets also use hash tables. When you put something in a set, it’s like you’re telling the set to remember that item. If you ask the set if it has a particular item, it uses the same hash magic to quickly check if it’s in the bag.
Sets only hold unique items. If you put the same item in the set twice, it only keeps one. So, if you have a set of names, you’re sure there are no duplicates. Sets are great for doing things like finding common items between two sets (set operations).

Performance Factors to Consider

Access Time Complexity
Both dictionaries and sets offer remarkable access performance of O(1). Due to their hash-based nature, they provide constant-time average access, ensuring efficient data retrieval.
With a list and tuple, you’d have to look through the entire list, which can be slow if the list is long.
Insertion Time Complexity
Dictionaries and sets also share similar insertion time complexities, both performing average constant-time insertion. However, in scenarios with collision resolution, performance can degrade.
Memory Usage
Dictionaries generally consume more memory than sets due to the additional storage required for keys and values. Sets, containing only unique elements, are more memory-efficient.
Dictionaries and sets use more memory than lists and tuple because they organize data in a special way. Also, their speed depends on how smart their hashing function is. If it takes too long, finding stuff will be slow.

Dictionary Use Cases

Dictionaries shine in scenarios where data needs to be stored and retrieved using meaningful keys. They are commonly used for building associative arrays, implementing caches, and managing configurations.
Use a dictionary when you need to store and retrieve values based on unique keys

Set Use Cases

Sets are invaluable when dealing with collections that require uniqueness. They efficiently eliminate duplicates from data and are useful for membership testing and filtering unique elements.
Use a set when you need to store a collection of unique elements and don’t require key-value relationships.

Tips for Optimizing Performance

  • Minimize Collision: For dictionaries, reducing collisions enhances performance. Choose hash functions carefully and consider resizing the dictionary if needed.
  • Use Set Operations: Sets offer powerful set operations like union, intersection, and difference. Utilize these functions to simplify code and improve efficiency.
  • Memory Consideration: When memory usage is a concern, opt for sets over dictionaries, especially when dealing with large datasets.


In the realm of Python performance optimization, the choice between dictionaries and sets depends on the specific requirements of your task. Both structures offer exceptional access and insertion performance, but their memory usage and use cases differ. By understanding their characteristics, developers can make informed decisions to ensure efficient code.


Sets are ideal for membership testing due to their efficient uniqueness handling.
While technically possible, dictionaries are designed for key-value associations. If keys aren’t needed, sets might be a better option.
Sets automatically handle duplicates by storing only unique elements. The duplicate will not be added.
While their core functionalities differ, there might be cases where either could work. However, using the appropriate structure is recommended for clarity and performance.
Choose efficient hash functions and consider using built-in functions like collections.defaultdict for more memory-conscious dictionary usage.
Share the Post:
Scroll to Top