Why dictionaries are used in Python - Why It Works This Way

Overview - Why dictionaries are used

What is it?

Dictionaries in Python are collections that store data as pairs of keys and values. Each key is unique and is used to quickly find its matching value. Unlike lists, dictionaries do not keep items in order but focus on fast access. They are like labeled boxes where you can store and retrieve things by name.

Why it matters

Dictionaries solve the problem of quickly finding information without searching through everything. Without dictionaries, programs would be slower and more complicated because they would have to look through lists or other structures to find data. This would make apps and websites less responsive and harder to build.

Where it fits

Before learning dictionaries, you should understand basic data types like strings, numbers, and lists. After dictionaries, you can learn about sets, classes, and more advanced data structures that organize data efficiently.

Mental Model

Core Idea

A dictionary stores data as unique keys linked directly to values, allowing instant lookup by key.

Think of it like...

A dictionary is like a real-world dictionary book where you look up a word (key) to find its meaning (value) instantly, instead of reading every page.

┌─────────────┐
│ Dictionary  │
├─────────────┤
│ Key: 'name' │ → Value: 'Alice'
│ Key: 'age'  │ → Value: 30
│ Key: 'city' │ → Value: 'Paris'
└─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding key-value pairs

Concept: Dictionaries store data as pairs where each key points to a value.

In Python, a dictionary looks like this: {'key1': 'value1', 'key2': 'value2'}. Each key is unique and helps find its value quickly. For example, {'name': 'Bob', 'age': 25} stores a name and age.

Result

You can access 'Bob' by asking for the value of key 'name'.

Knowing that data is stored as pairs helps you see why dictionaries are different from lists.

2

Foundation

Creating and accessing dictionaries

Concept: You can create dictionaries and get values by their keys.

Create a dictionary: person = {'name': 'Anna', 'age': 28} Access a value: person['name'] # returns 'Anna' Trying to access a key that doesn't exist causes an error.

Result

person['name'] returns 'Anna'.

Understanding how to create and access dictionaries is the first step to using them effectively.

3

Intermediate

Why dictionaries are faster for lookup

🤔Before reading on: do you think finding an item in a dictionary is faster or slower than in a list? Commit to your answer.

Concept: Dictionaries use a method called hashing to find values quickly without checking every item.

When you ask for a value by key, Python uses a hash function to jump directly to where the value is stored. Lists, by contrast, check items one by one until they find a match.

Result

Looking up a key in a dictionary is usually much faster than searching a list.

Knowing that dictionaries use hashing explains why they are preferred for fast data retrieval.

4

Intermediate

Keys must be unique and immutable

🤔Before reading on: can a list be used as a dictionary key? Commit to yes or no.

Concept: Dictionary keys must be unique and cannot change after creation (immutable).

Keys like strings, numbers, or tuples can be used because they don't change. Lists or other dictionaries cannot be keys because they can change, which would break the lookup system.

Result

Trying to use a list as a key causes an error.

Understanding key restrictions prevents common errors and clarifies how dictionaries maintain fast access.

5

Intermediate

Adding and updating dictionary items

Concept: You can add new key-value pairs or change existing ones easily.

person = {'name': 'Tom'} person['age'] = 40 # adds a new key 'age' person['name'] = 'Tim' # updates the value for 'name'

Result

person becomes {'name': 'Tim', 'age': 40}.

Knowing how to modify dictionaries makes them flexible for many tasks.

6

Advanced

Dictionaries in real-world applications

🤔Before reading on: do you think dictionaries are used only for small data or also for large, complex data? Commit to your answer.

Concept: Dictionaries are used everywhere to organize data by labels, from small programs to big systems.

Websites use dictionaries to store user info, apps use them for settings, and databases use similar key-value structures for fast access. They help manage complex data efficiently.

Result

Dictionaries enable fast, organized data handling in many real-world programs.

Recognizing the widespread use of dictionaries shows their importance beyond simple examples.

7

Expert

How dictionary resizing affects performance

🤔Before reading on: do you think dictionaries always keep the same size internally? Commit to yes or no.

Concept: Dictionaries resize their internal storage when they grow to keep lookups fast, which can briefly slow down operations.

When many items are added, Python creates a bigger internal table and moves items there. This resizing is automatic but can cause short delays. Understanding this helps optimize performance in large programs.

Result

Dictionaries remain fast but resizing can cause occasional slowdowns.

Knowing about resizing helps experts write efficient code and avoid unexpected slowdowns.

Under the Hood

Python dictionaries use a hash table internally. When you add a key, Python computes a hash number from the key and uses it to find a slot in an internal array. If two keys hash to the same slot, Python uses a method called probing to find another slot. This allows very fast access because Python jumps directly to the slot instead of searching linearly.

Why designed this way?

Dictionaries were designed to provide average constant-time lookup, insertion, and deletion. Hash tables were chosen because they balance speed and memory use well. Alternatives like lists or trees are slower for lookup. The design also handles collisions and resizing to maintain performance.

┌───────────────┐
│ Key: 'age'   │
│ Hash → 5     │
│ Slot 5       │
│ Value: 30    │
└───────────────┘
       ↑
┌─────────────────────────────┐
│ Internal array (hash table)  │
│ Slots: [0][1][2][3][4][5]...│
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think dictionary keys can be changed after creation? Commit to yes or no.

Common Belief: Dictionary keys can be changed anytime like list items.

Reality: Dictionary keys must be immutable and cannot be changed after creation.

Why it matters: Trying to change keys causes errors and breaks the dictionary's fast lookup system.

Quick: Do you think dictionaries keep items in the order they were added? Commit to yes or no.

Common Belief: Dictionaries always keep the order of items like lists.

Reality: Since Python 3.7, dictionaries preserve insertion order, but this was not always true and should not be relied on for logic.

Why it matters: Assuming order can cause bugs if code runs on older Python versions or if order is critical.

Quick: Do you think looking up a value in a dictionary is slower than in a list? Commit to yes or no.

Common Belief: Searching a list is faster or the same speed as a dictionary lookup.

Reality: Dictionary lookups are generally much faster than list searches because of hashing.

Why it matters: Using lists for frequent lookups can make programs slow and inefficient.

Quick: Do you think you can use any data type as a dictionary key? Commit to yes or no.

Common Belief: Any data type, including lists and dictionaries, can be used as keys.

Reality: Only immutable types like strings, numbers, and tuples can be keys; mutable types like lists cannot.

Why it matters: Using mutable types as keys causes errors and breaks dictionary behavior.

Expert Zone

1

Dictionaries maintain insertion order since Python 3.7, which can be used for predictable iteration.

2

The hash function used can be randomized per program run to prevent certain security attacks.

3

When many keys collide in the hash table, Python switches to a different internal structure (a small tree) to keep lookups fast.

When NOT to use

Dictionaries are not ideal when order matters before Python 3.7 or when keys are mutable. For ordered data, use collections.OrderedDict (legacy) or lists if order and duplicates matter. For very large datasets with complex queries, databases or specialized data structures may be better.

Production Patterns

Dictionaries are used for configuration settings, caching results, counting items, and representing JSON-like data. They often serve as fast lookup tables in algorithms and are combined with classes for flexible data models.

Connections

Hash Tables

Dictionaries are a practical implementation of hash tables.

Understanding hash tables explains why dictionaries provide fast access and how collisions are handled.

Databases

Dictionaries share the key-value storage pattern used in NoSQL databases.

Knowing dictionaries helps grasp how key-value stores work in large-scale data systems.

Human Memory

Both use keys (cues) to quickly retrieve stored information.

Recognizing this similarity helps understand why organizing data by keys is efficient and natural.

Common Pitfalls

#1 Trying to use a list as a dictionary key.

Wrong approach:

my_dict = {[1, 2, 3]: 'value'}

Correct approach:

my_dict = {(1, 2, 3): 'value'}

Root cause:

Lists are mutable and cannot be hashed, so they cannot be dictionary keys.

#2 Accessing a key that does not exist without checking.

Wrong approach:

value = my_dict['missing_key'] # causes KeyError

Correct approach:

value = my_dict.get('missing_key', 'default') # returns 'default' if key missing

Root cause:

Not handling missing keys leads to runtime errors.

#3 Assuming dictionary keys are ordered in all Python versions.

Wrong approach:

for key in my_dict:
print(key) # expecting insertion order on Python <3.7

Correct approach:

Use collections.OrderedDict for guaranteed order in older Python versions.

Root cause:

Dictionary order preservation was introduced in Python 3.7; older versions do not guarantee order.

Key Takeaways

Dictionaries store data as unique key-value pairs for fast access.

They use hashing internally to find values quickly without searching all items.

Keys must be immutable and unique to maintain dictionary integrity.

Dictionaries are widely used in programming for organizing and retrieving data efficiently.

Understanding dictionary internals helps write better, faster, and more reliable code.