Python Dictionaries Explained — Creation, Lookup, and Common Mistakes

Every app you've ever used is quietly powered by key-value pairs. When you log into a website, your username is looked up in a giant table to find your password hash. When Spotify loads your profile, it fetches your name, playlist count, and subscription tier all at once — not as a pile of unconnected numbers, but as named, organised data. Python dictionaries are the building block that makes this kind of organised, instant-access data possible in your own code.

Before dictionaries existed in Python (or before programmers reached for them), people stored related data in parallel lists — one list of names, one list of phone numbers, hoping the indexes stayed in sync. This is fragile, confusing, and breaks the moment someone inserts a row in the wrong place. A dictionary solves this by gluing the label and the value together permanently, so they can never drift apart.

By the end of this article you'll know how to create a dictionary from scratch, read and update values safely, loop through it without breaking anything, and avoid the three mistakes that trip up almost every beginner. You'll also know exactly when a dictionary is the right choice — and when it isn't.

Creating Your First Dictionary — and Understanding What You're Actually Building

A dictionary in Python is written with curly braces {}. Inside, you place pairs of items separated by a colon — the thing on the left of the colon is the key, the thing on the right is the value. Each pair is separated from the next by a comma.

Think of it this way: the key is the label on a filing cabinet drawer, and the value is the document inside. You always open the drawer by its label — never by guessing which drawer number it is.

Keys must be unique. You can't have two drawers with the same label — Python would just keep the last one you defined and silently drop the earlier one. Keys must also be immutable (unchangeable), which in practice means they're almost always strings or numbers. Values, on the other hand, can be absolutely anything: a number, a string, a list, even another dictionary.

You can also create an empty dictionary with just {} and fill it in later — useful when you're building data dynamically, like reading lines from a file.

# A dictionary representing a single student's record
# Keys are strings (labels), values are mixed types
student = {
    "name": "Maria Chen",       # string value
    "age": 21,                  # integer value
    "gpa": 3.85,                # float value
    "is_enrolled": True,        # boolean value
    "courses": ["Math", "CS"]   # list as a value — totally valid!
}

# Print the whole dictionary
print(student)

# Check what type it is
print(type(student))

# Check how many key-value pairs are inside
print("Number of fields:", len(student))

Reading, Adding, and Updating Values — The Three Core Operations You'll Use Every Day

Once your dictionary exists, you need to pull data out of it. The basic way is square bracket notation: student["name"] — think of it as typing the drawer label to pop it open.

But there's a trap with square brackets: if the key doesn't exist, Python throws a KeyError and your program crashes. The safer approach is the .get() method, which returns None by default (or a fallback value you choose) instead of crashing. In production code, .get() is almost always the right choice.

Adding a new key-value pair looks identical to updating an existing one — dictionary["new_key"] = value. If the key already exists, the value gets replaced. If it doesn't exist yet, a new pair is created. Python handles both cases with the same syntax, which keeps things simple.

Deleting a pair uses del dictionary["key"] or the .pop() method. The advantage of .pop() is that it returns the value you removed, so you can use it before it's gone — handy when you're moving data between structures.

student = {
    "name": "Maria Chen",
    "age": 21,
    "gpa": 3.85
}

# --- READING ---
# Square bracket access — fast, but crashes if key is missing
print(student["name"])   # works fine

# .get() is the safe version — returns None if key doesn't exist
print(student.get("gpa"))           # prints 3.85
print(student.get("major"))         # prints None — no crash!
print(student.get("major", "Undeclared"))  # custom fallback value

# --- ADDING a new key ---
student["major"] = "Computer Science"  # key didn't exist — now it does
print(student)

# --- UPDATING an existing key ---
student["gpa"] = 3.92  # key already exists — value gets replaced
print("Updated GPA:", student["gpa"])

# --- DELETING a key ---
# Option 1: del — removes silently
del student["age"]
print("After del:", student)

# Option 2: .pop() — removes AND returns the value
gpa_at_graduation = student.pop("gpa")
print("Captured GPA before removing:", gpa_at_graduation)
print("Final record:", student)

Looping Through a Dictionary — Keys, Values, and Both at Once

Looping over a dictionary is something you'll do constantly — printing a report, transforming data, searching for a specific value. Python gives you three clean methods for this, and knowing which one to use when is a mark of a confident Python developer.

Looping with just for key in dictionary gives you the keys only — the drawer labels. From each key you can look up the value inside the loop if you need it.

The .values() method gives you just the values, no keys — useful when you want to sum up prices or check if a specific value exists anywhere.

The real power move is .items(), which gives you both the key and the value as a pair on every iteration. This is what you'll use 80% of the time because you usually need both. Python unpacks the pair into two variables automatically — for key, value in dictionary.items() — and it reads almost like plain English.

Dictionaries in Python 3.7 and later also maintain insertion order, so the loop will always visit pairs in the order you added them.

product_prices = {
    "Laptop": 999.99,
    "Mouse": 29.99,
    "Keyboard": 79.99,
    "Monitor": 349.99
}

# --- Loop 1: Keys only ---
print("=== Product Names ===")
for product_name in product_prices:
    print("-", product_name)  # each iteration gives us one key

# --- Loop 2: Values only ---
print("\n=== All Prices ===")
total = 0
for price in product_prices.values():
    total += price           # accumulate a running total
print(f"Total inventory value: ${total:.2f}")

# --- Loop 3: Keys AND Values together (the most common pattern) ---
print("\n=== Full Price List ===")
for product_name, price in product_prices.items():  # unpacks each pair
    if price > 100:
        label = "Premium"   # flag expensive items
    else:
        label = "Budget"
    print(f"{product_name}: ${price:.2f} ({label})")

# --- Checking if a key exists before accessing it ---
search_term = "Webcam"
if search_term in product_prices:       # 'in' checks keys by default
    print(f"\nFound {search_term}: ${product_prices[search_term]}")
else:
    print(f"\n'{search_term}' is not in our catalogue.")

Nested Dictionaries — Storing Complex, Real-World Data Structures

Real data is rarely flat. A user doesn't just have a name — they have an address, which itself has a street, city, and postcode. A dictionary can hold another dictionary as a value, letting you model this hierarchy naturally.

This is called a nested dictionary. You access values inside it by chaining square brackets or .get() calls: user["address"]["city"]. Each set of brackets digs one level deeper — like opening a folder inside a folder.

Nested dictionaries are everywhere in professional Python: JSON data from an API is almost always a nested dictionary (Python's json module converts it automatically). Configuration files, database records, and game state are all commonly stored this way.

One thing to watch when working with nested data: if an intermediate key doesn't exist, chaining square brackets will crash on the first missing key before it even tries the inner one. Using .get() at each level prevents this — or you can use a try/except block if the structure is deeply uncertain.

# A dictionary of users — each key is a user ID, each value is another dictionary
user_database = {
    "usr_001": {
        "username": "mariachen",
        "email": "maria@example.com",
        "address": {
            "street": "14 Elm Street",
            "city": "Austin",
            "postcode": "73301"
        },
        "is_premium": True
    },
    "usr_002": {
        "username": "jakethompson",
        "email": "jake@example.com",
        "address": {
            "street": "9 Oak Avenue",
            "city": "Denver",
            "postcode": "80201"
        },
        "is_premium": False
    }
}

# Access a top-level value
print(user_database["usr_001"]["username"])  # chain brackets to go deeper

# Access a deeply nested value
print(user_database["usr_001"]["address"]["city"])

# Safe access with .get() at each level — no crash if a key is missing
user = user_database.get("usr_003", {})          # returns empty dict if not found
city = user.get("address", {}).get("city", "Unknown")
print("City for usr_003:", city)                  # gracefully returns 'Unknown'

# Loop through all users and print a summary
print("\n=== User Summary ===")
for user_id, user_info in user_database.items():
    tier = "Premium" if user_info["is_premium"] else "Free"
    city = user_info["address"]["city"]
    print(f"{user_id} | @{user_info['username']} | {city} | {tier}")

Frequently Asked Questions