Python collections.defaultdict Class

The collections.defaultdict class in Python’s collections module is a subclass of the built-in dict class. It overrides one method to provide a default value for a nonexistent key, simplifying the process of dealing with missing keys in a dictionary.

Table of Contents

1. Introduction
2. collections.defaultdict Class Syntax
3. Examples
   • Basic Usage
   • Using defaultdict with Different Default Factories
   • Counting Items
   • Grouping Items
4. Real-World Use Case
5. Conclusion

Introduction

The collections.defaultdict class in Python’s collections module simplifies the handling of dictionaries with missing keys by providing a default value automatically. This is particularly useful in situations where you need to ensure that a key exists before performing operations on its value.

collections.defaultdict Class Syntax

Here is how you use the collections.defaultdict class:

from collections import defaultdict

default_dict = defaultdict(default_factory)

Parameters:

• default_factory: A callable that provides the default value for the dictionary.

Returns:

• A new defaultdict object.

Examples

Basic Usage

Here is an example of how to create and use a defaultdict to handle missing keys.

Example

from collections import defaultdict

# Creating a defaultdict with a default factory of int
default_dict = defaultdict(int)

# Accessing and modifying elements
default_dict['a'] += 1
default_dict['b'] += 2

print(default_dict)

Output:

defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Using defaultdict with Different Default Factories

You can use various callable objects as the default factory to customize the default value.

Example

from collections import defaultdict

# Using list as the default factory
list_default_dict = defaultdict(list)

# Using lambda function as the default factory
lambda_default_dict = defaultdict(lambda: 'default_value')

# Adding elements to defaultdicts
list_default_dict['a'].append(1)
list_default_dict['b'].append(2)

lambda_default_dict['a']
lambda_default_dict['b']

print(list_default_dict)
print(lambda_default_dict)

Output:

defaultdict(<class 'list'>, {'a': [1], 'b': [2]})
defaultdict(<function <lambda> at 0x000002755BC5A2A0>, {'a': 'default_value', 'b': 'default_value'})

Counting Items

Using defaultdict with int as the default factory makes it easy to count items, such as characters in a string.

Example

from collections import defaultdict

# Counting characters in a string
char_count = defaultdict(int)

for char in 'hello world':
    char_count[char] += 1

print(char_count)

Output:

defaultdict(<class 'int'>, {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

Grouping Items

You can use defaultdict with list as the default factory to group items.

Example

from collections import defaultdict

# Grouping words by their first letter
words = ['apple', 'banana', 'cherry', 'apricot', 'blueberry', 'avocado']
grouped_words = defaultdict(list)

for word in words:
    grouped_words[word[0]].append(word)

print(grouped_words)

Output:

defaultdict(<class 'list'>, {'a': ['apple', 'apricot', 'avocado'], 'b': ['banana', 'blueberry'], 'c': ['cherry']})

Real-World Use Case

Categorizing Log Entries

In real-world applications, collections.defaultdict can be used to categorize log entries by their severity level.

Example

from collections import defaultdict

# Sample log entries
logs = [
    ('error', 'Invalid user input'),
    ('info', 'User logged in'),
    ('error', 'File not found'),
    ('warning', 'Disk space low'),
    ('info', 'User logged out'),
]

# Categorizing log entries
log_categories = defaultdict(list)

for severity, message in logs:
    log_categories[severity].append(message)

for severity, messages in log_categories.items():
    print(f"{severity.capitalize()}:")
    for message in messages:
        print(f" - {message}")

Output:

Error:
 - Invalid user input
 - File not found
Info:
 - User logged in
 - User logged out
Warning:
 - Disk space low

Conclusion

The collections.defaultdict class in Python’s collections module simplifies the handling of missing keys in dictionaries by providing default values automatically. This class is particularly useful for counting items, grouping items, and other tasks where you need to ensure that a key exists before performing operations on its value. Proper usage of this class can enhance the clarity and efficiency of your code when dealing with dictionaries.