A dictionary in Python is an unordered collection of key-value pairs, where each key is unique and associated with a value. Dictionaries are represented by curly braces ({}) and each key-value pair is separated by a colon (:). Here’s an example of a dictionary:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
In this example, the keys are ‘apple’, ‘banana’, and ‘cherry’, and their corresponding values are 2, 3, and 4, respectively.
Dictionary Operations
Python dictionaries provide a wide range of operations for adding, removing, and accessing elements. Here are some of the most common operations:
Creating a Dictionary
In Python, we can create a dictionary using curly braces {} or the built-in dict() function. A dictionary is a collection of key-value pairs, where each key is associated with a value. The key-value pairs are separated by a colon : and individual pairs are separated by commas ,. Here’s an example of creating a dictionary using curly braces:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
In the example above, we create a dictionary my_dict with three key-value pairs: 'apple': 2, 'banana': 3, and 'cherry': 4. You can also create a dictionary using the dict() function. The dict() function takes an iterable of key-value pairs and returns a dictionary. Here’s an example:
my_dict = dict([('apple', 2), ('banana', 3), ('cherry', 4)])
print(my_dict)
#{'apple': 2, 'banana': 3, 'cherry': 4}
In the example above, we create a dictionary my_dict using the dict() function and a list of key-value pairs. The resulting dictionary is the same as the one created using curly braces. You can also create an empty dictionary using either curly braces or the dict() function:
empty_dict = {}
empty_dict = dict()
In both cases, we create an empty dictionary.
It’s important to note that keys in a dictionary must be unique, and they can only be of an immutable type such as strings, numbers, or tuples. Values can be of any type, including mutable types such as lists or other dictionaries.
In terms of time and space complexity, creating a dictionary has a time complexity of O(n), where n is the number of key-value pairs in the dictionary. The space complexity is also O(n), since the dictionary stores all the key-value pairs.
Accessing Elements
In Python, you can access elements in a dictionary using the keys. Since a dictionary is a collection of key-value pairs, you can retrieve the value associated with a key by specifying the key in square brackets []. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
print(my_dict['banana'])
# Output: 3
In the example above, we access the value associated with the key 'banana' in the dictionary my_dict. If the key doesn’t exist in the dictionary, you’ll get a KeyError. To avoid this, you can use the get() method, which returns the value associated with the key if it exists, or a default value if it doesn’t. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
print(my_dict.get('orange', 0))
# Output: 0
In the example above, we use the get() method to retrieve the value associated with the key 'orange' in the dictionary my_dict. Since the key doesn’t exist in the dictionary, the method returns the default value 0.
It’s important to note that accessing an element in a dictionary has a time complexity of O(1), since the dictionary uses a hash table to store the key-value pairs. This allows for constant time lookups, regardless of the size of the dictionary.
In terms of space complexity, accessing an element in a dictionary has a space complexity of O(1), since it only retrieves the value associated with the specified key, without creating any new objects
Adding and Modifying Elements
In Python, you can add and modify elements in a dictionary using the same syntax. Since a dictionary is a mutable data type, you can change its contents by assigning new values to its keys.
To add a new key-value pair to a dictionary, simply assign a value to a new or existing key using square brackets []. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
my_dict['orange'] = 5
print(my_dict)
# Output: {'apple': 2, 'banana': 3, 'cherry': 4, 'orange': 5}
In the example above, we add a new key-value pair 'orange': 5 to the dictionary my_dict by assigning the value 5 to the key 'orange'.
To modify an existing key-value pair in a dictionary, simply assign a new value to the key using square brackets []. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
my_dict['banana'] = 5
print(my_dict) # Output: {'apple': 2, 'banana': 5, 'cherry': 4}
In the example above, we modify the value associated with the key 'banana' in the dictionary my_dict by assigning the value 5 to the key.
It’s important to note that adding and modifying elements in a dictionary has a time complexity of O(1), since the dictionary uses a hash table to store the key-value pairs. This allows for constant time lookups and updates, regardless of the size of the dictionary.
In terms of space complexity, adding and modifying elements in a dictionary has a space complexity of O(1), since it only adds or modifies the specified key-value pair, without creating any new objects.
Removing Elements
In Python, you can delete an element from a dictionary using the del keyword. There are two ways to delete an element from a dictionary: by specifying the key of the element to be deleted, or by using the pop() method.
Deleting by Key
To delete an element from a dictionary by specifying its key, you can use the del keyword followed by the key of the element to be deleted. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
del my_dict['banana']
print(my_dict)
# Output: {'apple': 2, 'cherry': 4}
In the example above, we use the del keyword to delete the element with the key 'banana' from the dictionary my_dict. After the deletion, the dictionary only contains the elements with keys 'apple' and 'cherry'.
Deleting by Pop
Another way to delete an element from a dictionary is to use the pop() method. The pop() method removes and returns the element with the specified key. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
value = my_dict.pop('banana')
print(my_dict) # Output: {'apple': 2, 'cherry': 4}
print(value) # Output: 3
In the example above, we use the pop() method to remove and return the element with the key 'banana' from the dictionary my_dict. After the deletion, the dictionary only contains the elements with keys 'apple' and 'cherry'. The value of the deleted element, 3, is returned and stored in the variable value.
If you try to delete an element that does not exist in the dictionary, you will get a KeyError:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
del my_dict['orange'] # Raises KeyError: 'orange'
value = my_dict.pop('orange') # Raises KeyError: 'orange'
To avoid getting a KeyError, you can use the in operator to check if the key exists in the dictionary before trying to delete or pop it:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
if 'orange' in my_dict:
del my_dict['orange']
value = my_dict.pop('orange', None) # value is None, since 'orange' is not in the dictionary
In the example above, we use the in operator to check if the key 'orange' exists in the dictionary my_dict before trying to delete or pop it. Since the key does not exist in the dictionary, the deletion and popping operations are skipped. To avoid getting a KeyError when using the pop() method, we pass None as the default value to be returned if the key is not in the dictionary.
Delete Complete Dictionary
To delete an entire dictionary in Python, you can use the del keyword followed by the name of the dictionary. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
del my_dict
print(my_dict) # Raises NameError: name 'my_dict' is not defined
In the example above, we use the del keyword to delete the entire dictionary my_dict. After the deletion, if we try to print the dictionary, we get a NameError since the dictionary no longer exists.
Alternatively, you can use the clear() method to remove all the elements from a dictionary:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
my_dict.clear()
print(my_dict) # Output: {}
In the example above, we use the clear() method to remove all the elements from the dictionary my_dict. After the operation, the dictionary is empty.
It’s important to note that deleting a dictionary using the del keyword or the clear() method has a time complexity of O(n), where n is the number of elements in the dictionary. This is because all the elements in the dictionary must be visited and removed one by one.
In terms of space complexity, deleting a dictionary only frees up the memory occupied by the dictionary object itself, but not the memory occupied by the elements in the dictionary. To free up the memory occupied by the elements, you would need to delete them one by one or use a garbage collector.
Checking if a Key Exists
To check if a key exists in a dictionary, you can use the in keyword. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
print('apple' in my_dict) #Output: True
print('pear' in my_dict) # Output: False
Clearing a Dictionary
To remove all elements from a dictionary, you can use the clear() method. Here’s an example:
my_dict = {'apple': 2, 'banana': 3, 'cherry': 4}
my_dict.clear()
print(my_dict) # Output: {}
Time and Space Complexity Analysis
The time and space complexity of dictionary operations in Python depend on the implementation and the size of the dictionary. In general, dictionary operations have an average-case time complexity of O(1), which means that they can be performed in constant time on average. However, in the worst case, dictionary operations can have a time complexity of O(n), where n is the number of elements in the dictionary.
Here’s a table summarizing the time and space complexity of some common dictionary operations:
| Operation | Time Complexity | Space Complexity |
|---|---|---|
| Accessing an element | O(1) (average), O(n) (worst) | O(1) |
| Adding an element | O(1) (average), O(n) (worst) | O(1) |
| Modifying an element | O(1) (average), O(n) (worst) | O(1) |
| Removing an element | O(1) (average), O(n) (worst) | O(1) |
| Checking if a key exists | O(1) (average), O(n) (worst) | O(1) |
| Getting the keys or values | O(n) | O(n) |
| Getting a list of key-value pairs | O(n) | O(n) |
Note that the space complexity of a dictionary depends on the number of elements it contains. In general, the space complexity of a dictionary is proportional to the number of elements it contains.
Conclusion
In this article, we’ve explored the Python dictionary and its operations in detail. We’ve seen how dictionaries can be used to store and access data using key-value pairs, and how they provide a convenient way to manipulate data in a program. We’ve also discussed the time and space complexity of dictionary operations, which can be useful when analyzing the performance of a program that uses dictionaries. As a next step, you can read about dictionary methods using this link here.
The codes (if any) mentioned in this post can be downloaded from github.com. Share the post with someone you think can benefit from the information
