Python - namedtuple

namedtuple in Python

In Python, the namedtuple is a class factory provided by the collections module that generates tuple subclasses with named fields. It provides all the functionality of a tuple, but with more readability and self-documentation due to its named fields. It is especially useful when you want immutable, lightweight, and readable data structures that behave like regular classes without the need to define an entire class manually.

What is namedtuple?

The namedtuple function returns a new tuple subclass named by the user, with named fields accessible via dot notation as well as the traditional tuple indexing. It is ideal for creating small, immutable, class-like objects in a compact and memory-efficient manner.

Importing namedtuple

from collections import namedtuple

Syntax

namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)

• typename: the name of the new class (str)
• field_names: iterable of field names or a space-separated string
• rename: if True, invalid names are automatically renamed
• defaults: default values for fields
• module: sets the __module__ attribute

Basic Example

from collections import namedtuple

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

p1 = Point(10, 20)
print(p1.x, p1.y)
print(p1[0], p1[1])

Advantages of namedtuple

• Provides named access to tuple elements
• Enhances code readability
• Immutable like regular tuples
• Less memory than a custom class with __slots__
• Supports useful methods like _make(), _asdict(), _replace()

Accessing Elements

Person = namedtuple('Person', ['name', 'age', 'gender'])

john = Person('John Doe', 30, 'Male')

print(john.name)
print(john[0])

Creating namedtuples in Different Ways

Using List of Strings

Car = namedtuple('Car', ['brand', 'model', 'year'])

Using Space-separated String

Car = namedtuple('Car', 'brand model year')

Using Default Values

Employee = namedtuple('Employee', ['name', 'dept', 'salary'], defaults=['HR', 30000])
emp = Employee('Alice')

print(emp)

Useful Methods of namedtuple

_make(iterable)

Creates an instance from an iterable like a list or tuple.

Point = namedtuple('Point', 'x y')
p = Point._make([3, 4])
print(p)

_asdict()

Returns a dictionary representation of the namedtuple.

print(p._asdict())

_replace(**kwargs)

Returns a new namedtuple with specified fields replaced.

p2 = p._replace(x=10)
print(p2)

_fields

Returns a tuple of field names.

print(p._fields)

Working with namedtuples in Loops

Student = namedtuple('Student', 'name grade')

students = [
    Student('Alice', 'A'),
    Student('Bob', 'B'),
    Student('Charlie', 'A'),
]

for s in students:
    print(f"{s.name} scored {s.grade}")

Unpacking namedtuple

Rectangle = namedtuple('Rectangle', 'length width')
rect = Rectangle(10, 5)

l, w = rect
print("Length:", l)
print("Width:", w)

namedtuple vs dict vs class

Using dict

employee = {'name': 'Tom', 'role': 'Manager'}
print(employee['name'])

Using class

class Employee:
    def __init__(self, name, role):
        self.name = name
        self.role = role

e = Employee('Tom', 'Manager')
print(e.name)

Using namedtuple

Employee = namedtuple('Employee', 'name role')
e = Employee('Tom', 'Manager')
print(e.name)

When to Use namedtuple

• When you need a lightweight object with immutable properties
• When readability and access by attribute names matter
• When working with structured data like coordinates, RGB values, records
• When performance is critical (namedtuple is faster than class)

Performance Comparison

namedtuple is significantly faster than regular class instantiation and uses less memory.

from collections import namedtuple
import time

Point = namedtuple('Point', 'x y')

start = time.time()
for _ in range(1000000):
    p = Point(10, 20)
end = time.time()

print("namedtuple time:", end - start)

Real-world Example: Representing a Database Record

Student = namedtuple('Student', ['id', 'name', 'grade'])

students = [
    Student(101, 'Alice', 'A'),
    Student(102, 'Bob', 'B'),
    Student(103, 'Charlie', 'A'),
]

for s in students:
    print(s._asdict())

Handling Invalid Field Names

fields = ['name', 'class', 'score']

# class is a keyword, rename will rename it
Student = namedtuple('Student', fields, rename=True)
s = Student('Alice', '10A', 95)

print(s)

namedtuple with Optional Fields (Defaults)

Person = namedtuple('Person', 'name age city', defaults=['Unknown'])
p = Person('John', 30)
print(p)

Using namedtuple with JSON

import json
from collections import namedtuple

json_data = '{"name": "Alice", "age": 30}'
data = json.loads(json_data)

Person = namedtuple('Person', data.keys())
person = Person(*data.values())

print(person)

Nested namedtuples

Address = namedtuple('Address', 'city state')
Employee = namedtuple('Employee', 'name address')

emp = Employee('John', Address('New York', 'NY'))
print(emp.address.city)

Modifying a namedtuple

Since namedtuples are immutable, use _replace to modify fields.

Book = namedtuple('Book', 'title author')
book1 = Book('Python 101', 'Guido')

book2 = book1._replace(author='Rossum')
print(book2)

namedtuple and type hinting

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(1, 2)
print(p)

Best Practices

• Use namedtuple for simple, immutable data structures
• Prefer list/tuple/dict when mutability is needed
• Use defaults for backward compatibility
• Use rename=True to avoid issues with reserved keywords

Summary

Python's namedtuple is an incredibly useful feature for creating lightweight, immutable, and readable data structures. It eliminates the need for verbose class definitions while giving the benefits of attribute-based access. Whether you are designing coordinate systems, parsing structured records, or building functional-style applications, namedtuples offer clarity and performance.

Key Takeaways:

• namedtuple is in the collections module
• Provides immutability with field access
• Supports helpful methods like _make, _asdict, _replace
• Can be nested and used with defaults
• Ideal for clean, readable, efficient code