9 Essential Python Collection Module Functions You Should Know

Have you ever thought about using robust data structures while programming in Python? If yes, the Python “collections” module is here to rescue you. This module offers a range of special functions and container points that can enhance your data structure management.

From namedtuples, DeQues, Counter, OrderedDict, defaultdict to user-friendly wrappers, the Python Collections module assists developers with the essential tools for simplifying coding tasks, efficiently handling data, and optimizing overall performance.

What Are Collection Modules in Python

Python Collections module is a built-in module that supports additional functions and structures for efficiently managing the data. It expands upon various standard data structures available in Python, like dictionaries, lists, and tuples, by ultimately offering specialized utility classes and container types.

Components of Python Collections Module

Here are the essential components of the Python collections module along with their description.

Component Name Description
NamedTuple Factory faction used for creating tuples subclasses with named fields.
DeQue List-like container that supports pops and appends operations on both ends.
ChainMap Dict-like class utilized for creating or making a single view of multiple mappings.
Counter Dict subclass used for counting hashable objects and calculating frequencies.
OrderedDict Dict subclass that maintains the key-value pairs orders.
DefaultDict Dict subclass that invoked a factory function for offering default values for missing keys.
UserDict Wrapper about dictionary objects for subclassing of the dictionary.
UserList Wrapper around list objects for subclassing of lists.
UserString Wrapper around string objects for subclassing of strings.

Let’s check out each component individually.

1. namedtuple() Function

In the Python collections module, the “namedtuple” class permits you to create self-explanatory and lightweight data structures. It behaves as a factory function in order for creating tuple subclasses with named fields. This ultimately offers a more concise, readable alternative to regular classes and tuples.

In the given program, we will first import the “namedtuple” class from the “collections” module. The next step is to define a “Pointnamedtuple that comprises “x” and “y” name fields.

Then, we will create an instance of the Point with “a=4” and “b=8” and then access these named fields with the help of the dot notation. This enables intuitive and clear referencing of particular values within the namedtuple.

from collections import namedtuple

# Defining a namedtuple for representing a Point with a and b coordinates
Point = namedtuple('Point', ['a', 'b'])

# Creating an instance of Point
p = Point(4, 8)

# Accessing the named fields
NamedTuple - Python Collection Module
NamedTuple – Python Collection Module

2. DeQue – Double-Ended Queues

deque” class of the Python collections module offers a list-like container with speedy append and pop operations on both left and right ends. More specifically, deques are optimized for the use cases that need efficient deletion or insertion from either sequence end. This makes deque more useful for implementing queues, stacks, and other essential data structures.

To utilize it, firstly, import the “deque” class from the collections module. Then, create an empty queue and append the given three elements to the right end with the simple “append()” method. Similarly, we will append two elements to the left by invoking the “appendleft()” method.

Next, we have called the “pop()” and “popleft()” to pop elements from the right end and left end, one by one. Lastly, the elements are printed on the console with the print() function.

from collections import deque

# Creating an empty deque
d = deque()

# Appending elements to the right end

# Appending elements to the left end

# Pop elements from the right end

# Pop elements from the left end

# Accessing elements
Note: We have also added comments in the code for your ease of understanding.
DeQue - Python Collection Module
DeQue – Python Collection Module

3. ChainMap in Python

This class offers an efficient approach for combining multiple dictionaries into a single view. It acts as a dict-like class that can be utilized as a single view of multiple mappings, permitting efficient lookup and modification operations across all the underlying dictionaries.

Now, let’s import the ChainMap class from the collections module. Then, we will create two dictionaries named “dict1” and “dict2“. After that, we will create a ChainMap object named “chain_map” by passing the newly created dictionaries as arguments.

These values can be accessed from the ChainMap as a single dictionary and you can also modify them which also affects the original dictionaries.

from collections import ChainMap

# Creating two dictionaries
dict1 = {'a': 9, 'b': 8}
dict2 = {'c': 7, 'd': 6}

# Creating a ChainMap from the dictionaries
chain_map = ChainMap(dict1, dict2)

# Accessing values
print("Original Values:")

# Updating values
chain_map['b'] = 5
print("Updated Values:")
ChainMap - Python Collection Module
ChainMap – Python Collection Module

4. Python’s Counter

The Counter class supports a convenient way of counting the occurrences of elements in an iterable. It is a specialized dict subclass that efficiently counts the hashable objects and permits easy frequency manipulation and calculation.

In the stated program, we first imported the Counter class from the collections module. Then, we created a Counter object named “c” from a list of elements. This object will automatically count the occurrences of each element that are characters in this scenario.

Then, we updated the counts with the help of the “updated()” method with another iterable. Lastly, the “most_common()” method for retrieving the most common elements and their counts.

from collections import Counter

# Creating a Counter from a list
c = Counter(['x', 'y', 'z', 'x', 'y', 'x'])

# Counting occurrences
print("Original:", c['x'])        

# Updating counts
c.update(['x', 'y', 'z'])
print("Updated:", c)            

# print most common elements
print("Most Common:", c.most_common(2))
Counter - Python Collection Module
Counter – Python Collection Module

5. OrderedDict() Function

Python collections module provides another dict subclass named OrderedDict. This class maintains the order in which the key-value pairs were defined. It also remembers the insertion order of the elements, enabling you to iterate over the dictionary’s keys or items in the order they were added.

For instance, we will import the OrderedDict class from the collections module. Then, create an empty ordered dictionary named “ordered_dict“. Next, the “items()” method is utilized for iterating over the created dictionary with the help of the for loop. Lastly, the print()function is used for displaying the items on the terminal.

from collections import OrderedDict

# Creating an empty OrderedDict
ordered_dict = OrderedDict()

# Adding key-value pairs
ordered_dict['x'] = 7
ordered_dict['y'] = 8
ordered_dict['z'] = 9

# Iterating over the OrderedDict
for key, value in ordered_dict.items():
    print(key, value)
OrderedDict - Collection Module in Python
OrderedDict – Collection Module in Python

6. defaultdict() Function

defaultdict class is a dict subclass that invokes the factory function for supplying the missing values when the accessed key does not exist. In such a scenario, it offers a convenient way for handling missing keys without raising KeyError exceptions.

Here, we have imported the defaultdict class from the collections module. Then, a new defaultdict object has been created named “d” with “int” as the factory function.

So, whenever a missing key is accessed, it outputs the default value of “int“, which is 0. After doing so, the count has been incremented for a key by 1.

from collections import defaultdict

# Defining a defaultdict with int as the factory function
d = defaultdict(int)

# Accessing a missing key returns the default value

# Incrementing the count for 'y' by 1
d['y'] += 1
DefaultDict - Collection Module
DefaultDict – Collection Module

As the next part of the program, a new defaultdict has been created named “d_list” with the “list” factory function. Then, we have appended two elements to it for missing values.

So, when a missing key is accessed, an empty list will be returned, permitting us to add values to the list.

from collections import defaultdict
# Creating a defaultdict with list as the factory function
d_list = defaultdict(list)

# Appending to the list for a missing key
DefaultDict in Python
DefaultDict in Python

7. UserDict in Pythons

UserDict” class in the Python collections module is referred to as a wrapper class that can simplify the subclassing of the dictionary respectively.

In this program, we have imported the “UserDict” class from the collections module. After that, we created custom subclasses named “CustomDict“. This is done by inheriting the corresponding wrapper class. Then, the “__setitem__” method is overridden for adding custom functionality and is invoked along with the added behavior.

from collections import UserDict

# Creating a custom dictionary subclass
class CustomDict(UserDict):
    def __setitem__(self, key, value):
        print("Setting key-value pair")
        super().__setitem__(key, value)

# Creating an instance of the custom dictionary
d = CustomDict()
d['a'] = 1
UserDict: Easier Subclassing Wrapper for Dictionaries
UserDict: Easier Subclassing Wrapper for Dictionaries

8. UserList in Python

UserList” is another wrapper class of the collections module that permits the easier subclassing of the list objects in Python.

In the provided code, we have created a custom list named “UserList” by importing the “UserList” class from the collections module. Then, the “append()” method is overridden and called for performing the added functionality of adding items to the list.

from collections import UserList

# Creating a custom list subclass
class CustomList(UserList):
    def append(self, item):
        print("Appending item")

# Creating an instance of the custom list
lst = CustomList()
UserList: Easier Subclassing Wrapper for Lists
UserList: Easier Subclassing Wrapper for Lists

9. UserString in Python

Last but not least, the “UserString” wrapper class of the Python collections module can be utilized for easier subclassing of the string objects.

For instance, here we have imported the “UserString” class from the collections module and created a custom substring named “CustomString“. Then, the “upper()” method is overridden and we added the custom functionality for converting the string to uppercase as follows.

from collections import UserString

# Creating a custom string subclass
class CustomString(UserString):
    def upper(self):
        print("Converting to uppercase")
        return super().upper()

# Creating an instance of the custom string
s = CustomString("hello geeksveda user")

UserString: Easier Subclassing Wrapper for Strings
UserString: Easier Subclassing Wrapper for Strings

It can be observed that the added functionality has been performed successfully.

Best Practices for Using Python Collections Module

Look at the provided best practices for using the Python Collections module.

  • Import only the particular functions or classes from the module that are required.
  • Utilized “deque” for the efficient deletion or insertion operations on both ends.
  • Use “namedtuples” for readable and concise data structures with named fields.
  • Utilize “OrderedDict” for preserving the order of key-value pairs.
  • Employ Counter for counting and frequency calculation.
  • Use “defaultdict” to easily handle missing keys.
  • Utilize “UserDict“, “UserString“, and “UserList” for easier subclassing of dictionaries, strings, and lists.

That’s all from today’s guide related to the Python collections module.


The Python Collections module supports robust container types and functions that can improve data structure management. By using namedtuples, deques, Counter, OrderedDict, defaultdict, and the UserDict, UserList, and UserString wrappers, you can achieve efficient, concise, and maintainable code.

So, explore it and utilize it in your project accordingly.

Want to explore and learn more related to Python, do check out our dedicated Python Tutorial Series!

If you read this far, tweet to the author to show them you care. Tweet a thanks
As a professional content writer with 3 years of experience, I specialize in creating high-quality, SEO-optimized content that engages, attracts, and retains the audience.

Each tutorial at GeeksVeda is created by a team of experienced writers so that it meets our high-quality standards.

Join the GeeksVeda Weekly Newsletter (More Than 5,467 Programmers Have Subscribed)
Was this article helpful? Please add a comment to show your appreciation and support.

Got Something to Say? Join the Discussion...