Python - defaultdict

defaultdict in Python 

In Python, the defaultdict class is part of the collections module and is a subclass of the built-in dict class. It simplifies dictionary operations by automatically initializing missing keys with a default value. This powerful feature helps prevent common errors such as KeyError and reduces the need to check if a key exists before inserting or updating a value.

This article provides an in-depth exploration of defaultdict, its syntax, use cases, comparisons with regular dictionaries, and numerous practical examples that illustrate its value in day-to-day Python programming.

What is defaultdict?

defaultdict is a dictionary-like object that provides all methods that a dictionary does but takes a first argument (a function) called default_factory. When a key is accessed that doesn’t exist in the dictionary, the default_factory function is called to provide a default value for that key.

Importing defaultdict

from collections import defaultdict

Basic Syntax

defaultdict(default_factory)

The default_factory is typically a data type like int, list, set, or a user-defined function that returns a default value.

Comparison with Regular dict

Using a standard dictionary:

my_dict = {}
my_dict['key'] += 1  # Raises KeyError

Using defaultdict:

from collections import defaultdict

my_dict = defaultdict(int)
my_dict['key'] += 1  # Automatically initializes to 0, then adds 1

Common default_factories

int

Used when counting elements:

counter = defaultdict(int)
counter['apple'] += 1
counter['banana'] += 2

print(counter)

list

Used for grouping elements:

grouped = defaultdict(list)
grouped['fruits'].append('apple')
grouped['fruits'].append('banana')

print(grouped)

set

unique_items = defaultdict(set)
unique_items['letters'].add('a')
unique_items['letters'].add('b')

print(unique_items)

lambda Functions

defaults = defaultdict(lambda: "N/A")
print(defaults['missing'])  # Output: N/A

Practical Examples

Example 1: Word Frequency Counter

text = "apple banana apple orange banana apple"

word_count = defaultdict(int)
for word in text.split():
    word_count[word] += 1

print(dict(word_count))

Example 2: Grouping Values by Key

data = [
    ('fruits', 'apple'),
    ('fruits', 'banana'),
    ('vegetables', 'carrot'),
    ('vegetables', 'spinach')
]

grouped = defaultdict(list)
for category, item in data:
    grouped[category].append(item)

print(dict(grouped))

Example 3: Nested defaultdict

nested = defaultdict(lambda: defaultdict(int))

nested['student1']['math'] = 90
nested['student1']['science'] = 85
nested['student2']['math'] = 78

print(dict(nested))

Example 4: Counting Letters in Words

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

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

print(dict(letter_count))

Why Use defaultdict?

• Removes need to check if a key exists before modifying it
• Improves code readability and maintainability
• Reduces boilerplate code
• Helpful in grouping, counting, and building multidimensional structures

Use Cases

1. Grouping Related Data

students = [('Alice', 'Math'), ('Bob', 'Science'), ('Alice', 'English')]

subjects = defaultdict(list)
for student, subject in students:
    subjects[student].append(subject)

print(dict(subjects))

2. Graph Representation

graph = defaultdict(list)
edges = [
    ('A', 'B'),
    ('A', 'C'),
    ('B', 'D'),
    ('C', 'D')
]

for u, v in edges:
    graph[u].append(v)

print(dict(graph))

3. Matrix or Grid with Default Values

matrix = defaultdict(lambda: defaultdict(int))

matrix[0][0] = 1
matrix[0][1] = 2
matrix[1][0] = 3

print(matrix[2][2])  # Returns 0 as default

4. Counting with Tuples

pairs = [('a', 'b'), ('a', 'b'), ('a', 'c')]

pair_count = defaultdict(int)
for p in pairs:
    pair_count[p] += 1

print(dict(pair_count))

Accessing and Updating Keys

You can access and update defaultdict keys just like in regular dictionaries:

dd = defaultdict(list)
dd['a'].append(1)
dd['a'].append(2)
dd['b'].append(3)

for key in dd:
    print(key, dd[key])

Converting defaultdict to dict

Sometimes it's necessary to convert a defaultdict to a regular dictionary:

dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2

normal_dict = dict(dd)
print(normal_dict)

Caveats and Considerations

• defaultdict can be confusing to new Python programmers
• Accessing a missing key will always create a new entry
• Do not use defaultdict where unexpected mutation is a concern
• Use cautiously in shared or multi-threaded environments

Alternative: Using dict.setdefault()

my_dict = {}
my_dict.setdefault('key', []).append('value')

print(my_dict)

Although setdefault() achieves similar behavior, defaultdict is more readable and concise when used repeatedly.

Real-World Application: CSV Grouping

import csv
from collections import defaultdict

grouped_data = defaultdict(list)

with open('data.csv') as f:
    reader = csv.reader(f)
    for row in reader:
        key = row[0]
        grouped_data[key].append(row[1:])

print(dict(grouped_data))

Real-World Application: JSON Parsing

import json
from collections import defaultdict

data = '{"users": [{"name": "Alice"}, {"name": "Bob"}]}'

parsed = json.loads(data)
users = defaultdict(list)

for u in parsed['users']:
    for key, value in u.items():
        users[key].append(value)

print(dict(users))

Using defaultdict with Custom Classes

class MyClass:
    def __init__(self):
        self.value = 0

data = defaultdict(MyClass)

data['item1'].value += 1
data['item2'].value += 5

print(data['item1'].value)

Using defaultdict for Word Indexing

text = "this is a test this is only a test"

index = defaultdict(list)

for pos, word in enumerate(text.split()):
    index[word].append(pos)

print(dict(index))

defaultdict is one of Python’s most valuable tools for writing clean, efficient, and error-free code when working with dictionaries. By automatically handling missing keys and initializing them with default values, it eliminates the need for verbose checks and conditionals.

It shines in scenarios involving counting, grouping, graph structures, and nested data representations. Whether you're a beginner or a seasoned developer, mastering defaultdict will significantly improve your Python programming fluency and help you write more Pythonic code.

To summarize:

• defaultdict is in the collections module
• It simplifies dictionary logic
• You can use int, list, set, lambda, or custom functions as default_factory
• It’s ideal for grouping, counting, and nesting
• Can be converted to dict using dict()

With its power and simplicity, defaultdict is a must-have tool in any Python programmer’s toolkit.