Python Collections Module Exercises: 25 Coding Problems on Counter, defaultdict, OrderedDict, deque, namedtuple

This article offers 25 exercises to help you get comfortable with Python’s collections module through hands-on practice. You’ll explore Counter for frequency analysis and arithmetic operations; defaultdict for clean grouping and graph building; OrderedDict for order-aware data structures including an LRU cache implementation; deque for efficient queue, stack, and sliding-window patterns; and namedtuple for lightweight, readable record types

Each coding challenge includes a Practice Problem, Hint, Solution code, and detailed Explanation, ensuring you don’t just copy code, but genuinely practice and understand how and why it works.

• All solutions have been fully tested on Python 3.
• Use our Online Code Editor to solve these exercises in real time.
• Also, Solve Python Exercises: 29 topic-wise exercises with over 800+ coding questions

Let us know if you have any alternative solutions. It will help other developers.

Exercise 1: Word Frequency Counter

Problem Statement: Write a Python program that takes a sentence string and uses Counter to count how many times each word appears, then prints each word alongside its frequency.

Purpose: Counting word frequencies is one of the most common text processing tasks, appearing in search engines, NLP pipelines, content analysis tools, and spam filters. This exercise introduces Counter as a purpose-built, readable alternative to manually incrementing dictionary keys in a loop.

Given Input: sentence = "the cat sat on the mat the cat sat"

Expected Output: Each word and its count printed on a separate line, e.g. the: 3, cat: 2, sat: 2, on: 1, mat: 1

from collections import Counter

sentence = "the cat sat on the mat the cat sat"
words = sentence.lower().split()

word_count = Counter(words)

for word, count in word_count.items():
    print(f"{word}: {count}")Code language: Python (python)

Exercise 2: Most Common Elements

Problem Statement: Write a Python program that takes a list of items and uses Counter.most_common(n) to find and print the top 3 most frequently occurring elements along with their counts.

Purpose: Finding the top N most frequent elements is a classic problem in data analysis, log monitoring, and recommendation systems. The most_common() method solves it in one line without sorting manually, making this one of the most practically useful features of Counter.

Given Input: items = ["apple", "banana", "apple", "cherry", "banana", "apple", "date", "cherry", "banana", "apple"]

Expected Output: apple: 4, banana: 3, cherry: 2

from collections import Counter

items = ["apple", "banana", "apple", "cherry", "banana", "apple",
         "date", "cherry", "banana", "apple"]

item_count = Counter(items)

print("Top 3 most common elements:")
for item, count in item_count.most_common(3):
    print(f"  {item}: {count}")Code language: Python (python)

Exercise 3: Subtract Two Counters

Problem Statement: Write a Python program that creates two Counter objects from two lists and subtracts one from the other to find the difference in element counts, then prints only the elements with a positive remaining count.

Purpose: Counter arithmetic is useful in inventory management, stock reconciliation, and diff-checking tools where you need to know what remains after removing a set of items from a collection. This exercise highlights the difference between the - operator and the .subtract() method, which handle negative results differently.

Given Input: stock = ["apple", "apple", "apple", "banana", "banana", "cherry"] and sold = ["apple", "apple", "banana", "cherry", "cherry"]

Expected Output: apple: 1, banana: 1 (items with positive remaining count only)

from collections import Counter

stock = ["apple", "apple", "apple", "banana", "banana", "cherry"]
sold  = ["apple", "apple", "banana", "cherry", "cherry"]

stock_counter = Counter(stock)
sold_counter  = Counter(sold)

print("Stock :", dict(stock_counter))
print("Sold  :", dict(sold_counter))

# The - operator keeps only positive results
remaining = stock_counter - sold_counter

print("\nRemaining stock (positive counts only):")
for item, count in remaining.items():
    print(f"  {item}: {count}")

# subtract() keeps zero and negative values
stock_counter.subtract(sold_counter)
print("\nAfter .subtract() (includes zero and negative):")
for item, count in stock_counter.items():
    print(f"  {item}: {count}")Code language: Python (python)

Exercise 4: Character Frequency in a String

Problem Statement: Write a Python program that uses Counter to count the frequency of every character in a given string, then prints only the alphabetic characters sorted from most to least frequent.

Purpose: Character frequency analysis is foundational in cryptography, compression algorithms, language detection, and data validation. This exercise also reinforces filtering and sorting a Counter result, skills that extend naturally to any frequency-ranked output.

Given Input: text = "hello world"

Expected Output: Alphabetic characters sorted by frequency descending, e.g. l: 3, o: 2, h: 1, e: 1, w: 1, r: 1, d: 1

from collections import Counter

text = "hello world"

char_count = Counter(text)

print("Alphabetic character frequencies (most to least):")
for char, count in char_count.most_common():
    if char.isalpha():
        print(f"  '{char}': {count}")Code language: Python (python)

Exercise 5: Combine Counters with Addition

Problem Statement: Write a Python program that creates two Counter objects representing separate item inventories and combines them using the + operator to produce a single merged total inventory.

Purpose: Merging frequency maps is a common operation when aggregating data from multiple sources – such as combining sales figures from different stores, merging word counts from multiple documents, or consolidating log entries. The + operator on Counter handles this cleanly without manual looping.

Given Input: warehouse_a = Counter({"apple": 50, "banana": 30, "cherry": 20}) and warehouse_b = Counter({"banana": 40, "cherry": 10, "date": 60})

Expected Output: apple: 50, banana: 70, cherry: 30, date: 60

from collections import Counter

warehouse_a = Counter({"apple": 50, "banana": 30, "cherry": 20})
warehouse_b = Counter({"banana": 40, "cherry": 10, "date": 60})

combined = warehouse_a + warehouse_b

print("Merged inventory:")
for item, count in sorted(combined.items()):
    print(f"  {item}: {count}")Code language: Python (python)

Exercise 6: Group Words by First Letter

Problem Statement: Write a Python program that takes a list of words and uses defaultdict(list) to group them alphabetically by their first letter, then prints each group.

Purpose: Grouping items by a shared attribute is one of the most common data transformation tasks in programming. Using defaultdict(list) eliminates the need for repetitive if key not in dict checks before appending, resulting in cleaner and more readable grouping logic.

Given Input: words = ["apple", "avocado", "banana", "blueberry", "cherry", "apricot", "cranberry", "bluebell"]

Expected Output: Each letter printed as a heading followed by the words starting with that letter, e.g. a: ['apple', 'avocado', 'apricot']

from collections import defaultdict

words = ["apple", "avocado", "banana", "blueberry",
         "cherry", "apricot", "cranberry", "bluebell"]

grouped = defaultdict(list)

for word in words:
    key = word[0].lower()
    grouped[key].append(word)

for letter, group in sorted(grouped.items()):
    print(f"{letter}: {group}")Code language: Python (python)

Exercise 7: Count Occurrences Without KeyError

Problem Statement: Write a Python program that counts the occurrences of each item in a list using defaultdict(int), without any manual initialisation of keys, and prints each item with its count.

Purpose: Before Counter and defaultdict existed, counting with a plain dictionary required checking for key existence on every update. This exercise shows how defaultdict(int) solves that cleanly and helps you understand the underlying mechanism that Counter itself builds upon.

Given Input: colours = ["red", "blue", "red", "green", "blue", "blue", "red", "yellow"]

Expected Output: red: 3, blue: 3, green: 1, yellow: 1

from collections import defaultdict

colours = ["red", "blue", "red", "green", "blue", "blue", "red", "yellow"]

counts = defaultdict(int)

for colour in colours:
    counts[colour] += 1

print("Colour counts:")
for colour, count in counts.items():
    print(f"  {colour}: {count}")

# Comparison: plain dict equivalent (more verbose)
plain_counts = {}
for colour in colours:
    if colour not in plain_counts:
        plain_counts[colour] = 0
    plain_counts[colour] += 1Code language: Python (python)

Exercise 8: Build an Adjacency List

Problem Statement: Write a Python program that reads a list of directed edge pairs and uses defaultdict(list) to build and print an adjacency list representation of the graph.

Purpose: The adjacency list is the most common way to represent graphs in software. It appears in network routing, social graph analysis, dependency resolution, and pathfinding algorithms. Using defaultdict(list) makes building one from a raw edge list concise and free of key-existence boilerplate.

Given Input: edges = [("A", "B"), ("A", "C"), ("B", "D"), ("C", "D"), ("D", "E")]

Expected Output: Each node printed with its list of neighbours, e.g. A: ['B', 'C'], B: ['D'], C: ['D'], D: ['E']

from collections import defaultdict

edges = [("A", "B"), ("A", "C"), ("B", "D"), ("C", "D"), ("D", "E")]

# Directed graph
graph = defaultdict(list)

for src, dst in edges:
    graph[src].append(dst)

print("Adjacency list (directed graph):")
for node, neighbours in sorted(graph.items()):
    print(f"  {node}: {neighbours}")

# Undirected graph variant
undirected = defaultdict(list)
for src, dst in edges:
    undirected[src].append(dst)
    undirected[dst].append(src)

print("\nAdjacency list (undirected graph):")
for node, neighbours in sorted(undirected.items()):
    print(f"  {node}: {neighbours}")Code language: Python (python)

Exercise 9: Nested defaultdict

Problem Statement: Write a Python program that uses a nested defaultdict to store a two-level dictionary representing departments and their employee names, then prints the full structure without manually creating any inner dictionaries.

Purpose: Nested data grouping is a frequent requirement in reporting, configuration management, and data pipelines. A nested defaultdict eliminates the need to check whether an inner dictionary exists before writing to it, making multi-level data assembly significantly cleaner than with plain dictionaries.

Given Input: A list of (department, employee) tuples: [("Engineering", "Alice"), ("Marketing", "Bob"), ("Engineering", "Charlie"), ("Marketing", "Diana"), ("HR", "Eve")]

Expected Output: Each department printed as a heading followed by its employees and their placeholder data, e.g. Engineering: {'Alice': [], 'Charlie': []}

from collections import defaultdict

records = [
    ("Engineering", "Alice"),
    ("Marketing",   "Bob"),
    ("Engineering", "Charlie"),
    ("Marketing",   "Diana"),
    ("HR",          "Eve"),
]

# Nested defaultdict: outer key = department, inner key = employee name
org = defaultdict(lambda: defaultdict(list))

for dept, employee in records:
    org[dept][employee]  # auto-initialises both levels

print("Organisation structure:")
for dept, employees in sorted(org.items()):
    print(f"  {dept}:")
    for name in sorted(employees):
        print(f"    - {name}")Code language: Python (python)

Exercise 10: defaultdict with set

Problem Statement: Write a Python program that takes a list of (student, subject) pairs and uses defaultdict(set) to collect all unique subjects each student is enrolled in, then prints each student’s subject list.

Purpose: Using a set as the default value automatically deduplicates entries, which is ideal when the source data may contain repeated pairs. This pattern appears in access control systems, tag collections, and any scenario where you need to associate a key with a unique group of values rather than an ordered list.

Given Input: enrolments = [("Alice", "Maths"), ("Bob", "Science"), ("Alice", "Science"), ("Alice", "Maths"), ("Bob", "Maths"), ("Charlie", "Science")]

Expected Output: Each student with their unique subjects, e.g. Alice: {'Maths', 'Science'}, Bob: {'Science', 'Maths'}, Charlie: {'Science'}

from collections import defaultdict

enrolments = [
    ("Alice",   "Maths"),
    ("Bob",     "Science"),
    ("Alice",   "Science"),
    ("Alice",   "Maths"),      # duplicate - will be ignored by the set
    ("Bob",     "Maths"),
    ("Charlie", "Science"),
]

subjects_by_student = defaultdict(set)

for student, subject in enrolments:
    subjects_by_student[student].add(subject)

print("Student enrolments (unique subjects):")
for student, subjects in sorted(subjects_by_student.items()):
    print(f"  {student}: {sorted(subjects)}")Code language: Python (python)

Exercise 11: Preserve Insertion Order

Problem Statement: Write a Python program that creates an OrderedDict from a list of key-value pairs and demonstrates that iteration always reflects the original insertion order, even after accessing individual keys.

Purpose: While Python 3.7 and later guarantee insertion order for regular dicts, OrderedDict remains relevant because it makes the ordering guarantee explicit in the code’s intent, supports additional order-aware methods like move_to_end(), and behaves differently in equality comparisons – as shown in Exercise 14. This exercise builds the foundation for the more advanced OrderedDict exercises that follow.

Given Input: pairs = [("banana", 3), ("apple", 5), ("cherry", 1), ("date", 8), ("elderberry", 2)]

Expected Output: Keys and values printed in insertion order: banana: 3, apple: 5, cherry: 1, date: 8, elderberry: 2

from collections import OrderedDict

pairs = [("banana", 3), ("apple", 5), ("cherry", 1),
         ("date", 8), ("elderberry", 2)]

od = OrderedDict(pairs)

print("Insertion order preserved:")
for key, value in od.items():
    print(f"  {key}: {value}")

# Access a key and confirm order is unchanged
_ = od["apple"]

print("\nOrder after accessing 'apple' (unchanged):")
for key, value in od.items():
    print(f"  {key}: {value}")Code language: Python (python)

Exercise 12: Move to End

Problem Statement: Write a Python program that creates an OrderedDict of tasks, then uses move_to_end() to promote one task to the front and demote another to the back, printing the order before and after each operation.

Purpose: Repositioning elements within an ordered collection is central to priority queues, recently-used lists, and scheduling systems. move_to_end() performs this in-place in O(1) time, making it far more efficient than deleting and re-inserting a key in a plain dictionary.

Given Input: tasks = [("task_1", "Write tests"), ("task_2", "Fix bug"), ("task_3", "Deploy"), ("task_4", "Code review"), ("task_5", "Update docs")]

Expected Output: The task list printed three times: original order, after moving task_3 to the front, and after moving task_1 to the back.

from collections import OrderedDict

tasks = OrderedDict([
    ("task_1", "Write tests"),
    ("task_2", "Fix bug"),
    ("task_3", "Deploy"),
    ("task_4", "Code review"),
    ("task_5", "Update docs"),
])

def print_tasks(label, od):
    print(f"\n{label}:")
    for key, value in od.items():
        print(f"  {key}: {value}")

print_tasks("Original order", tasks)

# Move task_3 to the front (highest priority)
tasks.move_to_end("task_3", last=False)
print_tasks("After moving 'task_3' to front", tasks)

# Move task_1 to the back (lowest priority)
tasks.move_to_end("task_1")
print_tasks("After moving 'task_1' to back", tasks)Code language: Python (python)

Exercise 13: Implement a Simple LRU Cache

Problem Statement: Write a Python program that implements a basic Least Recently Used (LRU) cache using OrderedDict. The cache should store up to a fixed number of entries and automatically evict the least recently used item when the limit is exceeded.

Purpose: LRU caches are used in web browsers, database query caches, CDN layers, and CPU memory management to keep frequently accessed data in fast storage while discarding stale entries. Building one with OrderedDict is a classic interview question that demonstrates mastery of both data structure selection and cache eviction logic.

Given Input: A cache with capacity = 3, followed by a sequence of get and put operations that triggers at least one eviction.

Expected Output: Cache state printed after each operation showing which items are present and which was evicted.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = OrderedDict()

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)   # mark as most recently used
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            evicted_key, evicted_val = self.cache.popitem(last=False)
            print(f"  [evicted] {evicted_key}: {evicted_val}")

    def display(self):
        print(f"  Cache (LRU to MRU): {list(self.cache.items())}")


lru = LRUCache(capacity=3)

print("put(A, 1)"); lru.put("A", 1); lru.display()
print("put(B, 2)"); lru.put("B", 2); lru.display()
print("put(C, 3)"); lru.put("C", 3); lru.display()
print(f"get(A) -> {lru.get('A')}");  lru.display()
print("put(D, 4) -- eviction expected")
lru.put("D", 4); lru.display()
print(f"get(B) -> {lru.get('B')}")   # B was evictedCode language: Python (python)

Exercise 14: Compare Two OrderedDicts

Problem Statement: Write a Python program that demonstrates the difference in equality behaviour between two regular dicts and two OrderedDict objects that contain the same keys and values but in different insertion orders.

Purpose: Understanding how equality works for OrderedDict versus dict prevents subtle bugs in code that compares configurations, serialised records, or cached results where insertion order may differ. This is one of the most commonly misunderstood behaviours of OrderedDict.

Given Input: Two dictionaries and two OrderedDict objects, each containing {"a": 1, "b": 2, "c": 3} but constructed in different key orders.

Expected Output: dict equality: True and OrderedDict equality: False

from collections import OrderedDict

# Plain dicts - order does not affect equality
dict_1 = {"a": 1, "b": 2, "c": 3}
dict_2 = {"c": 3, "a": 1, "b": 2}
print(f"dict equality (different order)      : {dict_1 == dict_2}")

# OrderedDicts - order DOES affect equality
od_1 = OrderedDict([("a", 1), ("b", 2), ("c", 3)])
od_2 = OrderedDict([("c", 3), ("a", 1), ("b", 2)])
print(f"OrderedDict equality (different order): {od_1 == od_2}")

# Same order - now they are equal
od_3 = OrderedDict([("a", 1), ("b", 2), ("c", 3)])
print(f"OrderedDict equality (same order)     : {od_1 == od_3}")

# Cross-type: OrderedDict vs plain dict
print(f"OrderedDict vs dict (same data)       : {od_1 == dict_1}")Code language: Python (python)

Exercise 15: Reverse an OrderedDict

Problem Statement: Write a Python program that creates an OrderedDict and iterates over it in reverse order using reversed(), printing key-value pairs from last inserted to first inserted.

Purpose: Reverse iteration over an ordered collection is useful when displaying recent history, processing a stack of operations in reverse, or presenting results in descending insertion sequence. OrderedDict supports reversed() directly, whereas reversing a plain dict requires converting it to a list first in older Python versions.

Given Input: steps = [("step_1", "Load data"), ("step_2", "Clean data"), ("step_3", "Analyse"), ("step_4", "Visualise"), ("step_5", "Export")]

Expected Output: Steps printed in reverse insertion order from step_5 down to step_1.

from collections import OrderedDict

steps = OrderedDict([
    ("step_1", "Load data"),
    ("step_2", "Clean data"),
    ("step_3", "Analyse"),
    ("step_4", "Visualise"),
    ("step_5", "Export"),
])

print("Forward order:")
for key, value in steps.items():
    print(f"  {key}: {value}")

print("\nReverse order:")
for key, value in reversed(steps.items()):
    print(f"  {key}: {value}")Code language: Python (python)

Exercise 16: Basic deque Operations

Problem Statement: Write a Python program that creates a deque from a list and demonstrates the four core operations: append(), appendleft(), pop(), and popleft(), printing the deque state after each operation.

Purpose: A deque (double-ended queue) supports O(1) insertions and removals from both ends, unlike a list where inserting or removing from the front is O(n). Understanding the four core operations is essential before using deque in queues, stacks, sliding windows, and history buffers covered in subsequent exercises.

Given Input: initial = [2, 3, 4]

Expected Output: The deque state printed after each of the six operations showing how items enter and leave from both ends.

from collections import deque

dq = deque([2, 3, 4])
print(f"Initial              : {list(dq)}")

dq.append(5)
print(f"After append(5)      : {list(dq)}")

dq.appendleft(1)
print(f"After appendleft(1)  : {list(dq)}")

right = dq.pop()
print(f"After pop()  -> {right}   : {list(dq)}")

left = dq.popleft()
print(f"After popleft() -> {left} : {list(dq)}")

dq.extend([6, 7])
print(f"After extend([6,7])  : {list(dq)}")

dq.extendleft([0, -1])
print(f"After extendleft([0,-1]): {list(dq)}")Code language: Python (python)

Exercise 17: Implement a Queue (FIFO)

Problem Statement: Write a Python program that simulates a customer service queue using a deque, where customers join at the back and are served from the front, printing the queue state after each operation.

Purpose: A queue (First In, First Out) is one of the most fundamental data structures in computer science. It models real-world waiting lines, task schedulers, breadth-first search frontiers, and message buffers. Using deque instead of a list gives O(1) performance at both ends, making it the correct tool for queue implementation in Python.

Given Input: A sequence of customer arrivals and service operations applied to an initially empty queue.

Expected Output: The queue state printed after each arrival and each service event, showing customers entering at the back and leaving from the front.

from collections import deque

queue = deque()

def enqueue(customer):
    queue.append(customer)
    print(f"  Arrived : {customer:10s} | Queue: {list(queue)}")

def serve():
    if queue:
        customer = queue.popleft()
        print(f"  Served  : {customer:10s} | Queue: {list(queue)}")
    else:
        print("  No customers waiting.")

print("=== Customer Service Queue ===")
enqueue("Alice")
enqueue("Bob")
enqueue("Charlie")
serve()
enqueue("Diana")
serve()
serve()
serve()
serve()    # empty queue caseCode language: Python (python)

Exercise 18: Implement a Stack (LIFO)

Problem Statement: Write a Python program that uses a deque to implement a stack where items are pushed onto and popped from the same end, simulating a browser back-navigation history.

Purpose: A stack (Last In, First Out) underpins function call frames, expression evaluation, undo systems, and depth-first search. Although a plain Python list supports stack operations, using deque makes the intent explicit and consistent with the queue implementation, reinforcing the idea that deque can model both structures depending on which end is used.

Given Input: A sequence of page visits and back-navigation events applied to an initially empty history stack.

Expected Output: The stack state printed after each push and pop, showing pages added and removed from the same end.

from collections import deque

history = deque()

def visit(page):
    history.append(page)
    print(f"  Visited : {page:20s} | Current: {history[-1]}")

def go_back():
    if len(history) > 1:
        history.pop()
        print(f"  Back    : {'':20s} | Current: {history[-1]}")
    elif len(history) == 1:
        print(f"  Already at first page: {history[0]}")
    else:
        print("  No history.")

print("=== Browser Navigation Stack ===")
visit("https://home.com")
visit("https://about.com")
visit("https://products.com")
visit("https://contact.com")
go_back()
go_back()
go_back()
go_back()    # already at first pageCode language: Python (python)

Exercise 19: Rotating a deque

Problem Statement: Write a Python program that creates a deque of tasks and uses deque.rotate(n) to shift the elements right by 2 positions and then left by 2 positions, printing the state after each rotation.

Purpose: Rotation is useful in round-robin scheduling, circular buffer simulations, and any algorithm that needs to cycle through a fixed collection repeatedly. deque.rotate() performs the operation in O(n) time in a single method call, without needing to manually slice, concatenate, or reassign elements.

Given Input: tasks = ["Design", "Develop", "Test", "Review", "Deploy"]

Expected Output: Task list printed in original order, after rotating right by 2, and after rotating left by 2.

from collections import deque

tasks = deque(["Design", "Develop", "Test", "Review", "Deploy"])

print(f"Original order   : {list(tasks)}")

tasks.rotate(2)
print(f"After rotate(+2) : {list(tasks)}")

tasks.rotate(-2)
print(f"After rotate(-2) : {list(tasks)}")

# Demonstrate round-robin scheduling
print("\nRound-robin task scheduling (5 turns):")
for turn in range(1, 6):
    current_task = tasks[0]
    print(f"  Turn {turn}: processing '{current_task}'")
    tasks.rotate(-1)    # move current task to back, advance to nextCode language: Python (python)

Exercise 20: Bounded deque for Recent History

Problem Statement: Write a Python program that creates a deque with maxlen=5 to simulate a recent browsing history buffer, demonstrating that adding a sixth item automatically discards the oldest entry.

Purpose: A bounded deque is the simplest way to maintain a fixed-size sliding window of recent events without manually checking length or removing old entries. It appears in terminal command history, log tail buffers, moving average calculations, and any feature that shows “last N items” to the user.

Given Input: A sequence of six page URLs added one at a time to a deque(maxlen=5).

Expected Output: History buffer state after each addition, showing the oldest URL being dropped when the sixth is added.

from collections import deque

history = deque(maxlen=5)

pages = [
    "https://home.com",
    "https://about.com",
    "https://products.com",
    "https://blog.com",
    "https://contact.com",
    "https://pricing.com",   # this will push out the oldest entry
]

print(f"Max history size: {history.maxlen}\n")

for page in pages:
    history.append(page)
    print(f"Visited: {page}")
    print(f"History: {list(history)}\n")Code language: Python (python)

Exercise 21: Create a namedtuple

Problem Statement: Write a Python program that defines a Point namedtuple with fields x and y, creates two instances, and accesses their coordinates using both attribute access and positional index access.

Purpose: A namedtuple gives a plain tuple named fields, making code that passes coordinate pairs, RGB values, or simple records significantly more readable than using raw index numbers. It is immutable, memory-efficient, and fully compatible with code that expects regular tuples, making it a zero-overhead upgrade over anonymous tuples.

Given Input: Two points – Point(3, 7) and Point(10, 4).

Expected Output: Coordinates accessed by attribute name and by index, plus the distance between the two points.

from collections import namedtuple
import math

Point = namedtuple("Point", ["x", "y"])

p1 = Point(3, 7)
p2 = Point(10, 4)

# Attribute access
print(f"p1 - x: {p1.x}, y: {p1.y}")
print(f"p2 - x: {p2.x}, y: {p2.y}")

# Index access (namedtuples are still tuples)
print(f"p1 via index  - [0]: {p1[0]}, [1]: {p1[1]}")

# Unpacking (works like a regular tuple)
x, y = p2
print(f"p2 unpacked   - x={x}, y={y}")

# Distance calculation
distance = math.sqrt((p2.x - p1.x)**2 + (p2.y - p1.y)**2)
print(f"Distance p1 to p2: {distance:.2f}")Code language: Python (python)

Exercise 22: namedtuple as a Lightweight Record

Problem Statement: Write a Python program that defines an Employee namedtuple with fields name, department, and salary, creates a list of employee records, and prints all employees belonging to a specific department.

Purpose: Namedtuples are an excellent lightweight alternative to full classes or dictionaries for storing structured records when no methods or mutability are needed. This pattern is widely used for database row representations, CSV record models, API response objects, and configuration entries where clarity and low overhead matter.

Given Input: A list of five Employee records across three departments. Filter for "Engineering".

Expected Output: Name and salary of every employee in the Engineering department, one per line.

from collections import namedtuple

Employee = namedtuple("Employee", ["name", "department", "salary"])

employees = [
    Employee("Alice",   "Engineering", 95000),
    Employee("Bob",     "Marketing",   72000),
    Employee("Charlie", "Engineering", 88000),
    Employee("Diana",   "HR",          65000),
    Employee("Eve",     "Engineering", 102000),
]

target_dept = "Engineering"
print(f"Employees in {target_dept}:")

dept_employees = [e for e in employees if e.department == target_dept]

for emp in dept_employees:
    print(f"  {emp.name:10s} | Salary: £{emp.salary:,}")

print(f"\nTotal in {target_dept}: {len(dept_employees)}")
avg = sum(e.salary for e in dept_employees) / len(dept_employees)
print(f"Average salary     : £{avg:,.0f}")Code language: Python (python)

Exercise 23: Convert namedtuple to Dictionary

Problem Statement: Write a Python program that creates a namedtuple instance and converts it to a regular dictionary using the _asdict() method, then demonstrates how to use the resulting dictionary for JSON serialisation.

Purpose: Namedtuples cannot be directly serialised to JSON because json.dumps() does not recognise them as dictionaries. Converting to a dict first is the standard bridge between the lightweight namedtuple record model and JSON-based APIs, configuration files, or database serialisation layers.

Given Input: A Product namedtuple with fields name, category, price, and in_stock.

Expected Output: The namedtuple printed as a dict, then as a JSON string.

from collections import namedtuple
import json

Product = namedtuple("Product", ["name", "category", "price", "in_stock"])

product = Product(name="Laptop", category="Electronics",
                  price=999.99, in_stock=True)

# Convert to dictionary
product_dict = product._asdict()
print("As dict:")
print(f"  {product_dict}")

# Serialise to JSON
product_json = json.dumps(product_dict, indent=2)
print("\nAs JSON:")
print(product_json)

# Reconstruct namedtuple from dict
restored = Product(**product_dict)
print(f"\nRestored namedtuple: {restored}")
print(f"Equal to original  : {restored == product}")Code language: Python (python)

Exercise 24: Replace a Field Value

Problem Statement: Write a Python program that creates a namedtuple instance representing a product listing and uses the _replace() method to produce updated copies with changed field values, without modifying the original instance.

Purpose: Because namedtuples are immutable, _replace() is the correct way to create a modified version of an existing record – analogous to using dataclasses.replace() for dataclasses or spread syntax in JavaScript. This pattern is common in functional programming workflows where data is never mutated in place.

Given Input: A Listing namedtuple with fields title, price, available, and rating.

Expected Output: Original listing printed, then two modified copies with updated fields, confirming the original is unchanged.

from collections import namedtuple

Listing = namedtuple("Listing", ["title", "price", "available", "rating"])

original = Listing(title="Wireless Headphones", price=79.99,
                   available=True, rating=4.3)

print(f"Original  : {original}")

# Update price only
discounted = original._replace(price=59.99)
print(f"Discounted: {discounted}")

# Mark as unavailable and update rating
updated = original._replace(available=False, rating=4.5)
print(f"Updated   : {updated}")

# Confirm original is unchanged
print(f"\nOriginal unchanged: {original}")
print(f"Same object? {original is discounted}")Code language: Python (python)

Exercise 25: namedtuple with Default Values

Problem Statement: Write a Python program that defines a Config namedtuple using the defaults parameter so that some fields have fallback values and can be omitted at instantiation, then creates instances with and without the optional fields.

Purpose: Default values make namedtuples practical for configuration objects, optional record fields, and function return types where some fields may not always be populated. This feature was added in Python 3.6.1 and removes the need to subclass or use __new__ tricks to achieve optional fields.

Given Input: A Config namedtuple with required fields host and port, and optional fields debug (default False), timeout (default 30), and max_retries (default 3).

Expected Output: A fully specified config and a minimal config printed side by side, showing default values filling in the omitted fields.

from collections import namedtuple

Config = namedtuple(
    "Config",
    ["host", "port", "debug", "timeout", "max_retries"],
    defaults=[False, 30, 3]   # applies to debug, timeout, max_retries
)

# Inspect available defaults
print(f"Field defaults: {Config._field_defaults}\n")

# Fully specified instance
full_config = Config(
    host="api.example.com",
    port=8443,
    debug=True,
    timeout=60,
    max_retries=5
)

# Minimal instance - only required fields provided
minimal_config = Config(host="localhost", port=5000)

print(f"Full config   : {full_config}")
print(f"Minimal config: {minimal_config}")

# Display each field clearly
print("\nMinimal config field breakdown:")
for field, value in minimal_config._asdict().items():
    source = "(default)" if field in Config._field_defaults and \
             value == Config._field_defaults[field] else "(provided)"
    print(f"  {field:15s}: {str(value):6s} {source}")Code language: Python (python)