Python Dictionary Tutorial
Introduction
Python dictionaries are a built-in data type used to store key-value pairs. They are mutable and allow for efficient retrieval and manipulation of data. Dictionaries are defined using curly braces ({}) and contain comma-separated key-value pairs. Here’s an example:
person = {
"name": "Yash",
"age": 23,
"occupation": "Architect"
}
In this example, “name”, “age”, and “occupation” are the keys, and “Yash”, 23, and “Architect” are the corresponding values. The keys must be unique within a dictionary, but the values can be of any data type.
You can access the values in a dictionary by using the corresponding key:
print(person["name"]) # Output: Yash
print(person["age"]) # Output: 23
print(person["occupation"]) # Output: Architect
Features of Python Dictionary:
- Key-Value Pairs: Python dictionaries are a collection of key-value pairs, where each key is unique and associated with a value. The key-value pairs allow for efficient lookup and retrieval of data.
- Mutable: Dictionaries are mutable, which means you can modify, add, or remove key-value pairs after the dictionary is created. This flexibility allows for dynamic updates and changes to the data stored in the dictionary.
- Dynamic Sizing: Dictionaries in Python can dynamically resize to accommodate an arbitrary number of key-value pairs. As you add more items, the dictionary automatically adjusts its size to fit the data.
- Unordered: Dictionaries are unordered, meaning the items are not stored in any particular order. The order in which you add items to a dictionary may not be preserved when iterating or accessing the items. If you need a specific order, you can use an ordered dictionary from the `collections` module.
- Efficient Data Retrieval: Dictionaries provide fast and efficient data retrieval based on the key. Instead of iterating over all the items, you can directly access a value by providing its associated key. This makes dictionaries suitable for scenarios where quick access to data is required.
- Various Data Types: Python dictionaries can store values of any data type, including integers, floats, strings, lists, tuples, other dictionaries, and even custom objects. This flexibility allows you to organize and structure data in a way that suits your specific needs.
- Membership Testing: Dictionaries provide efficient membership testing using the `in` operator. You can check if a key exists in a dictionary without iterating over all the items, making it convenient for conditional operations.
- Dictionary Methods: Python dictionaries come with built-in methods that allow you to perform various operations. Some commonly used methods include `keys()` to retrieve all the keys, `values()` to retrieve all the values, `items()` to retrieve key-value pairs as tuples, and `get()` to safely retrieve a value with a default if the key does not exist.
- Hashable Keys: Dictionary keys in Python must be hashable, meaning they should have a hash value that remains constant during their lifetime. Immutable data types like strings, integers, and tuples (containing only hashable elements) can be used as keys, while mutable types like lists or dictionaries themselves cannot.
Advantages of Python Dictionary:
- Efficient Data Retrieval: Python dictionaries provide fast and efficient data retrieval based on keys. They use a hash table implementation, which allows for constant-time lookup regardless of the dictionary size. This makes dictionaries ideal for scenarios where quick access to data is required.
- Flexibility: Dictionaries in Python can store values of any data type, allowing you to organize and structure data in a way that suits your needs. You can use different data types as keys and values within the same dictionary, making it versatile for various applications.
- Dynamic Updates: Dictionaries are mutable, meaning you can add, modify, or remove key-value pairs after the dictionary is created. This flexibility enables you to dynamically update and manipulate data within the dictionary, making it adaptable to changing requirements.
- Uniqueness of Keys: Python dictionary keys must be unique. This property ensures that each key is associated with a single value, preventing duplicate entries. It allows you to uniquely identify and access data based on specific keys, maintaining data integrity.
- Membership Testing: Dictionaries provide efficient membership testing using the `in` operator. You can quickly check if a key exists in a dictionary without iterating over all the items. This feature is useful for conditional operations and avoiding potential errors when accessing non-existent keys.
- Versatile Use Cases: Python dictionaries have a wide range of applications. They are commonly used for tasks such as caching, indexing, data modeling, configuration management, and more. Dictionaries provide a convenient way to store and access data based on meaningful keys, improving code readability and maintainability.
- Integration with Other Data Structures: Python dictionaries can be easily integrated with other data structures. For example, you can have lists or tuples as values in a dictionary, allowing you to create more complex and nested data structures. This enables you to represent and manipulate data in a hierarchical or structured manner.
- Built-in Dictionary Methods: Python dictionaries come with built-in methods that provide convenient ways to perform various operations. These methods include `keys()`, `values()`, `items()`, `get()`, `pop()`, and more. They allow you to retrieve keys, values, key-value pairs, safely access values with defaults, and manipulate the dictionary efficiently.
- Memory Efficiency: Python dictionaries are memory-efficient compared to other data structures like lists. They optimize memory usage by utilizing hash tables and only allocate memory for the keys and values actually stored in the dictionary. This makes dictionaries suitable for handling large amounts of data with minimal memory footprint.
Disadvantages of Python Dictionary:
- Unordered: Dictionaries in Python are unordered, meaning the items are not stored in a predictable order. The order in which you add items to a dictionary may not be preserved when iterating or accessing the items. If you require a specific order, you would need to use an ordered dictionary from the `collections` module.
- Memory Overhead: Python dictionaries consume more memory compared to other data structures like lists or tuples. The overhead is due to the hash table implementation, which requires additional memory to store the hash values, key-value pairs, and internal data structures. If memory efficiency is a concern, alternative data structures may be more suitable.
- Hashable Keys Requirement: Dictionary keys in Python must be hashable, meaning they should have a hash value that remains constant during their lifetime. This requirement restricts the use of mutable data types like lists or dictionaries as keys. It can sometimes limit the flexibility of using certain data structures or objects as keys.
- Lack of Indexing: Unlike sequences such as lists or tuples, dictionaries do not support indexing. You cannot access items in a dictionary using numeric indices, as they are accessed through keys. If you need to access items based on a specific position or order, dictionaries may not be the ideal choice.
- Slow Iteration with Large Dictionaries: Iterating over large dictionaries can be slower compared to iterating over sequences. As dictionaries are unordered, iterating through the items may require more time due to the internal structure of hash tables. If you need to perform operations that involve iterating through all the items, an alternative data structure may be more efficient.
- No Preserved Duplicate Keys: Python dictionaries do not allow duplicate keys. If you attempt to add a key that already exists in the dictionary, the value associated with the existing key will be overwritten. This can lead to unintentional data loss or incorrect results if duplicate keys are mistakenly introduced.
- Lack of Deterministic Order: The order of items in a dictionary can vary across different Python versions or implementations. Although dictionaries maintain their internal order consistently within a single execution, the order may differ when running the same code in different environments. This lack of deterministic order can sometimes lead to unexpected behavior or inconsistencies.
- Key Error on Non-existent Keys: When accessing a non-existent key in a dictionary using square brackets (`[]`), Python raises a `KeyError` exception. This can be problematic if you are not certain whether a key exists in the dictionary. You can mitigate this issue by using the `get()` method, which allows you to provide a default value if the key is not found.
Indexing in Python Dictionary:
Indexing is not directly supported in Python dictionaries because they are unordered collections of key-value pairs. Unlike sequences like lists or tuples where you can access elements using numeric indices, dictionaries are accessed by their keys.
- Accessing Values by Key: You can retrieve the value associated with a specific key using square brackets (`[]`) and providing the key as the index. Here’s an example:
my_dict = {"name": "Yash", "age": 23, "occupation": "Architect"}
print(my_dict["name"]) # Output: Yash
print(my_dict["age"]) # Output: 23
By specifying the key within the square brackets, you can access the corresponding value from the dictionary.
- Using the `get()` Method: The `get()` method provides a way to access dictionary values by key while also handling non-existent keys gracefully. If the key is present, the method returns the associated value. If the key does not exist, it returns a default value specified as the second argument. Here’s an example:
my_dict = {"name": "Yash", "age": 23, "occupation": "Architect"}
print(my_dict.get("name")) # Output: Yash
print(my_dict.get("city", "N/A")) # Output: N/A (default value for non-existent key)
In the above example, `my_dict.get(“name”)` returns the value “Yash” since the key “name” is present. The `my_dict.get(“city”, “N/A”)` call returns “N/A” as the default value because the key “city” is not found in the dictionary.
Python Dictionary functions:
- `len()` function: Returns the number of key-value pairs in a dictionary.
dictionary = {"name": "Yash", "age": 23}
print(len(dictionary)) # Output: 2
- `keys()` method: Returns a view object that contains all the keys in a dictionary.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
keys = dictionary.keys()
print(keys) # Output: dict_keys(['name', 'age', 'occupation'])
- `values()` method: Returns a view object that contains all the values in a dictionary.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
values = dictionary.values()
print(values) # Output: dict_values([Yash, 22,Architect])
- `items()` method: Returns a view object that contains all the key-value pairs as tuples in a dictionary.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
items = dictionary.items()
print(items) # Output: dict_items([('name', 'Yash'), ('age',23), ('occupation', 'Architect')])
- `get()` method: Returns the value associated with a given key. It allows specifying a default value to be returned if the key is not found.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
print(dictionary.get("name")) # Output: Yash
print(my_dict.get("city", "N/A")) # Output: N/A (default value for non-existent key)
- `pop()` method: Removes and returns the value associated with a given key. It takes the key as an argument and removes the corresponding key-value pair from the dictionary.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
removed_value = dictionary.pop("age")
print(removed_value) # Output: 25
print(dictionary) # Output: {'name': 'Yash', 'occupation': 'Architect'}
- `update()` method: Merges the key-value pairs from another dictionary into the current dictionary. If a key already exists, the value is updated; otherwise, a new key-value pair is added.
dictionary = {"name": "Yeah", "age": 23}
new_dict = {"occupation": "Architect", "city": "Pune"}
dictionary.update(new_dict)
print(dictionary) # Output: {'name': 'Yash', 'age': 23, 'occupation': 'Architect', 'city': 'Pune'}
- `clear()` method: Removes all key-value pairs from a dictionary, making it empty.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
dictionary.clear()
print(dictionary) # Output: {}
Python Dictionary operators:
- Membership Operators:
– `in` operator: Returns `True` if a key exists in the dictionary, otherwise `False`.
– `not in` operator: Returns `True` if a key does not exist in the dictionary, otherwise `False`.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
print("name" in dictionary) # Output: True
print("Company" not in dictionary) # Output: True
print("age" in dictionary.keys()) # Output: True
print("Engineer" in dictionary.values()) # Output: False
- Comparison Operators:
– `==` operator: Returns `True` if two dictionaries have the same key-value pairs, otherwise `False`.
– `!=` operator: Returns `True` if two dictionaries have different key-value pairs, otherwise `False`.
dict1 = {"name": "Yash", "age": 23}
dict2 = {"age": 23, "name": "Yash"}
print(dict1 == dict2) # Output: True (order of key-value pairs doesn't matter)
print(dict1 != dict2) # Output: False (key-value pairs are the same)
- Assignment Operator:
– `=` operator: Assigns a dictionary to a variable.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
- Deletion Operator:
– `del` operator: Deletes an entire dictionary or a specific key-value pair.
dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
del dictionary ["age"]
print(dictionary) # Output: {'name': 'Yash', 'occupation': 'Architect'}