Python Collections Module – Complete Guide with Examples

Introduction

The Collections Module is part of Python’s standard library and contains powerful data structures designed to simplify coding, improve readability, and enhance performance.

Some commonly used classes in the Collections Module include:

• Counter
• defaultdict
• OrderedDict
• namedtuple
• deque
• ChainMap

These classes are widely used in data processing, web development, machine learning, analytics, and software engineering projects.

What is the Python Collections Module?

The Collections Module is a built-in Python module that provides alternative container datatypes to Python’s standard containers.

It extends the capabilities of:

• Lists
• Dictionaries
• Tuples

and offers additional functionality that makes data handling easier and more efficient.

To use the Collections Module, import it first:

import collections

Or import specific classes from collections import Counter.

Counter

The Counter class counts the frequency of elements in a collection.

Syntax:

from collections import Counter
Counter(iterable)

Example:

from collections import Counter
data = [
    "apple",
    "banana",
    "apple",
    "orange",
    "apple"
]
result = Counter(data)
print(result)

Output:

Getting Most Common Elements

Example:

from collections import Counter
data = [
    1,2,2,3,3,3
]
counter = Counter(data)
print(
    counter.most_common(1)
)

Output:

Meaning:

• Number 3 appears 3 times.

Real-Life Example: Word Counter

from collections import Counter
text = """
python is easy
python is powerful
"""
words = text.split()
count = Counter(words)
print(count)

Output:

Useful in text analysis applications.

defaultdict

A defaultdict automatically assigns a default value to missing keys.

Without defaultdict:

data = {}
data["A"].append(1)

Output:

With defaultdict:

from collections import defaultdict
data = defaultdict(list)
data["A"].append(1)
print(data)

Output:

Grouping Data Using defaultdict

Example:

from collections import defaultdict
students = [
    ("A", "Math"),
    ("B", "Science"),
    ("A", "English")
]
result = defaultdict(list)
for name, subject in students:
    result[name].append(subject)
print(result)

Output:

OrderedDict

The OrderedDict remembers the insertion order of keys.

Syntax:

from collections import OrderedDict

Example:

from collections import OrderedDict
data = OrderedDict()
data["A"] = 1
data["B"] = 2
data["C"] = 3
print(data)

Output:

Why Use OrderedDict?

Before Python 3.7, normal dictionaries did not guarantee insertion order.

Today, standard dictionaries maintain insertion order, but OrderedDict still provides extra features such as:

move_to_end()
popitem()

namedtuple

A namedtuple creates tuple-like objects with named fields.

Syntax:

from collections import namedtuple

Example:

from collections import namedtuple
Student = namedtuple(
    "Student",
    ["name", "age"]
)
s = Student(
    "John",
    20
)
print(s.name)
print(s.age)

Output:

Why Use namedtuple?

Normal tuple:

student = (
    "John",
    20
)
print(student[0])

Less readable.

Using namedtuple:

print(student.name)

Much clearer.

Real-Life Example: Employee Records

from collections import namedtuple
Employee = namedtuple(
    "Employee",
    ["id", "name", "salary"]
)
emp = Employee(
    101,
    "David",
    50000
)
print(emp.name)

Output:

deque

A deque (double-ended queue) allows fast insertion and deletion from both ends.

Syntax:

from collections import deque

Example:

from collections import deque
numbers = deque(
    [1,2,3]
)
numbers.append(4)
print(numbers)

Output:

Adding at the Beginning

Example:

from collections import deque
numbers = deque(
    [1,2,3]
)
numbers.appendleft(0)
print(numbers)

Output:

Removing Elements

Example:

numbers.pop()

Removes from the right.

Example:

numbers.popleft()

Removes from the left.

Real-Life Example: Browser History

from collections import deque
history = deque()
history.append("Home")
history.append("Products")
history.append("Contact")
print(history)

Output:

deque([ 

    'Home', 

    'Products', 

    'Contact' 

])

Useful for implementing navigation systems.

ChainMap

A ChainMap combines multiple dictionaries into a single view.

Syntax:

from collections import ChainMap

Example:

from collections import ChainMap
dict1 = {
    "name": "John"
}
dict2 = {
    "age": 25
}
combined = ChainMap(
    dict1,
    dict2
)
print(combined["name"])
print(combined["age"])

Output:

Real-Life Example: Application Settings

from collections import ChainMap
default_settings = {
    "theme": "light"
}
user_settings = {
    "theme": "dark"
}
settings = ChainMap(
    user_settings,
    default_settings
)
print(settings["theme"])

Output:

User settings override default settings.

Summary of Important Classes

Comparing Collections Classes

Advantages of Python Collections Module

Common Mistakes

1. Forgetting to Import Collections

Incorrect:

Counter(
    [1,2,3]
)

Output:

Correct:

from collections import Counter

2. Using defaultdict Incorrectly

Incorrect:

defaultdict()

Always provide a default factory.

Correct:

defaultdict(list)

3. Treating namedtuple Like a Dictionary

Incorrect:

student["name"]

Correct:

student.name

4. Using deque Like a List

Although possible, deque is designed primarily for queue operations.

5. Modifying ChainMap Unexpectedly

Changes affect the first dictionary in the chain.

Be careful when updating values.

Conclusion

The Python Collections Module is a powerful part of Python’s standard library that extends the functionality of built-in data structures. Classes such as Counter, defaultdict, OrderedDict, namedtuple, deque, and ChainMap simplify common programming tasks, improve code readability, and often provide better performance than traditional data structures.

Whether you’re counting data, grouping records, managing queues, creating structured objects, or combining dictionaries, the Collections Module offers efficient solutions.

Related Python Tutorials