Python dictionary methods are the built-in functions that let you interact with, modify, and extract data from dictionaries — one of the most powerful data structures in Python. Whether you're retrieving values safely with dict.get(), syncing data with dict.update(), or looping through key-value pairs using dict.items(), python dictionary methods are something every Python developer uses daily. In this guide, you'll learn every essential python dictionary method with clear examples, detailed explanations, and real-world use cases so you can confidently apply python dict operations in your own projects.
Python dictionary methods are built-in functions attached to dictionary objects. You call them with dot notation — my_dict.method() — and they perform operations like searching, modifying, iterating, and copying dictionaries. Unlike standalone python dictionary functions, these methods operate directly on the dict object itself.
Python dictionaries store data as key-value pairs, and the python dictionary methods give you fine-grained control over how you access and manipulate those pairs.
student = {"name": "Alice", "age": 22, "grade": "A"}
print(student.keys()) # dict_keys(['name', 'age', 'grade'])
Every Python dict supports the same set of methods — there's no need to import anything extra. Let's go through each one.
dict.get() — Safe Value RetrievalThe dict.get() method retrieves the value for a given key. Unlike direct bracket access (dict[key]), python dict get() does not raise a KeyError if the key is missing — it returns None by default, or a fallback value you specify.
Syntax: dict.get(key, default=None)
config = {"theme": "dark", "language": "Python"}
print(config.get("theme")) # dark
print(config.get("font_size")) # None
print(config.get("font_size", 14)) # 14
Why it matters: When you python iterate dict values or build user-facing applications, keys may or may not be present. Using get() prevents unexpected crashes and keeps your python dict operations clean and safe.
dict.update() — Merge and Modify Dictionariesdict.update() merges another dictionary (or iterable of key-value pairs) into the current dictionary. If a key already exists, its value gets overwritten. This is one of the most commonly used python dictionary methods for syncing or extending data.
Syntax: dict.update([other])
profile = {"username": "dev_hardik", "level": 1}
updates = {"level": 5, "badge": "gold"}
profile.update(updates)
print(profile)
# {'username': 'dev_hardik', 'level': 5, 'badge': 'gold'}
You can also pass keyword arguments directly:
profile.update(city="Mumbai", verified=True)
print(profile)
# {'username': 'dev_hardik', 'level': 5, 'badge': 'gold', 'city': 'Mumbai', 'verified': True}
dict.update() modifies the dictionary in-place and returns None. It's ideal for building config systems, merging API responses, or patching records.
dict.keys(), dict.values(), dict.items() — Iterating a DictionaryThese three python dictionary methods give you views of a dictionary's contents — and they're the backbone of how you python iterate dict data.
dict.keys()Returns a view object of all keys in the dictionary.
inventory = {"apples": 10, "bananas": 5, "mangoes": 8}
print(inventory.keys()) # dict_keys(['apples', 'bananas', 'mangoes'])
dict.values()Returns a view object of all values.
print(inventory.values()) # dict_values([10, 5, 8])
dict.items()Returns a view object of all key-value pairs as tuples — the most commonly used of the three when you need to python iterate dict entries.
for item, qty in inventory.items():
print(f"{item}: {qty} units")
# apples: 10 units
# bananas: 5 units
# mangoes: 8 units
Important: These are live views, not static lists. If you modify the dictionary after calling .keys(), .values(), or .items(), the view reflects the change automatically. Convert to a list() if you need a snapshot.
dict.pop() — Remove and Return a Valuedict.pop(key, default) removes the specified key from the dictionary and returns its value. If the key doesn't exist and no default is provided, it raises a KeyError.
Syntax: dict.pop(key[, default])
cart = {"laptop": 1200, "mouse": 25, "keyboard": 75}
price = cart.pop("mouse")
print(price) # 25
print(cart) # {'laptop': 1200, 'keyboard': 75}
# Safe pop with default
price = cart.pop("monitor", 0)
print(price) # 0
Use pop() when you need to both remove an item and use its value — for example, processing tasks from a queue stored in a dict.
dict.popitem() — Remove the Last Inserted Itemdict.popitem() removes and returns the last inserted key-value pair as a tuple. This behavior is guaranteed in Python 3.7+ due to insertion-ordered dictionaries.
logs = {"login": "08:00", "request": "08:05", "logout": "09:30"}
last_entry = logs.popitem()
print(last_entry) # ('logout', '09:30')
print(logs) # {'login': '08:00', 'request': '08:05'}
If the dictionary is empty, popitem() raises a KeyError. This python dictionary method is useful for stack-like operations where LIFO (last in, first out) order matters.
dict.setdefault() — Insert if Key is Missingdict.setdefault(key, default) checks if a key exists. If it does, it returns its value unchanged. If it doesn't, it inserts the key with the given default value and returns that default.
Syntax: dict.setdefault(key, default=None)
scores = {"Alice": 90, "Bob": 85}
# Key exists — no change
scores.setdefault("Alice", 0)
print(scores["Alice"]) # 90
# Key missing — inserts with default
scores.setdefault("Carol", 70)
print(scores) # {'Alice': 90, 'Bob': 85, 'Carol': 70}
setdefault() is especially useful when building nested dictionaries or grouping data, because it lets you initialize missing keys without checking first:
grouped = {}
for word in ["apple", "avocado", "banana", "blueberry"]:
grouped.setdefault(word[0], []).append(word)
print(grouped)
# {'a': ['apple', 'avocado'], 'b': ['banana', 'blueberry']}
dict.copy() — Shallow Copy a Dictionarydict.copy() returns a shallow copy of the dictionary. Changes to the copy do not affect the original for top-level keys, but nested objects are still shared.
original = {"x": 1, "y": 2}
duplicate = original.copy()
duplicate["x"] = 99
print(original) # {'x': 1, 'y': 2} — unchanged
print(duplicate) # {'x': 99, 'y': 2}
For deep copies (where nested dicts are also independent), use Python's built-in copy.deepcopy().
dict.clear() — Empty a Dictionarydict.clear() removes all key-value pairs from the dictionary, leaving it empty. The dictionary object itself still exists in memory.
session = {"user": "hardik", "token": "abc123", "expires": 3600}
session.clear()
print(session) # {}
This is different from reassigning session = {}, which creates a brand new dict object. Use clear() when other parts of your code hold a reference to the same dictionary.
dict.fromkeys() — Create a Dictionary from Keysdict.fromkeys(iterable, value) is a class method that creates a new dictionary from a sequence of keys, all set to the same default value.
Syntax: dict.fromkeys(keys, value=None)
fields = ["name", "email", "phone"]
blank_form = dict.fromkeys(fields, "")
print(blank_form)
# {'name': '', 'email': '', 'phone': ''}
# Default value is None
status = dict.fromkeys(["active", "verified", "premium"])
print(status)
# {'active': None, 'verified': None, 'premium': None}
This python dictionary method is great for initializing forms, setting default feature flags, or building template structures.
This example brings together the core python dictionary methods in a realistic mini-application — a simple student record manager.
# student_records.py
# Demonstrates: get, update, items, keys, values,
# pop, setdefault, copy, clear, fromkeys
# --- Initialize Records ---
fields = ["name", "age", "course", "grade", "fee_paid"]
template = dict.fromkeys(fields, None)
print("Template:", template)
# Template: {'name': None, 'age': None, 'course': None, 'grade': None, 'fee_paid': None}
# --- Create a Student Record ---
student = {
"name": "Riya Sharma",
"age": 21,
"course": "Computer Science",
"grade": "B+",
}
# --- Safe Retrieval with get() ---
print("\nStudent Name:", student.get("name"))
print("Fee Status:", student.get("fee_paid", "Not recorded"))
# Student Name: Riya Sharma
# Fee Status: Not recorded
# --- Update with new data ---
student.update({"grade": "A", "fee_paid": True, "semester": 3})
print("\nAfter update:", student)
# After update: {'name': 'Riya Sharma', 'age': 21, 'course': 'Computer Science',
# 'grade': 'A', 'fee_paid': True, 'semester': 3}
# --- setdefault for optional fields ---
student.setdefault("scholarship", False)
print("Scholarship:", student["scholarship"])
# Scholarship: False
# --- Iterate with items() ---
print("\n--- Student Details ---")
for key, value in student.items():
print(f" {key.capitalize()}: {value}")
# --- Copy and modify safely ---
archived = student.copy()
archived.update({"status": "archived", "semester": None})
print("\nOriginal grade:", student["grade"]) # A (unchanged)
print("Archived status:", archived["status"]) # archived
# --- Pop a field ---
removed_semester = student.pop("semester")
print("\nRemoved semester value:", removed_semester)
print("Remaining keys:", list(student.keys()))
# --- Clear archived record ---
archived.clear()
print("\nArchived after clear:", archived) # {}
Output:
Template: {'name': None, 'age': None, 'course': None, 'grade': None, 'fee_paid': None}
Student Name: Riya Sharma
Fee Status: Not recorded
After update: {'name': 'Riya Sharma', 'age': 21, 'course': 'Computer Science', 'grade': 'A', 'fee_paid': True, 'semester': 3}
Scholarship: False
--- Student Details ---
Name: Riya Sharma
Age: 21
Course: Computer Science
Grade: A
Fee_paid: True
Semester: 3
Scholarship: False
Removed semester value: 3
Remaining keys: ['name', 'age', 'course', 'grade', 'fee_paid', 'scholarship']
Archived after clear: {}
For the complete reference on python dictionary methods, visit the official Python documentation on dictionaries.
Ready to go deeper? This guide is part of a complete Python tutorial series covering everything from basics to advanced topics. Whether you're just starting out or looking to sharpen your skills, the full series has you covered. Learn the full Python tutorial here.