3 Useful Real-World Examples of Using Python Collections Module

The Python Collections module provides alternative implementations of built-in datatypes like lists, tuples, and dictionaries that offer additional functionality and performance optimizations. In this tutorial, we’ll explore three useful real-world examples of how you can use the Collections module in your Python projects.

Example 1: Counting Occurrences with Counter

The Counter class is a dictionary subclass that provides a convenient way to count occurrences of items in a list, tuple, or any iterable object. It returns a dictionary with keys representing the items and values representing the count of each item in the iterable. Here’s an example:

from collections import Counter

fruits = ['apple', 'banana', 'orange', 'apple', 'orange', 'orange']
fruit_counts = Counter(fruits)

print(fruit_counts)

Output:

Counter({'orange': 3, 'apple': 2, 'banana': 1})

In this example, we created a list of fruits and used the Counter class to count the number of occurrences of each fruit in the list. We then printed the resulting dictionary, which shows that ‘orange’ appears three times, ‘apple’ appears twice, and ‘banana’ appears once.

You can use the Counter class to count occurrences of any iterable object, including strings, tuples, and even other dictionaries.

Example 2: Creating Default Dictionaries with defaultdict

The defaultdict class is another dictionary subclass that provides a default value for missing keys. This can be useful when you’re working with dictionaries that have nested structures or when you want to avoid writing boilerplate code to handle missing keys. Here’s an example:

from collections import defaultdict

word_counts = defaultdict(int)
words = ['foo', 'bar', 'foo', 'baz', 'foo', 'qux']

for word in words:
    word_counts[word] += 1

print(word_counts['quux'])

Output:

0

In this example, we created a defaultdict with a default value of 0. We then looped over a list of words and incremented the count for each word in the defaultdict. When we printed the value for a missing key (‘quux’), the defaultdict returned the default value of 0 instead of raising a KeyError.

You can use the defaultdict class to create nested dictionaries or dictionaries with default values of other datatypes, like lists or sets.

Example 3: Efficiently Updating Multiple Dictionaries with ChainMap

The ChainMap class is a dictionary subclass that allows you to combine multiple dictionaries into a single mapping. It provides a convenient way to update or access multiple dictionaries at once, without having to merge them into a single dictionary. Here’s an example:

from collections import ChainMap

dict1 = {'foo': 1, 'bar': 2}
dict2 = {'baz': 3, 'qux': 4}
dict3 = {'foo': 5, 'qux': 6}

combined_dict = ChainMap(dict1, dict2, dict3)

print(combined_dict['foo'])
print(combined_dict['qux'])

Output:

1
4

In this example, we created three dictionaries and combined them into a single mapping using the ChainMap class. When we accessed the ‘foo’ key in the combined dictionary, the ChainMap returned the value from the first dictionary (dict1). When we accessed the ‘qux’ key, the ChainMap returned the value from the second dictionary (dict2), since the ‘qux’ key was not present in the first dictionary.

Additionally, you can also use ChainMap to implement fallback values in cases where a key is not found in the first dictionary. Here’s an example:

from collections import ChainMap

default_config = {'debug': False, 'verbose': False, 'log_file': 'app.log'}
local_config = {'verbose': True}

config = ChainMap(local_config, default_config)

print(config['debug'])
print(config['verbose'])
print(config['log_file'])

Output:

False
True
app.log

In this example, we created two dictionaries: default_config and local_config. We combined them into a single mapping using the ChainMap class. When we accessed the 'debug' key, which was not present in local_config, ChainMap returned the value from default_config. When we accessed the 'verbose' key, which was present in both local_config and default_config, ChainMap returned the value from local_config. Finally, when we accessed the 'log_file' key, which was only present in default_config, ChainMap returned the value from default_config.

Overall, the Collections module provides a wide range of useful datatypes that can help you write more efficient and expressive Python code. By using these datatypes in your projects, you can reduce the amount of boilerplate code you need to write, increase performance, and simplify complex data structures.