Python · Dictionaries
Removing Elements
The full text of this chapter, to read or revisit. To practise, do the exercises.
▶ Do the exercisesExercise 1 — Introduction to Removing Dictionary Elements
Python provides several ways to remove elements from a dictionary. Each method has its own use case and behavior:
-
del
- Removes an item by key (raises error if key doesn't exist)
-
pop()
- Removes an item and returns its value (can provide default)
-
popitem()
- Removes and returns the last inserted key-value pair
-
clear()
- Removes all items from the dictionary
Exercise 2 — The del Statement
The
del
statement is the simplest way to remove an item from a dictionary. You just specify the key you want to delete:
del dictionary[key]
codemon = {
"name": "Pyrochu",
"type": "fire",
"level": 20,
"power": 80
}
print("Before deletion:", codemon)
# Remove the 'power' key
del codemon["power"]
print("After deleting power:", codemon)
# Remove the 'type' key
del codemon["type"]
print("After deleting type:", codemon)
KeyError with del
If you try to delete a key that doesn't exist, Python will raise a
KeyError
. Always make sure the key exists before using
del
, or use
pop()
with a default value instead.
Exercise 3 — Understanding del Behavior
What will happen when running this code?
codemon = {"name": "Florachu", "type": "plant"}
del codemon["level"]
print(codemon)
Options
• A ```KeyError``` will be raised because 'level' doesn't exist
• The code will print ```{'name': 'Florachu', 'type': 'plant'}```
• The code will print an empty dictionary ```{}```
• The ```del``` statement will do nothing and the original dictionary will be printed
Hint : Remember that ```del``` raises a ```KeyError``` if you try to delete a key that doesn't exist in the dictionary.
Exercise 4 — The pop() Method
The
pop()
method removes a key from the dictionary and returns its value. Unlike
del
, you can provide a default value to return if the key doesn't exist:
value = dictionary.pop(key)
# or with default
value = dictionary.pop(key, default_value)
codemon = {
"name": "Aquachu",
"type": "water",
"level": 15,
"power": 75
}
# pop() returns the value
power = codemon.pop("power")
print("Removed power:", power)
print("Dictionary after pop:", codemon)
# Using pop() with a default value
experience = codemon.pop("experience", 0)
print("Experience (with default):", experience)
print("Dictionary after second pop:", codemon)
Why Use pop()?
Use
pop()
when you need to retrieve the value before removing it, or when you want to provide a default value if the key doesn't exist. This makes your code safer and more flexible than using
del
.
Exercise 5 — Using pop() with Defaults
Complete the code to safely remove the "trainer" key from the dictionary. If it doesn't exist, use "Unknown" as the default value.
codemon = {
"name": "Pyrochu",
"type": "fire",
"level": 18
}
trainer_name = codemon.____(____________)
print("Trainer:", trainer_name)
Options: pop remove delete "trainer" trainer , : "Unknown" Unknown
Hint : Remember the syntax: ```dictionary.pop(key, default_value)```. The default value is optional but useful for safe operations.
Exercise 6 — The popitem() Method
The
popitem()
method removes and returns the last inserted key-value pair as a tuple. This is useful when you need to process items one by one:
key, value = dictionary.popitem()
codemon = {
"name": "Florachu",
"type": "plant",
"level": 16,
"power": 70
}
print("Original:", codemon)
# Remove the last inserted item
key, value = codemon.popitem()
print(f"Removed: {key} = {value}")
print("After first popitem:", codemon)
# Remove another item
key, value = codemon.popitem()
print(f"Removed: {key} = {value}")
print("After second popitem:", codemon)
Empty Dictionary Error
If you call
popitem()
on an empty dictionary, Python will raise a
KeyError
. Always check if the dictionary is not empty before using
popitem()
.
Exercise 7 — pop() vs popitem()
What is the main difference between
pop()
and
popitem()
?
Options
• ```pop()``` requires a key and returns only the value, while ```popitem()``` removes the last item and returns both key and value
• ```pop()``` removes the last item while ```popitem()``` requires a key
• They are exactly the same, just different names
• ```pop()``` can only be used once while ```popitem()``` can be used multiple times
Hint : Think about what parameters each method needs and what they return.
Exercise 8 — The clear() Method
The
clear()
method removes all items from a dictionary, leaving it empty. This is useful when you want to reset a dictionary:
dictionary.clear()
codemon = {
"name": "Aquachu",
"type": "water",
"level": 15,
"power": 75
}
print("Before clear:", codemon)
print("Dictionary has", len(codemon), "items")
codemon.clear()
print("After clear:", codemon)
print("Dictionary has", len(codemon), "items")
clear() vs Creating New Dictionary
Using
dictionary.clear()
is different from
dictionary = {}
. The
clear()
method empties the existing dictionary object, while
dictionary = {}
creates a new empty dictionary. This matters when other variables reference the same dictionary.
Exercise 9 — Choosing the Right Removal Method
Complete the code with the appropriate removal methods:
codemon = {
"name": "Pyrochu",
"type": "fire",
"level": 20,
"power": 80
}
# Remove 'power' without needing its value
____ codemon["power"]
print(codemon)
# Remove 'type' and store its value
codemon_type = codemon.____("type")
print(codemon_type)
# Empty the entire dictionary
codemon.____()
print(codemon)
Options: del remove pop popitem clear delete empty
Hint : Think about when you need the value (```pop()```), when you just want to remove (```del```), and when you want to empty everything (```clear()```).
Exercise 10 — Match Methods with Their Purposes
Match each removal method with its best use case:
Items to match
• del dictionary[key]
• dictionary.pop(key)
• dictionary.popitem()
• dictionary.clear()
Definitions
• Remove an item when you don't need its value
• Remove an item and get its value safely
• Remove and return the last inserted key-value pair
• Remove all items from the dictionary
Exercise 11 — Safe Removal Practice
Which of these is the safest way to remove a key that might not exist in the dictionary?
Options
• ```codemon.pop("trainer", None)```
• ```del codemon["trainer"]```
• ```codemon.popitem()```
• ```codemon.clear()```
Hint : Think about which method won't raise an error if the key doesn't exist.
Exercise 12 — Challenge: Managing Codémon Stats
You need to clean up and manage your Codémon's stats! Use the appropriate removal methods for each situation.
1. Remove the
"nickname"
key (you don't need its value)
2. Remove the
"experience"
key and print its value (if it doesn't exist, use
0
as default)
3. Remove the last inserted key-value pair and print what was removed
4. Print the final cleaned dictionary
Starter code
codemon = {
"name": "Aquachu",
"type": "water",
"level": 25,
"power": 85,
"nickname": "Splash",
"hp": 150
}
print("=== CLEANING CODEMON ===")
print("Original:", codemon)
# 1. Remove 'nickname' (you don't need its value)
# 2. Remove 'experience' and print its value (default 0)
# 3. Remove last inserted key-value pair and print it
# 4. Print final cleaned dictionary
print("\n=== FINAL RESULT ===")