Dictionaries

Beginner ~25 min read

Dictionaries are Python's built-in mapping type - they store data as key-value pairs. Think of them like a real dictionary where you look up a word (key) to find its definition (value). They're incredibly fast for lookups and one of Python's most useful data structures!

Creating Dictionaries

Dictionaries are created with curly braces {} containing key: value pairs, or with the dict() constructor. Keys must be immutable (hashable), but values can be anything.

# Creating Dictionaries in Python

# 1. Using curly braces with key:value pairs
print("=== Creating Dictionaries ===")
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}
print(f"Person dict: {person}")
print(f"Type: {type(person)}")
print()

# 2. Empty dictionary
print("=== Empty Dictionary ===")
empty = {}
also_empty = dict()
print(f"Empty dict: {empty}")
print(f"Using dict(): {also_empty}")
print()

# 3. Using dict() constructor
print("=== Using dict() Constructor ===")
# From keyword arguments
user = dict(name="Bob", age=25, active=True)
print(f"From kwargs: {user}")

# From list of tuples
pairs = [("a", 1), ("b", 2), ("c", 3)]
from_pairs = dict(pairs)
print(f"From tuples: {from_pairs}")

# From two lists using zip
keys = ["x", "y", "z"]
values = [10, 20, 30]
from_zip = dict(zip(keys, values))
print(f"From zip: {from_zip}")
print()

# 4. Keys can be any immutable type
print("=== Valid Key Types ===")
mixed_keys = {
    "string_key": 1,
    42: "integer key",
    (1, 2): "tuple key",
    3.14: "float key",
    True: "boolean key"
}
for k, v in mixed_keys.items():
    print(f"  {k!r}: {v}")
print()

# 5. Values can be anything
print("=== Values Can Be Anything ===")
complex_dict = {
    "list": [1, 2, 3],
    "dict": {"nested": "value"},
    "tuple": (4, 5, 6),
    "function": len,
    "none": None
}
print(f"List value: {complex_dict['list']}")
print(f"Nested dict: {complex_dict['dict']}")
print(f"Function value: {complex_dict['function']('hello')}")
print()

# 6. Dictionary properties
print("=== Dictionary Properties ===")
sample = {"a": 1, "b": 2, "c": 3}
print(f"Length: {len(sample)}")
print(f"Keys: {list(sample.keys())}")
print(f"Values: {list(sample.values())}")
print(f"Items: {list(sample.items())}")

Output

Click Run to execute your code

Dictionary Properties: Since Python 3.7, dictionaries maintain insertion order. Keys must be unique and immutable (strings, numbers, tuples). Values can be any type including lists, other dictionaries, or even functions!

Accessing Dictionary Values

Access values using square brackets dict[key] or the safer get() method. Use in to check if a key exists, and keys(), values(), items() to get different views.

# Accessing Dictionary Values

person = {
    "name": "Alice",
    "age": 30,
    "city": "New York",
    "email": "alice@example.com"
}
print(f"Dictionary: {person}")
print()

# 1. Square bracket notation
print("=== Square Bracket Access ===")
print(f"person['name']: {person['name']}")
print(f"person['age']: {person['age']}")
# print(person['phone'])  # KeyError if key doesn't exist!
print()

# 2. get() method - safe access
print("=== get() Method - Safe Access ===")
print(f"person.get('name'): {person.get('name')}")
print(f"person.get('phone'): {person.get('phone')}")  # Returns None
print(f"person.get('phone', 'N/A'): {person.get('phone', 'N/A')}")  # Default value
print()

# 3. Checking if key exists
print("=== Checking Keys ===")
print(f"'name' in person: {'name' in person}")
print(f"'phone' in person: {'phone' in person}")
print(f"'phone' not in person: {'phone' not in person}")
print()

# 4. keys(), values(), items()
print("=== Keys, Values, Items ===")
print(f"Keys: {list(person.keys())}")
print(f"Values: {list(person.values())}")
print(f"Items: {list(person.items())}")
print()

# 5. Accessing nested dictionaries
print("=== Nested Dictionary Access ===")
company = {
    "name": "TechCorp",
    "address": {
        "street": "123 Main St",
        "city": "Boston",
        "zip": "02101"
    },
    "employees": ["Alice", "Bob", "Charlie"]
}
print(f"Company: {company['name']}")
print(f"City: {company['address']['city']}")
print(f"First employee: {company['employees'][0]}")
print()

# Safe nested access
print("=== Safe Nested Access ===")
# Using get() chain
zip_code = company.get('address', {}).get('zip', 'Unknown')
print(f"Zip code: {zip_code}")

# Missing key with default
country = company.get('address', {}).get('country', 'USA')
print(f"Country (default): {country}")

Output

Click Run to execute your code

Pro Tip: Always use get() when the key might not exist. dict.get('key', default) returns the default value instead of raising a KeyError. This makes your code more robust and avoids try/except blocks.

Modifying Dictionaries

Dictionaries are mutable - you can add, update, and remove key-value pairs. Use assignment, update(), pop(), and del to modify your dictionaries.

# Modifying Dictionaries

person = {"name": "Alice", "age": 30, "city": "New York"}
print(f"Original: {person}")
print()

# 1. Update existing value
print("=== Updating Values ===")
person["age"] = 31
print(f"After person['age'] = 31: {person}")
print()

# 2. Add new key-value pair
print("=== Adding New Keys ===")
person["email"] = "alice@example.com"
print(f"After adding email: {person}")
print()

# 3. update() method - add/update multiple items
print("=== update() Method ===")
person.update({"age": 32, "phone": "555-1234"})
print(f"After update(): {person}")

# Can also use keyword arguments
person.update(city="Boston", country="USA")
print(f"After update(kwargs): {person}")
print()

# 4. setdefault() - add only if not exists
print("=== setdefault() ===")
person = {"name": "Alice", "age": 30}
print(f"Starting: {person}")

# Adds key because it doesn't exist
person.setdefault("city", "Unknown")
print(f"After setdefault('city', 'Unknown'): {person}")

# Doesn't change because key exists
person.setdefault("name", "Bob")
print(f"After setdefault('name', 'Bob'): {person}")
print()

# 5. Removing items
print("=== Removing Items ===")
person = {"name": "Alice", "age": 30, "city": "NYC", "temp": "delete me"}
print(f"Original: {person}")

# pop() - remove and return value
removed = person.pop("temp")
print(f"pop('temp') returned: {removed}")
print(f"After pop: {person}")

# pop() with default for missing key
missing = person.pop("phone", "Not found")
print(f"pop('phone', 'Not found'): {missing}")

# del - remove without return
del person["city"]
print(f"After del person['city']: {person}")

# popitem() - remove last item (Python 3.7+)
person = {"a": 1, "b": 2, "c": 3}
last = person.popitem()
print(f"popitem() returned: {last}")
print(f"After popitem: {person}")
print()

# 6. clear() - remove all items
print("=== clear() ===")
data = {"x": 1, "y": 2}
data.clear()
print(f"After clear(): {data}")

Output

Click Run to execute your code

Looping Through Dictionaries

Iterate over keys, values, or both using keys(), values(), and items(). The default iteration is over keys.

# Looping Through Dictionaries

student = {
    "name": "Alice",
    "age": 20,
    "major": "Computer Science",
    "gpa": 3.8
}
print(f"Student: {student}")
print()

# 1. Loop through keys (default)
print("=== Loop Through Keys ===")
for key in student:
    print(f"  {key}")
print()

# Explicit keys()
print("=== Using .keys() ===")
for key in student.keys():
    print(f"  {key}: {student[key]}")
print()

# 2. Loop through values
print("=== Using .values() ===")
for value in student.values():
    print(f"  {value}")
print()

# 3. Loop through key-value pairs
print("=== Using .items() ===")
for key, value in student.items():
    print(f"  {key}: {value}")
print()

# 4. Enumerate with items
print("=== Enumerate Items ===")
for i, (key, value) in enumerate(student.items()):
    print(f"  {i}. {key} = {value}")
print()

# 5. Filtering while looping
print("=== Filtering Values ===")
scores = {"Alice": 85, "Bob": 72, "Charlie": 91, "Diana": 68}
passing = {k: v for k, v in scores.items() if v >= 75}
print(f"All scores: {scores}")
print(f"Passing (>=75): {passing}")
print()

# 6. Sorted iteration
print("=== Sorted Iteration ===")
# By key
print("Sorted by key:")
for key in sorted(student.keys()):
    print(f"  {key}: {student[key]}")

# By value (need items)
print("\nScores sorted by value:")
for name, score in sorted(scores.items(), key=lambda x: x[1], reverse=True):
    print(f"  {name}: {score}")
print()

# 7. Safe modification during iteration
print("=== Safe Modification ===")
# Never modify dict size while iterating!
# Instead, iterate over a copy or build new dict
original = {"a": 1, "b": 2, "c": 3, "d": 4}
# Remove items where value is even
filtered = {k: v for k, v in original.items() if v % 2 != 0}
print(f"Original: {original}")
print(f"Filtered (odd values): {filtered}")

Output

Click Run to execute your code

Don't Modify While Iterating! Never add or remove keys while looping through a dictionary - it will raise a RuntimeError. Instead, iterate over a copy (dict.copy()) or build a new dictionary.

Common Mistakes

1. KeyError when accessing missing key

# Wrong - raises KeyError
person = {"name": "Alice"}
print(person["age"])  # KeyError: 'age'

# Correct - use get() with default
print(person.get("age", "Unknown"))  # "Unknown"

# Or check first
if "age" in person:
    print(person["age"])

2. Using mutable objects as keys

# Wrong - lists are mutable/unhashable
my_dict = {[1, 2]: "value"}  # TypeError!

# Correct - use tuples instead
my_dict = {(1, 2): "value"}  # Works!

3. Modifying dict while iterating

# Wrong - modifying size during iteration
for key in my_dict:
    if some_condition:
        del my_dict[key]  # RuntimeError!

# Correct - iterate over copy or use comprehension
for key in list(my_dict.keys()):  # Creates copy of keys
    if some_condition:
        del my_dict[key]

# Or build new dict
my_dict = {k: v for k, v in my_dict.items() if not some_condition}

4. Overwriting when you meant to update

# Wrong - completely replaces the dict
config = {"debug": True, "verbose": False}
config = {"timeout": 30}  # Lost debug and verbose!

# Correct - update existing dict
config.update({"timeout": 30})
# Or
config["timeout"] = 30

Exercise: Student Profile

Task: Create and modify a dictionary representing a student.

Requirements:

Create a dictionary with name, age, and grade
Update the grade to "A+"
Add a new key "subject" with value "Computer Science"

Output

Click Run to execute your code

Show Solution

# Create student dictionary
student = {
    "name": "John",
    "age": 20,
    "grade": "B"
}
print(f"Original: {student}")

# Update grade to A+
student["grade"] = "A+"
print(f"After grade update: {student}")

# Add subject
student["subject"] = "Computer Science"
print(f"Final: {student}")

Summary

Creating: {"key": value} or dict(key=value)
Accessing: dict[key] or dict.get(key, default)
Adding/Updating: dict[key] = value or dict.update()
Removing: del dict[key], dict.pop(key), dict.clear()
Checking: key in dict
Looping: .keys(), .values(), .items()
Properties: Ordered (3.7+), mutable, unique keys, O(1) lookup

What's Next?

Now let's learn Dictionary Comprehensions - the elegant, one-liner way to create and transform dictionaries, similar to list comprehensions!

Previous Sets

Next Dict Comprehensions

Creating Dictionaries

Accessing Dictionary Values

Modifying Dictionaries

Looping Through Dictionaries

Common Mistakes

1. KeyError when accessing missing key

2. Using mutable objects as keys

3. Modifying dict while iterating

4. Overwriting when you meant to update

Exercise: Student Profile

Summary

What's Next?

Enjoying these tutorials?