Python Dictionaries

1. Concept Introduction

A dictionary (dict) in Python is a built-in data structure that stores data in key-value pairs. Instead of asking "give me the 5th item" (like a List), you ask a Dictionary "give me the value associated with the name 'email' ".

This fundamentally solves the problem of Lookup Speed. If you have 10 million usernames in a List and want to find "John", the computer must scan every single name until it finds it (O(N) time). A Dictionary uses a mathematical trick called Hashing to find "John" instantly (O(1) time), no matter if there are 10 items or 10 billion items.

2. Concept Intuition

Think of a List like a massive library where books are placed randomly on shelves. To find a book about Neural Networks, you have to walk down every aisle and read every cover until you spot it.

Think of a Dictionary like a magic librarian. You walk up to the librarian and say "Neural Networks". The librarian instantly computes a magical math formula in their head: "Ah, the letters in 'Neural Networks' mathematically point exactly to Aisle 4, Shelf 2, Book 3!". You walk straight there instantly. You never have to search the intermediate shelves.

3. Python Syntax

my_dict = {"key1": "value1", "key2": "value2"} my_dict = dict(key1="value1", key2="value2") # Adding / Updating my_dict["new_key"] = "new_value" # Common Methods: # .keys(): Returns a view of all keys # .values(): Returns a view of all values # .items(): Returns a view of (key, value) tuples # .get(key, default): Safely gets a value, or default if missing

4. Python Code Example

python

# 1. Dictionary Creation
user_profile = {"name": "Alice", "age": 28, "is_admin": True}

# 2. Fast O(1) Lookup
print(user_profile["name"])  # Outputs: Alice

# 3. Adding a new Key-Value Pair
user_profile["email"] = "alice@example.com"

# 4. Safe Lookup (Default Value)
country = user_profile.get("country", "Unknown")
print(country)  # Outputs: Unknown

5. Line-by-Line Explanation

Code Line	Explanation
`user_profile = {"name": "Alice", "age": 28, ...}`	Python allocates a Hash Table in memory. It calculates the hash of the string "name", uses it to find an empty bucket, and stores a pointer to the string "Alice". It repeats this for "age".
`print(user_profile["name"])`	Python takes "name", hashes it to the exact same number, jumps instantly to that index in memory, and returns "Alice" without checking "age" or any other keys.
`user_profile["email"] = "alice@example.com"`	Python hashes "email". It finds an empty memory bucket corresponding to that hash and injects the new pointer. This does not push existing keys around.
`user_profile.get("country", "Unknown")`	Python hashes "country". It jumps to the bucket. The bucket is completely empty. Instead of crashing the program with a `KeyError`, the `get()` wrapper catches it and elegantly returns the fallback string "Unknown".

6. Input and Output Example

Input Dictionary: counts = {"apple": 1}

Code operation: counts["apple"] += 1

Transformation process: Instantly look up "apple" bucket -> retrieve integer `1`. Execute addition `1 + 1 = 2`. Instantly jump back to "apple" bucket and overwrite the pointer to the new integer `2` object.

Output State:

{"apple": 2}

7. Internal Mechanism

Internally, modern Python Dictionaries (since Python 3.6) use an incredibly brilliant dual-array system to ensure they are both fast AND ordered.

1. Indices Array: A sparse array of integers. When a key is hashed, Python jumps into this array. This array only contains integers, making it ultra-lightweight and cache-friendly.

2. Entries Array: A dense, contiguous C-struct array containing `(Hash, Key_Pointer, Value_Pointer)`. When you append to a dict, the entry goes to the next empty spot in this array, preserving insertion order.

When you look up a key, Python hashes it, checks the lean Indices array instantly, gets the index integer, and uses that integer to retrieve the real data from the dense Entries array.

8. Vector Representation

Adding `{"a": 1, "b": 2}` mathematically:

hash("a") = 12416037344
binary = ...00101 (lowest 3 bits = 5)

Indices Array:
[None, None, None, None, None, 0, None, 1]
                               ^        ^
                            hash("a") hash("b")
Entries Array:
Index 0: (12416037344, pointer_to_"a", pointer_to_1)
Index 1: (hash_of_"b", pointer_to_"b", pointer_to_2)

9. Shape and Dimensions

Like a list, a Dictionary is 1-Dimensional. You get the count of key-value pairs using len(my_dict).

When the dict grows to 2/3rds full (e.g., trying to put 6 items in an 8-bucket array), Python executes a massive resizing operation, doubling the array to 16 buckets and completely recalculating everyone's new position mathematically.

10. Return Values

Object Type: <class 'dict'>

dict.keys() Type: <class 'dict_keys'> (This is a View object, not a List. It takes 0 extra memory. If the dictionary updates, the View is instantly aware of it. To get a snapshot memory copy, you must wrap it: list(my_dict.keys())).

11. Edge Cases

Hash Collisions: What if "Apple" and "Banana" mathematically generate the exact same bucket number (e.g., Bucket 4)? This is known as a collision. Python handles this instantly using Open Addressing (Random Probing). It calculates a pseudo-random jump formula, looks for the next available empty bucket, and drops "Banana" there instead.

Un-hashable Types: You cannot use a List as a Dictionary key because Lists can mathematically mutate. d = {[1,2]: "error"} will result in a fatal `TypeError: unhashable type: 'list'`.

12. Variations & Alternatives

collections.defaultdict: Normally, editing an empty key like d["count"] += 1 crashes because "count" doesn't exist yet to add to. defaultdict(int) automatically assigns `0` to any missing key right before the `+= 1` executes, avoiding massive `if key in dict:` checking bloat.

collections.Counter: Feed it a list like ['a', 'b', 'a'] and it instantly constructs a dictionary of frequencies behind the scenes: {"a": 2, "b": 1}.

13. Common Mistakes

Mistake: Iterating over a dictionary while trying to delete keys from it.

for key in d: if key == "bad": del d[key]

Why is this bad?: Python throws a fatal RuntimeError: dictionary changed size during iteration. The internal C iterators lose their mathematical track of the loop offsets when you delete items mid-flight.

Fix: Create a static copied list of keys first: for key in list(d.keys()):

14. Performance Considerations

Looking up a key is O(1) mathematically instantaneous time.

HOWEVER, the mathematical hash function itself takes processing time (hashing a massive string takes CPU ticks). Therefore it is slightly slower to retrieve d["apple"] than to retrieve index L[0] from a simple list. Always use lists when exact numbering is required, use dicts when named associations are required.

15. Practice Exercise

Challenge: You possess a dictionary mapping user ages: ages = {"bob": 30, "alice": 25}. Write a single-line dictionary comprehension that flips this dictionary, mapping the ages as the keys, and names as the values.

Expected Answer: {age: name for name, age in ages.items()}

16. Advanced Explanation

Security Attack (Hash DOS): In older versions of Python, hackers could send 100,000 carefully crafted web parameters that all mathematically mapped to the exact same Bucket 4 (forcing 100,000 Hash Collisions). Because Python had to randomly probe 100,000 times for every single insertion, the O(1) time degraded completely into O(N^2) time, instantly freezing the entire web server (CPU 100%).

Python 3 securely fixed this by injecting a random cryptographic "salt" into the hashing math formula the moment the Python runtime starts. This guarantees the hacker cannot mathematically predict where the buckets will land on your specific server.

Python Dictionaries {}