Python Dictionaries

Learn how to store key–value data using dictionaries and why they are essential for storing structured information.

8 minutesVideo LessonPDF notes

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Ready to continue?

Mark this lesson as complete when you're ready to proceed.

Key moments

Dictionary Basics — Creates a dictionary storing country keys mapped to capital values using curly braces.
Dictionary Introspection — Demonstrates how to inspect available dictionary methods using dir and help functions.
Safe Retrieval with Get — Retrieves values using get and handles non-existent keys conditionally via None return values.
Updating and Inserting — Inserts a new country and modifies an existing capital value using the update method.
Removal Methods — Removes entries using pop for specific keys, popitem for recent keys, and clear for wiping the dictionary.
Keys and Values Iteration — Iterates across keys and values collections using dedicated view methods within for loops.
Iterating Over Items — Unpacks key-value tuple pairs across loop iterations using the items method.

PDF notes

Bottom line: You will create, inspect, modify, and traverse Python dictionaries using built-in methods. You will safely access values without runtime errors, insert or update key-value pairs, remove entries deterministically, and iterate across keys, values, and item tuples.

This lesson on Python Dictionaries is hands-on and example-driven. You will create, inspect, modify, and traverse Python dictionaries using built-in methods. You will safely access values without runtime errors, insert or update key-value pairs, remove entries deterministically, and iterate across keys, values, and item tuples.

What You'll Be Able To Do

Construct a dictionary using key-value syntax within curly braces and verify its structure.
Retrieve values safely using the get method to handle missing keys without throwing exceptions.
Insert new entries and modify existing values using the update method.
Remove specific entries using pop, delete the most recent item using popitem, and purge all items using clear.
Iterate through dictionary elements across keys, values, and unpacked key-value pairs via items.

Detailed Concept Walkthrough

1. Dictionary Definition and Introspection

A dictionary is an ordered, changeable collection of key-value pairs where keys must be unique. It maps distinct lookup keys to associated values using curly brace syntax separated by colons.

Syntax Rule: Define a dictionary by enclosing comma-separated key: value pairs within curly braces {}.
Data Integrity: Keys must be unique within a single dictionary; duplicate keys are not allowed and will overwrite previous entries.
Introspection Tools: Run dir(dictionary_name) to view all available dictionary attributes and methods, or run help(dictionary_name) in the interactive shell to read detailed documentation on method signatures.

# Define a dictionary of countries and capitals
capitals = {
    "USA": "Washington, D.C.",
    "India": "New Delhi",
    "China": "Beijing",
    "Russia": "Moscow"
}

# Inspect available methods on the dictionary
print(dir(capitals))

Key Takeaway: Dictionaries store unique keys mapped to mutable values in an ordered structure defined by curly braces.

2. Safe Lookup and Element Modification

Dictionaries provide dedicated methods to retrieve values safely and apply batch insertions or updates to existing keys.

Mechanism: Calling dict.get(key) returns the associated value if the key exists, or None if the key is absent, avoiding unexpected execution halts.
Conditional Guard: Because get returns None for missing keys, you can directly use if dict.get(key): to verify membership before proceeding with logic.
Modification Syntax: Calling dict.update({key: value}) inserts the pair if the key is new, or overwrites the existing value if the key already exists in the dictionary.

capitals = {"USA": "Washington, D.C.", "India": "New Delhi"}

# Safe lookup returning value or None
usa_cap = capitals.get("USA")       # "Washington, D.C."
jp_cap = capitals.get("Japan")      # None

# Conditional check
if capitals.get("Japan"):
    print("Capital exists")
else:
    print("Capital doesn't exist")

# Insert new key and overwrite existing key
capitals.update({"Germany": "Berlin"})
capitals.update({"USA": "Detroit"})
print(capitals)

Key Takeaway: Use get for safe lookups that return None on missing keys, and use update to both insert new pairs and modify existing values.

3. Removal and Deletion Methods

Python offers targeted methods to eliminate specific keys, remove the most recently added entry, or clear the entire dictionary container.

Targeted Deletion: The pop(key) method removes the specified key and its associated value from the dictionary.
LIFO Removal: The popitem() method takes no arguments and removes the last inserted key-value pair based on insertion order.
Container Reset: The clear() method strips all entries from the dictionary in-place, leaving an empty dictionary {}.

capitals = {
    "USA": "Detroit",
    "India": "New Delhi",
    "China": "Beijing",
    "Russia": "Moscow"
}

# Remove a specific key
capitals.pop("China")

# Remove the most recently added key-value pair
capitals.popitem()

# Empty the entire dictionary
capitals.clear()
print(capitals)  # Output: {}

Key Takeaway: Choose pop for specific keys, popitem for the latest entry, and clear to purge all elements.

4. Dictionary Views and Iteration

Dictionaries expose dynamic iterable view objects for inspecting keys, values, or unpacked key-value pairs across loops.

Key Iteration: The dict.keys() method produces an iterable collection containing all dictionary keys, allowing sequential iteration via for key in dict.keys():.
Value Iteration: The dict.values() method returns an iterable collection of all stored values, accessible with for val in dict.values():.
Pair Unpacking: The dict.items() method returns view objects structured like pairs of tuples, allowing simultaneous unpacking of key and value variables in a single loop statement.

capitals = {
    "USA": "Washington, D.C.",
    "India": "New Delhi",
    "Russia": "Moscow"
}

# Iterate over keys
for key in capitals.keys():
    print(f"Key: {key}")

# Iterate over values
for value in capitals.values():
    print(f"Value: {value}")

# Iterate and unpack key-value pairs simultaneously
for key, value in capitals.items():
    print(f"{key}: {value}")

Key Takeaway: Iterate over keys, values, or items using dedicated view methods, unpacking items directly into key-value loop variables.

Topics Covered in Python Dictionaries

Dictionary Basics (0:00 - 0:45) — Creates a dictionary storing country keys mapped to capital values using curly braces.
Dictionary Introspection (0:45 - 1:15) — Demonstrates how to inspect available dictionary methods using dir and help functions.
Safe Retrieval with Get (1:15 - 2:10) — Retrieves values using get and handles non-existent keys conditionally via None return values.
Updating and Inserting (2:10 - 2:50) — Inserts a new country and modifies an existing capital value using the update method.
Removal Methods (2:50 - 3:30) — Removes entries using pop for specific keys, popitem for recent keys, and clear for wiping the dictionary.
Keys and Values Iteration (3:30 - 4:45) — Iterates across keys and values collections using dedicated view methods within for loops.
Iterating Over Items (4:45 - 5:30) — Unpacks key-value tuple pairs across loop iterations using the items method.

Python Cheat Sheet

capitals = {"USA": "Washington, D.C."} — Initializes a dictionary with key-value pairs
```
capitals = {"USA": "Washington, D.C.", "India": "New Delhi"}
```
dict.get(key) — Fetches value for key; returns None if missing
```
capital = capitals.get("Japan")
```
dict.update({key: value}) — Inserts or updates key-value pairs in-place
```
capitals.update({"Germany": "Berlin"})
```
dict.pop(key) — Removes the specified key and its associated value
```
capitals.pop("China")
```
dict.popitem() — Removes the most recently added key-value pair
```
capitals.popitem()
```
dict.clear() — Removes all elements from the dictionary
```
capitals.clear()
```
dict.keys() / dict.values() — Returns iterable view of keys or values
```
for k in capitals.keys(): print(k)
```
dict.items() — Returns iterable view of key-value tuples
```
for k, v in capitals.items(): print(f"{k}: {v}")
```

Comparison Table

Method	Yielded Structure	Primary Purpose
.keys()	Iterable view of keys	Access or iterate dictionary keys
.values()	Iterable view of values	Access or iterate dictionary values
.items()	Iterable view of (key, value) tuples	Simultaneously unpack keys and values in loops

Common Pitfalls

Mistake: Assuming get raises an error when a key is missing. Avoid: Check if the return value is None using conditional statements.
Mistake: Passing individual key and value arguments directly into update. Avoid: Wrap the target key-value pairs inside a dictionary literal within update.
Mistake: Passing a key argument to popitem expecting targeted deletion. Avoid: Call popitem without arguments or use pop with the specific key.

FAQs

What happens if I define duplicate keys when initializing a dictionary? Python retains only the last value assigned to that key, overwriting any previous assignments without raising an error.
Why does .get('missing_key') return None instead of an error? The get method is designed for safe lookups, returning None by default when a key does not exist so your program does not crash.
What is the difference between pop() and popitem()? The pop method requires a specific key argument to delete, whereas popitem takes no arguments and removes the most recently inserted pair.
How do dir() and help() differ when inspecting dictionaries? The dir function lists all attribute and method names as strings, while help prints interactive, detailed documentation describing what each method does.

Common pitfalls

Mistake: Assuming get raises an error when a key is missing. Avoid: Check if the return value is None using conditional statements.
Mistake: Passing individual key and value arguments directly into update. Avoid: Wrap the target key-value pairs inside a dictionary literal within update.
Mistake: Passing a key argument to popitem expecting targeted deletion. Avoid: Call popitem without arguments or use pop with the specific key.

Hey everybody, in today's video, I'm going to explain dictionaries. A dictionary is one of the four basic collection types for beginners. A dictionary consists of key-value pairs. They are ordered and changeable. No duplicates allowed. A few examples of key-value pairs could be: an ID and a name, an item and a price. But in today's example, we'll create a dictionary of countries and capitals. Let's name our dictionary capitals. capitals = Enclose your dictionary with a set of curly braces much like what you do with sets. The first country will be the USA. To add a value to this key, type colon, then some other value. The capital of the USA will be Washington, D.C. Separate each key-value pair with a comma. Then we can add another key-value pair. So the capital of India, that will be New Delhi. We'll add two more: China, the capital is Beijing; Russia, the capital is Moscow. I think that's good enough. Just as a reminder, if you would like to see all of the different attributes and methods of a dictionary, you can use the dir function, pass in your dictionary, capitals, then we'll need to print this. Here's all the different attributes and methods of a dictionary. If you would like an in-depth description of all these attributes and methods, you can use the help function. Uh that's herp. help, there we go. So yeah, that's just a reminder. All right, let's cover a few of the methods. To get one of the values from a dictionary, you would get the key. Type the name of the dictionary capitals.get Let's get the capital of the USA, then we'll print it. The value associated with this key, the USA, is Washington, D.C. If I picked a different country, like India, well then we would get that associated value, which is New Delhi. Another thing, if Python doesn't find a key, this is what will be returned. Let's get Japan, which is not in our dictionary. This method would return None. We can use this within an if statement. if capitals.get Japan if a value is returned, then we will print that capital exists. else we will print that capital doesn't exist. So, Japan is not in our dictionary, that capital doesn't exist, but Russia is, that capital does exist. That's how to check to see if a key is within our dictionary. You can use the get method. All right, moving on. Let's update our dictionary. capitals.update So within a set of curly braces, I will add a key, then a value. Germany followed by Berlin. Then let's print our dictionary. I'll use a print statement. print capitals Yeah, and there's Germany, right there. Using the update method, we can insert a new key-value pair or update an existing key-value pair. Let's also change one of the existing values. With our key USA, let's update the capital to be Detroit. Yeah, see, the value has been updated. The capital of the USA is now Detroit, Michigan. To remove a key-value pair, you can use the pop method, then pass in a key. Let's remove China. China no longer exists within our dictionary. It's gone. You can remove the latest key-value pair within a dictionary by using the popitem method. capitals.popitem With popitem, you don't need to pass in a key. popitem will remove the latest key-value pair that was inserted. Then we have clear. capitals.clear That will clear the dictionary. It's pretty self-explanatory. The next few methods are a little tricky to explain. To get all of the keys within the dictionary, but not the values, there is a keys method. capitals.keys I think I'm going to insert this within a variable. keys = capitals.keys Let's see what happens when we print this. The keys method will return all of the keys within our dictionary. Technically, keys is an object which resembles a list. I haven't discussed object-oriented programming yet. This is a little bit above our level. If you ever need the keys in a dictionary, you can use the keys method. One use is that we can use that within a for loop. They're iterable. for every key in capitals.keys method, let's print every key. If at any time you need to iterate over all the keys, you can use a for loop to iterate over every key that is returned from the keys method of your dictionary. There's also the values method. To get all of the values within your dictionary, there is a values method. values = capitals.values method Then let's print our values. Like before with the keys method, the values method will return an object which resembles a list. Let's iterate and print over every value within our dictionary. for every value in capitals.values print every value. Here are all the values within our dictionary. This next one is probably the most tricky. It is the items method. capitals.items I will assign what is returned to a variable named items, then we will print items. items returns a dictionary object which resembles a 2D list of tuples. It's really complicated. How might this be useful? This time we're going to use a for loop to print every key, value in capitals.items method. We have in essence two counters this time. I will print using an f-string every key-value pair. I will print every key as well as every value in our print statement. So there's our dictionary laid out. We have iterated over every key-value pair. It's kind of an advanced topic, but I thought I would at least bring it up now. So yeah, that's a dictionary, everybody. It's a collection of key-value pairs. They are ordered and changeable. No duplicates allowed. You have a bunch of different methods such as get, update, pop, popitem, clear. Then you can get the keys, the values, or both, which is the items method. We'll be using dictionaries in a few game programs we'll be making in the future. And well, yeah, those are dictionaries in Python.

Frequently asked questions

What happens if I define duplicate keys when initializing a dictionary?

Python retains only the last value assigned to that key, overwriting any previous assignments without raising an error.

Why does .get('missing_key') return None instead of an error?

The get method is designed for safe lookups, returning None by default when a key does not exist so your program does not crash.

What is the difference between pop() and popitem()?

The pop method requires a specific key argument to delete, whereas popitem takes no arguments and removes the most recently inserted pair.

How do dir() and help() differ when inspecting dictionaries?

The dir function lists all attribute and method names as strings, while help prints interactive, detailed documentation describing what each method does.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.