What’s New ?

The Top 10 favtutor Features You Might Have Overlooked

Read More

Python Dictionary: Methods & Operations (with Examples)

  • Oct 06, 2023
  • 8 Minutes Read
Python Dictionary: Methods & Operations (with Examples)

Dictionaries in Python are versatile and fundamental data structures that make it different from other programming languages. In this blog, we'll explore everything about Python dictionaries, from the basics to more advanced techniques.

What is a Python Dictionary?

A Python dictionary serves as a collection of key-value pairs, in which each key is distinct and can encompass various object types, such as strings, numbers, or tuples. Correspondingly, each key can be linked to any type of object.

Dictionaries are frequently utilized for efficient data storage and retrieval. For example, they can be employed to organize contact details for friends and family. In such a dictionary, the keys might represent the names of individuals, while the values could denote their respective phone numbers, email addresses, and mailing addresses.

Dictionaries emerge as a potent data structure adaptable to an array of tasks. Several compelling reasons advocate for their use:

  1. Efficiency: Dictionaries excel at rapid data retrieval and searching. They achieve this by employing a hash table for data storage, permitting constant-time access to values, regardless of dictionary size.
  2. Flexibility: Dictionaries accommodate a wide range of data types, rendering them a versatile choice for data organization.
  3. Readability: Dictionaries feature a user-friendly and easily comprehensible structure, making them well-suited for storing and retrieving data in a human-readable format.

Basic Syntax

To instantiate dictionaries, employ curly braces {}. Each key-value pair is demarcated by a colon :. For instance, the following code establishes a straightforward dictionary:

my_dictionary = {
    "name": "Alice",
    "age": 25,
    "occupation": "Software Engineer"
}

 

To access a value within a dictionary, employ the associated key. For instance, to retrieve Alice's age, one can use the following code:

age = my_dictionary["age"]

 

Creating & Accessing Dictionaries in Python

Two techniques exist for crafting dictionaries in Python:

  1. Curly Braces: As previously demonstrated, dictionaries are constructed using curly braces, with key-value pairs separated by colons.
  2. dict() Function: Alternatively, dictionaries can be generated through the dict() function. This function takes an iterable of key-value pairs as its argument and yields a dictionary with those pairs. For instance, the following code builds the same dictionary as the previous example, but employs the dict() function:
my_dictionary = dict([("name", "Alice"), ("age", 25), ("occupation", "Software Engineer")])

 

To access a dictionary's value, use the corresponding key enclosed in square brackets. For instance, to retrieve Alice's name, use the following code:

name = my_dictionary["name"]

 

In cases where an attempt is made to access a non-existent key, a KeyError may occur. This can be circumvented by utilising the get() method. The get() method returns the value associated with the specified key or None if the key is absent. For example, the following code safely retrieves Alice 's name, even if the key is absent:

name = my_dictionary.get("name")

 

Operations in Python Dictionary

Python dictionaries support several operations, including:

Adding items: Employ the [] operator to add items to a dictionary. For instance, to include a new item in my_dictionary, use:

my_dictionary["favorite_color"] = "blue"

 

Modifying items: Utilize the [] operator to modify an item in a dictionary. For example, to adjust Alice's age to 26:

my_dictionary["age"] = 26

 

Removing items: Delete an item from a dictionary using the del keyword. To eliminate the favorite_color item:

del my_dictionary["favorite_color"]

 

Checking for key existence: To verify if a key exists, use the in keyword. To determine if the name key exists in my_dictionary, execute:

"name" in my_dictionary

 

Dictionary Length: Determine a dictionary's length with the len() function, which yields the item count. To print the length of my_dictionary:

print(len(my_dictionary))

 

Iterating over a dictionary: Iterate through a dictionary using a for loop, which iterates over its keys. For example, the following code prints all keys in my_dictionary:

for key in my_dictionary:
    print(key)

 

Additionally, one can iterate over the values in a dictionary by applying the values() method, which returns a list of all values. The subsequent code prints all values in my_dictionary:

for value in my_dictionary.values():
    print(value)

 

Methods for Python Dictionary 

Apart from the fundamental operations, Python dictionaries offer numerous methods. Below are some of the most commonly used dictionary methods:

get()

The get() method retrieves the value linked to a particular key. This method takes two arguments: the key for which the value is sought and an optional default value. If the key is absent in the dictionary, the get() method returns the default value. For instance:

name = my_dictionary.get("name", "Unknown")

 

keys()

The keys() method produces a sorted list of all keys present in the dictionary. This list is arranged in a sorted order. For instance:

for key in my_dictionary.keys():
    print(key)

 

values()

The values() method furnishes a list of all values in the dictionary, preserving the order identical to the keys. For example:

for value in my_dictionary.values():
    print(value)

 

items()

The items() method assembles a list of tuples, where each tuple embodies a key-value pair from the dictionary. The list preserves the same order as the keys. Here's an illustration:

for key, value in my_dictionary.items():
    print(f"{key}: {value}")

 

update()

The update() method integrates the contents of one dictionary into another. It accepts one argument: a dictionary containing key-value pairs to append to the existing dictionary. For instance:

new_dictionary = {"favorite_color": "blue"}
my_dictionary.update(new_dictionary)

 

pop()

The pop() method eliminates an item from the dictionary and returns the associated value. It takes two arguments: the key of the item to remove and an optional default value. Should the key not exist, the pop() method returns the default value or raises a KeyError if no default is provided. For example:

name = my_dictionary.pop("name")

 

popitem()

The popitem() method withdraws a random item from the dictionary and delivers it as a tuple comprising the key and value of the removed item. For instance:

key, value = my_dictionary.popitem()

 

clear()

The clear() method purges all items from the dictionary. For example:

my_dictionary.clear()

 

Dictionary Comprehensions

Dictionary comprehensions provide a concise means of crafting dictionaries.  They are Python expressions that yield dictionaries. The foundational syntax for a dictionary comprehension is as follows:

{key: value for key, value in iterable}

 

The iterable can represent any collection of key-value pairs, while the expressions for key and value can be any valid Python expressions. For instance, the subsequent code formulates a dictionary encompassing the squares of numbers from 1 to 10:

squares = {x: x * x for x in range(1, 11)}

 

Conditional expressions can also be incorporated into dictionary comprehensions. This code, for instance, establishes a dictionary featuring even numbers from 1 to 10:

even_numbers = {x for x in range(1, 11) if x % 2 == 0}

 

Advanced Dictionary Techniques

Beyond the fundamental operations and methods, numerous advanced dictionary techniques are available for utilization:

Nested Dictionaries

A nested dictionary encompasses other dictionaries within it. Such dictionaries are instrumental for storing complex data structures. For example, consider the subsequent code that forges a nested dictionary to manage contact information for friends and family:

my_contacts = {
    "Alice": {
        "phone_number": "123-456-7890",
        "email_address": "[email protected]"
    },
    "Bob": {
        "phone_number": "987-654-3210",
        "email_address": "[email protected]"
    }
}

 

Accessing a value in a nested dictionary entails using the [] operator and chaining the keys together. For instance, to retrieve Alice's phone number, this code is used:

alice_phone_number = my_contacts["Alice"]["phone_number"]

 

Dictionary Sorting

Dictionaries can be sorted based on their keys or values using the sorted() function. When sorting by keys, the sorted() function directly takes the dictionary's keys() method as an argument. Here's code to print a sorted list of keys in my_contacts:

for key in sorted(my_contacts.keys()):
    print(key)

 

To sort by values, iterate through the values() method and apply the sorted() function. The subsequent code will print a sorted list of values in my_contacts:

for value in sorted(my_contacts.values()):
    print(value)

 

Merging Dictionaries

Combining two dictionaries is feasible through the update() method. This method inserts key-value pairs from the second dictionary into the first. For instance, the code below merges my_contacts with new_contacts:

new_contacts = {
    "Carol": {
        "phone_number": "555-555-5555",
        "email_address": "[email protected]"
    }
}

my_contacts.update(new_contacts)

 

Default Values for Missing Keys

To set default values for missing keys, employ the defaultdict() class. This class accepts a function as an argument, which generates a default value for absent keys. The code snippet below constructs a defaultdict() using the string "Unknown" as the default value:

from collections import defaultdict

my_contacts = defaultdict(str)

# Fetch Carol's phone number. If the `Carol` key is absent, the
# `defaultdict()` will supply a default value of `""`.
carol_phone_number = my_contacts["Carol"]

 

Immutable Dictionaries (Python 3.9+)

Python 3.9 introduced immutable dictionaries, incapable of modification once created. To establish an immutable dictionary, employ the frozenset() function to generate a frozen set of keys, and subsequently, pass this frozen set to the dict() function. Here's an example:

from collections import frozenset

my_contacts = dict(frozenset(["Alice", "Bob"]))

 

Use Cases and Real-World Examples

Dictionaries prove highly adaptable and find application in various scenarios:

  1. Storing and Retrieving Configuration Data: Dictionaries can house configuration data for applications, such as database connection details.
  2. Counting and Aggregating Data: Dictionaries facilitate counting and aggregating data. For instance, they can tally word occurrences in a document.
  3. Mapping Data for Faster Access: Dictionaries can be employed to map data, accelerating access. For instance, mapping user IDs in a database to their corresponding usernames.
  4. JSON Serialization and Deserialization: Dictionaries are handy for serializing and deserializing JSON data, facilitating data exchange with other applications.

Performance and Efficiency

Dictionaries excel in efficiency when it comes to searching and retrieving data due to their use of hash tables. A hash table employs a hash function to map keys to values, enabling constant-time access to any value, regardless of dictionary size.

Nevertheless, dictionaries are comparatively less efficient for inserting and deleting items, as these operations may necessitate hash table resizing.

Memory Usage Considerations

Dictionaries consume more memory compared to other data structures, like lists. This is attributed to their need to store both keys and values.

Choosing the Right Data Structure

When selecting a data structure, contemplate the following factors:

  1. Type of Operations: Dictate your choice based on the operations you intend to perform. If efficient data retrieval and searching are paramount, a dictionary is a judicious selection. Conversely, if efficient item insertion and deletion are requisite, a list might be more appropriate.
  2. Memory Constraints: In scenarios with limited memory resources, opt for more memory-efficient data structures, such as lists.

Best Practices and Tips

Consider these best practices and tips when working with dictionaries:

  1. Descriptive Keys: Use keys that aptly describe the values they represent, enhancing comprehension.
  2. Consistent Naming Convention: Maintain a consistent naming convention for dictionary keys, promoting code readability and maintainability.
  3. Graceful Error Handling: Handle potential errors, like KeyError, gracefully when attempting to access non-existent keys.
  4. Default Values: To avert KeyError occurrences, employ default values for missing keys, facilitated by the defaultdict() class.
  5. Select the Appropriate Data Structure: Assess your needs carefully to select the most suitable data structure. If efficient data retrieval is a priority, opt for dictionaries; otherwise, choose lists for efficient item insertion and deletion.

Exercises and Projects

Beginner Exercises

  • Construct a dictionary to store contact details for friends and family.
  • Develop a program to tally word occurrences in a document.
  • Create a program to map user IDs in a database to their corresponding usernames.

Intermediate Projects

  • Develop a word frequency counter.
  • Implement a phonebook application.

Advanced Projects

  • Engineer a dictionary-based spell checker.
  • Implement a  rudimentary JSON database.

Conclusion

Dictionaries emerge as potent and versatile data structures, applicable in various scenarios. They excel in data retrieval efficiency but exhibit comparatively lower efficiency in item insertion and deletion. Selecting the right data structure hinges on the nature of operations and memory constraints.

We trust that this detailed guide to Python dictionaries proves helpful. Please don't hesitate to reach out with any inquiries. Happy Coding!

FavTutor - 24x7 Live Coding Help from Expert Tutors!

About The Author
Nihal Mahansaria
As a computer science student with a passion for technology and a drive to learn, I have developed a diverse set of skills in web development, machine learning, and technical content writing. With experience in multiple front-end and back-end frameworks, including Flask and Python, I am able to create scalable and efficient web applications.