Skip to content
CodeMDD.io | Coding Tutorials

Using defaultdict in Python Explained

[

Using the Python defaultdict Type for Handling Missing Keys

A common problem that you can face when working with Python dictionaries is trying to access or modify keys that don’t exist in the dictionary. This can raise a KeyError and break your code execution. To handle these situations, the standard library provides the Python defaultdict type, a dictionary-like class available in the collections module.

The Python defaultdict type behaves almost exactly like a regular Python dictionary. However, if you try to access or modify a missing key, defaultdict will automatically create the key and generate a default value for it. This makes defaultdict a valuable option for handling missing keys in dictionaries.

In this tutorial, you will learn:

  • How to use the Python defaultdict type for handling missing keys in a dictionary.
  • When and why to use a Python defaultdict rather than a regular dictionary.
  • How to use a defaultdict for grouping, counting, and accumulating operations.

With this knowledge, you will be better equipped to effectively use the Python defaultdict type in your programming challenges.

Handling Missing Keys in Dictionaries

A common issue when working with Python dictionaries is how to handle missing keys. If your code heavily relies on dictionaries or if you frequently create dictionaries on-the-fly, dealing with frequent KeyError exceptions can be annoying and add extra complexity to your code.

Python dictionaries have several ways to handle missing keys, including:

  1. Using the get() method to provide a default value when a key is missing.
  2. Using the setdefault() method to set a default value for a missing key.
  3. Using a try-except block to catch KeyError exceptions.

While these approaches work, they can be verbose and require extra lines of code to handle missing keys.

Understanding the Python defaultdict Type

The Python defaultdict type is a subclass of the built-in dict type. It builds upon the basic functionality of a dictionary and provides additional capabilities for handling missing keys.

The main advantage of the defaultdict type is that it automatically creates a default value when accessing a missing key. This can simplify your code and make it more readable by eliminating the need for explicit checks and exception handling.

Using the Python defaultdict Type

To use the defaultdict type, you first need to import it from the collections module:

from collections import defaultdict

Once imported, you can create a defaultdict by specifying a default factory function. This factory function will be called every time a missing key is accessed. It should return the default value that will be associated with the missing key. If no default factory function is provided, the default value will be None.

my_dict = defaultdict(int)  # Default value for missing keys is 0

Grouping Items

One common use case for defaultdict is grouping items based on a certain criteria. For example, let’s say you have a list of names, and you want to group them by the first letter of each name.

names = ["Alice", "Bob", "Charlie", "Dave", "Eve"]


grouped_names = defaultdict(list)
for name in names:
    grouped_names[name[0]].append(name)


print(grouped_names)

Output:

{
    'A': ['Alice'],
    'B': ['Bob'],
    'C': ['Charlie'],
    'D': ['Dave'],
    'E': ['Eve']
}

In this example, the list type is used as the default factory function for the defaultdict. When a missing key is accessed, a new empty list is created and assigned as the value of the missing key. This allows us to directly append the names to their respective groups.

Grouping Unique Items

If you want to group unique items based on a certain criterion, you can use a set as the default factory function:

names = ["Alice", "Bob", "Charlie", "Dave", "Eve"]


grouped_unique_names = defaultdict(set)
for name in names:
    grouped_unique_names[name[0]].add(name)


print(grouped_unique_names)

Output:

{
    'A': {'Alice'},
    'B': {'Bob'},
    'C': {'Charlie'},
    'D': {'Dave'},
    'E': {'Eve'}
}

Using a set as the default factory function ensures that each name is only added once to its corresponding group.

Counting Items

Another common use case is counting the occurrences of items. You can use the int type as the default factory function to create a counter:

words = ["apple", "banana", "apple", "cherry", "banana"]


word_count = defaultdict(int)
for word in words:
    word_count[word] += 1


print(word_count)

Output:

{
    'apple': 2,
    'banana': 2,
    'cherry': 1
}

In this example, the default factory function int() is called whenever a missing key is accessed. The int() function returns 0, which allows us to increment the count for each word.

Accumulating Values

You can also use the defaultdict type for accumulating values. For example, let’s say you have a list of numbers, and you want to calculate the sum for each unique number:

numbers = [1, 2, 1, 3, 2, 4, 1, 2, 3]


number_sum = defaultdict(int)
for number in numbers:
    number_sum[number] += number


print(number_sum)

Output:

{
    1: 3,
    2: 6,
    3: 6,
    4: 4
}

In this example, the default factory function is int(), which returns 0 when a missing key is accessed. We can then accumulate the values by adding the current number to the existing sum.

Diving Deeper Into defaultdict

Now that you have a basic understanding of how to use the defaultdict type, let’s explore some additional features and comparisons.

defaultdict vs dict

A defaultdict behaves almost exactly like a regular Python dictionary, but with the added default value functionality. You can use it as a drop-in replacement for a regular dictionary and get the benefits of automatic default value generation.

defaultdict.default_factory

You can access the default factory function of a defaultdict by the default_factory attribute:

my_dict = defaultdict(int)
print(my_dict.default_factory)  # <class 'int'>

In this example, int is the default factory function that will be used to generate default values for missing keys.

defaultdict vs dict.setdefault()

The setdefault() method of a regular dictionary provides similar functionality to a defaultdict, but with some key differences.

my_dict = {}
my_dict.setdefault("key", "default_value")
print(my_dict)  # {'key': 'default_value'}


default_dict = defaultdict(str)
default_dict["key"]
print(default_dict)  # defaultdict(<class 'str'>, {'key': ''})

The setdefault() method of a regular dictionary sets the default value for a missing key and returns the value. In contrast, a defaultdict automatically generates the default value when a missing key is accessed without modifying the underlying dictionary.

defaultdict.missing()

The __missing__() method is a special method that is used by dictionaries when a key is not found. It allows you to customize the behavior of a dictionary for missing keys. However, the __missing__() method is not used by defaultdict, as it already provides default value generation.

Emulating the Python defaultdict Type

If you’re working with an older version of Python that doesn’t have the defaultdict type, or if you want to understand its inner workings, you can emulate its behavior using a regular dictionary and a helper function.

Here is an example:

def default_factory():
    return "default_value"


my_dict = {}
key = "missing_key"
value = my_dict.get(key, default_factory())
my_dict[key] = value


print(my_dict)  # {'missing_key': 'default_value'}

In this example, the default_factory() function is called when the get() method returns None, indicating that the key is missing. The default value is then assigned to the missing key in the dictionary.

Passing Arguments to .default_factory

You can pass arguments to the default_factory function using lambda or functools.partial().

Using lambda

from collections import defaultdict


my_dict = defaultdict(lambda: "default_value")

In this example, the lambda function returns the string "default_value" for missing keys.

Using functools.partial()

from collections import defaultdict
from functools import partial


def default_factory(default_value):
    return default_value


my_dict = defaultdict(partial(default_factory, default_value="default_value"))

In this example, the partial() function from the functools module is used to specify the default_value argument for the default_factory() function.

Conclusion

The Python defaultdict type is a useful class that simplifies handling missing keys in dictionaries. By providing a default factory function, defaultdict allows you to automatically generate default values for missing keys, eliminating the need for explicit checks and exception handling.

In this tutorial, you learned how to use the Python defaultdict type for various operations such as grouping, counting, and accumulating values. You also explored additional features and comparisons with regular dictionaries. With this knowledge, you can confidently use the defaultdict type in your Python programs and make your code more concise and readable.