Python - Collections in Python

Collections in Python

In Python, collections are containers used to store, manage, and manipulate groups of related data. Python offers a variety of built-in collection types such as lists, tuples, sets, and dictionaries. Each collection type has unique properties and is suitable for different scenarios. Additionally, Python provides the collections module, which includes specialized container datatypes like namedtuple, deque, Counter, defaultdict, OrderedDict, and ChainMap.

This document will explore all the major collection types in Python, both built-in and those from the collections module, with syntax, examples, and use cases.

Built-in Collection Types

List

A list is an ordered, mutable collection that allows duplicate elements.

# Creating a list
fruits = ['apple', 'banana', 'cherry']

# Accessing elements
print(fruits[0])

# Adding elements
fruits.append('orange')

# Removing elements
fruits.remove('banana')

# Iterating over a list
for fruit in fruits:
    print(fruit)

Tuple

A tuple is an ordered, immutable collection that allows duplicate elements.

# Creating a tuple
coordinates = (10, 20)

# Accessing elements
print(coordinates[0])

# Tuples are immutable
# coordinates[0] = 15  # This will raise an error

# Tuple unpacking
x, y = coordinates
print(x, y)

Set

A set is an unordered collection of unique elements.

# Creating a set
numbers = {1, 2, 3, 3, 4}

# Adding elements
numbers.add(5)

# Removing elements
numbers.remove(2)

# Set operations
evens = {2, 4, 6}
odds = {1, 3, 5}
union = evens | odds
intersection = evens & odds

Dictionary

A dictionary is an unordered collection of key-value pairs. Keys must be unique and immutable.

# Creating a dictionary
student = {'name': 'Alice', 'age': 22, 'grade': 'A'}

# Accessing values
print(student['name'])

# Adding a new key-value pair
student['major'] = 'Physics'

# Removing a key
del student['grade']

# Iterating over a dictionary
for key, value in student.items():
    print(key, value)

The collections Module

Python's collections module provides alternative specialized data structures that are optimized for performance or convenience in specific use cases.

namedtuple

namedtuple is a factory function for creating tuple subclasses with named fields. It combines the simplicity of tuples with readable field names.

from collections import namedtuple

# Define a namedtuple
Point = namedtuple('Point', ['x', 'y'])

# Create an instance
p = Point(10, 20)

# Access using names
print(p.x, p.y)

deque

deque (double-ended queue) is optimized for fast appends and pops from both ends.

from collections import deque

# Creating a deque
d = deque(['a', 'b', 'c'])

# Append to right
d.append('d')

# Append to left
d.appendleft('z')

# Pop from right
d.pop()

# Pop from left
d.popleft()

print(d)

Counter

Counter counts the number of occurrences of elements in an iterable.

from collections import Counter

# Count character frequency
text = "banana"
counter = Counter(text)

print(counter)
print(counter['a'])

defaultdict

defaultdict returns a default value if the key has not been set yet, avoiding KeyError.

from collections import defaultdict

# Create a defaultdict with list as default factory
dd = defaultdict(list)

# Append without checking key
dd['fruits'].append('apple')
dd['fruits'].append('banana')

print(dd['fruits'])

OrderedDict

OrderedDict remembers the order of key insertions. (In Python 3.7+, regular dicts also preserve order, but OrderedDict provides extra functionality.)

from collections import OrderedDict

# Create OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3

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

ChainMap

ChainMap groups multiple dictionaries together and treats them as a single unit.

from collections import ChainMap

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

cm = ChainMap(dict1, dict2)

print(cm['a'])  # 1 from dict1
print(cm['b'])  # 2 from dict1 (comes first)
print(cm['c'])  # 4 from dict2

Comparing Collections

Use Cases for Different Collections

• Use list when you need an ordered collection with frequent insertions and deletions.
• Use tuple for immutable collections or fixed data structures.
• Use set for membership tests and removing duplicates.
• Use dict for fast key-value lookups and mappings.
• Use namedtuple when you want readable fields in immutable structures.
• Use deque for fast queue or stack-like behavior from both ends.
• Use Counter for counting hashable items.
• Use defaultdict to simplify dictionary operations with default values.
• Use OrderedDict when insertion order matters.
• Use ChainMap to combine multiple dictionaries.

Real-World Example: Counting Word Frequency

from collections import Counter

text = """
Python is simple, yet powerful.
Python is readable and flexible.
"""

# Split into words
words = text.lower().split()

# Count frequencies
counter = Counter(words)

# Most common words
print(counter.most_common(3))

Real-World Example: Multi-Level Dictionary Lookup with ChainMap

from collections import ChainMap

defaults = {'theme': 'light', 'language': 'English'}
user_settings = {'theme': 'dark'}

settings = ChainMap(user_settings, defaults)

print(settings['theme'])    # 'dark'
print(settings['language']) # 'English'

Real-World Example: Using defaultdict for Grouping

from collections import defaultdict

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

courses = defaultdict(list)

for name, subject in students:
    courses[name].append(subject)

print(dict(courses))

Conclusion

Python collections are essential tools for managing data in a structured and efficient way. Understanding when and how to use each type allows for more readable, maintainable, and performant code. While the built-in types like list, tuple, set, and dictionary are sufficient for most use cases, the collections module offers powerful enhancements and specialized structures that solve common programming problems more effectively.

Whether you're managing a queue, counting occurrences, or mapping user settings, Python collections provide the flexibility and power to handle complex data scenarios with elegance and simplicity.

Always choose the right collection based on:

• Ordering requirement
• Mutability
• Need for unique elements
• Frequency counting
• Default values

Mastering Python’s collection types will significantly improve your ability to solve real-world programming challenges efficiently and elegantly.