Introduction

Python provides several built-in methods for working with dictionaries. These methods make it easier to retrieve values, access keys and values, add or update items, remove entries, create copies, and perform other common dictionary operations.
While the Dictionaries in Python article covers the basic structure, creation, access, and use of dictionaries, this article focuses on the methods provided specifically for dictionaries.
Some commonly used dictionary methods include get(), keys(), values(), items(), update(), setdefault(), pop(), popitem(), clear(), copy(), and fromkeys().

Table of Contents

---

What Are Dictionary Methods?

Dictionary methods are built-in operations that can be called on a dictionary to retrieve information or modify its contents.

Syntax:

dictionary_name.method_name()

For example, the keys() method returns a view containing the keys of a dictionary.

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
print(student.keys())

Output:

dict_keys(['name', 'age', 'course'])

Dictionary methods can be broadly used for retrieving information, modifying dictionary contents, or creating new dictionary objects.

get() Method

The get() method returns the value associated with a specified key. If the key does not exist, it returns None by default instead of raising a KeyError.

Syntax:

dictionary.get(key, default)

The default argument is optional. It specifies the value to return when the key is not found.

Example:

student = {
    "name": "Rahul",
    "age": 20
}
print(student.get("name"))
print(student.get("course"))

Output:

Rahul
None

A custom default value can also be provided.

student = {
    "name": "Rahul",
    "age": 20
}
print(student.get("course", "Not Available"))

Output:

Not Available

The get() method is useful when a key may not exist, and the program should handle the missing key without raising an exception.

keys() Method

The keys() method returns a view containing all the keys in a dictionary.

Syntax:

dictionary.keys()

Example:

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
print(student.keys())

Output:

dict_keys(['name', 'age', 'course'])

The returned view can also be converted into a list when a list is required.

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
keys_list = list(student.keys())
print(keys_list)

Output:

['name', 'age', 'course']

The keys() method is commonly used when a program needs to iterate through or work specifically with dictionary keys.

values() Method

The values() method returns a view containing all the values stored in a dictionary.

Syntax:

dictionary.values()

Example:

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
print(student.values())

Output:

dict_values(['Rahul', 20, 'Python'])

The values can also be converted into a list.

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
values_list = list(student.values())
print(values_list)

Output:

['Rahul', 20, 'Python']

Unlike dictionary keys, values do not need to be unique. The same value can occur multiple times.

students = {
    "student1": "Python",
    "student2": "Python",
    "student3": "C++"
}
print(students.values())

Output:

dict_values(['Python', 'Python', 'C++'])

items() Method

The items() method returns a view containing all the key-value pairs in a dictionary. Each pair is represented as a tuple.

Syntax:

dictionary.items()

Example:

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
print(student.items())

Output:

dict_items([('name', 'Rahul'), ('age', 20), ('course', 'Python')])

The items() method is especially useful when both keys and values are required while iterating through a dictionary.

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
for key, value in student.items():
    print(key, value)

Output:

name Rahul
age 20
course Python

update() Method

The update() method adds new key-value pairs to a dictionary or changes the values of existing keys.

Syntax:

dictionary.update(iterable)

It can be used to add or update multiple dictionary entries at once.

Example:

student = {
    "name": "Rahul",
    "age": 20
}
student.update({
    "age": 21,
    "course": "Python"
})
print(student)

Output:

{'name': 'Rahul', 'age': 21, 'course': 'Python'}

Here, the existing age value is updated, while the new course key-value pair is added.

The method can also be used with keyword arguments.

student = {
    "name": "Rahul"
}
student.update(age=20, course="Python")
print(student)

Output:

{'name': 'Rahul', 'age': 20, 'course': 'Python'}

setdefault() Method

The setdefault() method returns the value of a specified key. If the key does not exist, it adds the key with a specified default value and returns that value.

Syntax:

dictionary.setdefault(key, default)

Example:

student = {
    "name": "Rahul",
    "age": 20
}
result = student.setdefault("course", "Python")
print(result)
print(student)

Output:

Python
{'name': 'Rahul', 'age': 20, 'course': 'Python'}

If the key already exists, setdefault() returns its existing value and does not replace it.

student = {
    "name": "Rahul",
    "age": 20
}
result = student.setdefault("age", 25)
print(result)
print(student)

Output:

20
{'name': 'Rahul', 'age': 20}

This makes setdefault() useful when a key should be created only if it does not already exist.

pop() Method

The pop() method removes the specified key from a dictionary and returns its associated value.

Syntax:

dictionary.pop(key, default)

The default argument is optional. It can be used to provide a value when the specified key does not exist.

Example:

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
removed_value = student.pop("age")
print(removed_value)
print(student)

Output:

20
{'name': 'Rahul', 'course': 'Python'}

If the key does not exist and no default value is provided, pop() raises a KeyError.

A default value can be provided to avoid this error.

student = {
    "name": "Rahul"
}
result = student.pop("age", "Not Found")
print(result)

Output:

Not Found

popitem() Method

The popitem() method removes and returns the last inserted key-value pair from a dictionary.

Syntax:

dictionary.popitem()

Example:

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
item = student.popitem()
print(item)
print(student)

Output:

('course', 'Python')
{'name': 'Rahul', 'age': 20}

Unlike pop(), popitem() does not take a key. It removes the last inserted key-value pair.

If popitem() is called on an empty dictionary, it raises a KeyError.

clear() Method

The clear() method removes all key-value pairs from a dictionary. The dictionary itself remains available as an empty dictionary.

Syntax:

dictionary.clear()

Example:

student = {
    "name": "Rahul",
    "age": 20,
    "course": "Python"
}
student.clear()
print(student)

Output:

{}

The clear() method is useful when all existing entries need to be removed from a dictionary.

copy() Method

The copy() method creates a shallow copy of a dictionary. The returned dictionary is a separate dictionary object containing the same key-value pairs.

Syntax:

dictionary.copy()

Example:

student = {
    "name": "Rahul",
    "age": 20
}
student_copy = student.copy()
student_copy["age"] = 21
print(student)
print(student_copy)

Output:

{'name': 'Rahul', 'age': 20}
{'name': 'Rahul', 'age': 21}

Changing the top-level contents of the copied dictionary does not change the original dictionary.

However, copy() creates a shallow copy. If a dictionary contains mutable nested objects, those nested objects may still be shared between the original and copied dictionaries.

fromkeys() Method

The fromkeys() method creates a new dictionary using the specified values as keys. All keys are assigned the same value.

Syntax:

dict.fromkeys(keys, value)

The value argument is optional. If it is not provided, the values default to None.

Example:

keys = ["name", "age", "course"]
student = dict.fromkeys(keys)
print(student)

Output:

{'name': None, 'age': None, 'course': None}

A common value can also be provided.

keys = ["math", "science", "english"]
marks = dict.fromkeys(keys, 0)
print(marks)

Output:

{'math': 0, 'science': 0, 'english': 0}

Comparing Dictionary Methods

Several dictionary methods perform related tasks but behave differently. Understanding these differences helps in selecting the appropriate method for a particular situation.

1. get() vs Square Bracket Access

Both approaches can be used to retrieve a value using a key. The main difference is how they behave when the key does not exist.

Feature	get()	Square Brackets []
Syntax	d.get("key")	d["key"]
Missing key	Returns None or a default value	Raises KeyError
Can provide default	Yes	No
Modifies dictionary	No	No

2. pop() vs popitem()

Both methods remove dictionary entries, but they differ in how the entry to be removed is selected.

Feature	pop()	popitem()
Removes	A specified key	Last inserted key-value pair
Requires a key	Yes	No
Returns	Removed value	Removed key-value pair
Empty dictionary	Raises KeyError if key is not found and no default is provided	Raises KeyError

3. keys() vs values() vs items()

These methods provide different views of the contents of a dictionary.

Method	Returns	Common use
keys()	Dictionary keys	Working with keys
values()	Dictionary values	Working with values
items()	Key-value pairs	Working with keys and values together

4. update() vs Direct Assignment

Both approaches can add or modify dictionary entries, but they are useful in different situations.

Feature	update()	Direct Assignment
Syntax	d.update({"a": 1})	d["a"] = 1
Multiple items	Can add or update multiple items	Normally handles one key at a time
Existing keys	Values are updated	Value is updated
New keys	Added	Added

5. copy() vs Assignment

Assignment and copying behave differently when another dictionary variable is created.

Feature	copy()	Assignment
Example	d2 = d1.copy()	d2 = d1
Creates separate dictionary	Yes	No
Changes to top-level data affect original	No	Yes
Type of copy	Shallow copy	Same object reference

Practical Examples of Dictionary Methods

Dictionary methods are commonly used together when processing real-world data. The following examples demonstrate how multiple methods can simplify common programming tasks.

1. Safely Accessing Optional Data

The get() method can be used when a dictionary may not contain a particular key.

user = {
    "name": "Rahul",
    "email": "rahul@example.com"
}
phone = user.get("phone", "Not Provided")
print(phone)

Output:

Not Provided

This avoids a KeyError when the optional key is missing.

2. Updating a User Record

The update() method can modify several related values at once.

user = {
    "name": "Rahul",
    "age": 20
}
user.update({
    "age": 21,
    "city": "Delhi"
})
print(user)

Output:

{'name': 'Rahul', 'age': 21, 'city': 'Delhi'}

3. Removing and Using a Value

The pop() method is useful when an item needs to be removed, and its value is also required.

cart = {
    "item": "Laptop",
    "price": 50000,
    "quantity": 1
}
price = cart.pop("price")
print(price)
print(cart)

Output:

50000
{'item': 'Laptop', 'quantity': 1}

4. Displaying Dictionary Data

The items() method can be used to process keys and values together.

marks = {
    "Math": 85,
    "Science": 90,
    "English": 88
}
for subject, mark in marks.items():
    print(subject, ":", mark)

Output:

Math : 85
Science : 90
English : 88

5. Creating a Dictionary with Default Values

The fromkeys() method can create a dictionary where several keys initially share the same value.

subjects = ["Math", "Science", "English"]

marks = dict.fromkeys(subjects, 0)

print(marks)

Output:

{'Math': 0, 'Science': 0, 'English': 0}

Edge Cases

Dictionary methods have specific behaviors that should be understood to avoid unexpected results.

• get() returns None for a missing key when no default is provided.
• get() does not add a missing key to the dictionary.
• keys(), values(), and items() return dictionary view objects rather than ordinary lists.
• update() replaces values when the supplied keys already exist.
• setdefault() does not replace the existing value when the key is already present.
• pop() raises KeyError for a missing key when no default is provided.
• popitem() raises KeyError when called on an empty dictionary.
• clear() removes all entries but does not delete the dictionary object.
• copy() creates a shallow copy, not a deep copy.
• fromkeys() assigns the same supplied value to every created key.

Common Mistakes

Many beginner mistakes occur because dictionary methods have similar purposes but different behaviors.

• Using square bracket access when a missing key is expected to be possible.
• Assuming get() automatically adds a missing key.
• Expecting keys(), values(), or items() to return lists directly.
• Using popitem() when a specific key needs to be removed.
• Calling pop() without handling a possible missing key.
• Assuming copy() creates a completely independent deep copy of nested objects.
• Assuming setdefault() replaces an existing value.
• Using clear() when only one dictionary entry needs to be removed.
• Assuming update() creates a new dictionary instead of modifying the existing one.

Important Rules for Dictionary Methods

The following rules summarize the important behavior of Python dictionary methods.

• get() retrieves a value without raising an error for a missing key when a suitable default is used.
• keys() returns a view of dictionary keys.
• values() returns a view of dictionary values.
• items() returns a view of key-value pairs.
• update() adds new entries and updates existing entries.
• setdefault() adds a key only when it does not already exist.
• pop() removes a specified key and returns its value.
• popitem() removes and returns the last inserted key-value pair.
• clear() removes all dictionary entries.
• copy() creates a shallow copy of a dictionary.
• fromkeys() creates a new dictionary from specified keys.
• Methods such as update(), setdefault(), pop(), popitem(), and clear() can modify the dictionary.

Quick Reference Table

The following table provides a quick overview of the dictionary methods discussed in this article.

Method	Syntax	Purpose
get()	d.get(key, default)	Retrieve a value safely
keys()	d.keys()	Return dictionary keys
values()	d.values()	Return dictionary values
items()	d.items()	Return key-value pairs
update()	d.update(data)	Add or update entries
setdefault()	d.setdefault(key, default)	Get a value or add a missing key
pop()	d.pop(key, default)	Remove a specified key
popitem()	d.popitem()	Remove the last inserted key-value pair
clear()	d.clear()	Remove all entries
copy()	d.copy()	Create a shallow copy
fromkeys()	dict.fromkeys(keys, value)	Create a dictionary from keys

Conclusion

Dictionary methods provide convenient ways to work with key-value data in Python. Methods such as get(), keys(), values(), and items() make it easier to retrieve and process dictionary data, while methods such as update(), setdefault(), pop(), and clear() help modify dictionary contents.
Methods such as copy() and fromkeys() are useful for creating dictionaries or dictionary copies for specific situations. Understanding the behavior of each method helps avoid common errors and makes dictionary-based programs easier to write and maintain.
For the basic structure, creation, access, iteration, and use of dictionaries, see the Dictionaries in Python article.

Frequently Asked Questions (FAQs)

Here are some common questions beginners may have when working with dictionary methods in Python. These questions cover the purpose, behavior, and common uses of the methods discussed in this article.

1. What are dictionary methods in Python?

Dictionary methods are built-in methods used to retrieve, modify, remove, copy, or otherwise work with dictionary data. Examples include get(), keys(), values(), items(), and update().

2. What does the get() method do in Python?

The get() method returns the value associated with a specified key. If the key does not exist, it returns None by default or a specified default value.

3. What is the difference between get() and square bracket access?

Both can retrieve a dictionary value using a key. However, get() returns None or a specified default value when the key is missing, while square bracket access raises a KeyError.

4. What do keys(), values(), and items() return?

keys() returns a view of the dictionary's keys, values() returns a view of its values, and items() returns a view containing its key-value pairs.

5. What does the update() method do?

The update() method adds new key-value pairs and updates the values of existing keys in a dictionary.