Dictionaries in Python are a fundamental data structure for storing key-value pairs. They offer a powerful and flexible way to manage and retrieve data, making them ideal for tasks that require fast lookups. Python provides numerous built-in functions and methods for working with dictionaries, allowing you to manipulate, access, and manage dictionary data effectively. This tutorial covers all built-in dictionary functions in Python with examples and explanations.
A dictionary in Python is an unordered, mutable, and indexed collection of key-value pairs. Each key in a dictionary must be unique, and keys are used to access the corresponding values. Dictionaries are defined using curly braces {} with key-value pairs separated by colons.
Dictionaries provide several advantages:
Here’s a complete list of Python’s built-in dictionary functions and methods.
update(): Updates the dictionary with elements from another dictionary or an iterable of key-value pairs.setdefault(): Returns the value of a key if it exists; if not, inserts the key with a specified default value.get(): Returns the value of a specified key.keys(): Returns a view object with all dictionary keys.values(): Returns a view object with all dictionary values.items(): Returns a view object with all key-value pairs in the dictionary.pop(): Removes and returns a specified key-value pair.popitem(): Removes and returns the last inserted key-value pair.clear(): Removes all elements from the dictionary.copy(): Returns a shallow copy of the dictionary.fromkeys(): Creates a new dictionary with keys from an iterable and a specified value for each key.len(): Returns the number of key-value pairs in the dictionary (not strictly a dictionary method but commonly used with dictionaries).in: Checks if a key exists in the dictionary.update([other]): Updates the dictionary with elements from another dictionary or iterable. If a key already exists, its value is updated; otherwise, a new key-value pair is added.
student = {"name": "Alice", "age": 20}
student.update({"age": 21, "grade": "A"})
print(student) # Output: {'name': 'Alice', 'age': 21, 'grade': 'A'}
setdefault(key[, default]): Returns the value of a specified key. If the key does not exist, inserts the key with the specified default value.
student = {"name": "Alice", "age": 20}
print(student.setdefault("age", 18)) # Output: 20
print(student.setdefault("grade", "B")) # Output: 'B'
print(student) # Output: {'name': 'Alice', 'age': 20, 'grade': 'B'}
get(key[, default]): Returns the value for a specified key. If the key does not exist, returns the specified default value (or None if no default is provided).
student = {"name": "Alice", "age": 20}
print(student.get("age")) # Output: 20
print(student.get("grade", "B")) # Output: 'B'
keys(): Returns a view object containing all keys in the dictionary.
student = {"name": "Alice", "age": 20}
print(student.keys()) # Output: dict_keys(['name', 'age'])
values(): Returns a view object containing all values in the dictionary.
student = {"name": "Alice", "age": 20}
print(student.values()) # Output: dict_values(['Alice', 20])
items(): Returns a view object containing all key-value pairs as tuples in a list.
student = {"name": "Alice", "age": 20}
print(student.items()) # Output: dict_items([('name', 'Alice'), ('age', 20)])
pop(key[, default]): Removes and returns the value for a specified key. If the key does not exist, it raises a KeyError unless a default value is provided.
student = {"name": "Alice", "age": 20}
age = student.pop("age")
print(age) # Output: 20
print(student) # Output: {'name': 'Alice'}
popitem(): Removes and returns the last inserted key-value pair as a tuple. Raises a KeyError if the dictionary is empty.
student = {"name": "Alice", "age": 20}
item = student.popitem()
print(item) # Output: ('age', 20)
print(student) # Output: {'name': 'Alice'}
clear(): Removes all elements from the dictionary, resulting in an empty dictionary.
student = {"name": "Alice", "age": 20}
student.clear()
print(student) # Output: {}
copy(): Returns a shallow copy of the dictionary.
student = {"name": "Alice", "age": 20}
student_copy = student.copy()
print(student_copy) # Output: {'name': 'Alice', 'age': 20}
fromkeys(keys, value): Creates a new dictionary with specified keys, each assigned a specified value (default is None).
keys = ["name", "age", "grade"]
student = dict.fromkeys(keys, "Unknown")
print(student) # Output: {'name': 'Unknown', 'age': 'Unknown', 'grade': 'Unknown'}
len(dict): Returns the number of key-value pairs in the dictionary.
student = {"name": "Alice", "age": 20}
print(len(student)) # Output: 2
in: Checks if a key exists in the dictionary.
student = {"name": "Alice", "age": 20}
print("name" in student) # Output: True
print("grade" in student) # Output: False
update() to add or modify multiple key-value pairs and setdefault() to add a new key with a default value.get() to avoid errors and use keys(), values(), and items() to retrieve dictionary components.pop() to remove specific elements, popitem() for the last added element, and clear() to empty the dictionary.copy() for shallow copies and fromkeys() to create a new dictionary with specified keys.Python’s built-in dictionary functions make it easy to manage and manipulate key-value pairs efficiently. These functions cover all essential operations, from adding and updating values to accessing, removing, and analyzing dictionary contents. By mastering these functions, you can make the most out of dictionaries in Python, allowing for efficient data storage and retrieval.
With Python’s dictionary functions, you can:
Ready to dive deeper into dictionaries in Python? Practice using these functions in real-world applications to unlock the full potential of dictionaries. Happy coding!