Python - NamedTuple

In Python,tuples are immutable data structures that can hold a collection of items. We already discussed tuples, it's properties and usage in the previous chapters. In this chapter, we will explainnamedtuple() and its usage in Python.

What is NamedTuple?

In Python, anamedtuple() is a subclass oftuple that allows you to create tuples with named fields. Meaning, you can access the elements of the tuple using fieldnames instead of just numerical indices. It is part of thecollections module in Python.

Syntax

from collections import namedtuple # Define a namedtuplePoint = namedtuple('typename', fieldnames )

• Type Name: The typename is the name of the namedtuple class. It is a string that represents the name of the tuple type.
• Field Names: The field names are the names of the elements in the tuple. They are defined as a list of strings.

Create a NamedTuple in Python

To create a namedtuple, you need to import thenamedtuple function from thecollections module. Then, you can define a namedtuple by specifying its name and field names.

The followingexample shows how to create a namedtuple calledPoint with fieldsx andy −

from collections import namedtuple# Define a namedtupleVertex = namedtuple('Vertex', ['x', 'y'])# Create an instancev = Vertex(10, 20)# Access fieldsprint("Vertex-1:", v.x)print("Vertex-2:", v.y)

Theoutput of the above code will be −

Vertex-1: 10Vertex-2: 20

Access NamedTuple Fields

We already saw how to access the fields of a namedtuple using dot notation(i.e., using keyname). There are some other ways to access the fields as well −

• Accessing by Indexing − You can access the fields using their index, just like a regular tuple.
• Accessing by keyname − You can also access the fields using their key names, similar to a dictionary.
• Accessing Using getattr() − You can use thegetattr() function to access the fields by name.

Example: Accessing by Indexing

In this example, we will access the fields of the namedtuple using their index.

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20)# Access fields by indexingprint("Point-1", p[0])print("Point-2", p[1])

Theoutput of the above code will be −

Point-1 10Point-2 20

Example: Accessing by keyname

In this example, we will access the fields of the namedtuple using their key names.

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20)# Access fields by keynameprint("Point-1:", p.x)print("Point-2:", p.y)

Theoutput of the above code will be −

Point-1: 10Point-2: 20

Example: Accessing Using getattr()

In this example, we will access the fields of the namedtuple using thegetattr() function.

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20) # Access fields using getattr()print("getattr(p, 'x'):", getattr(p, 'x'))print("getattr(p, 'y'):", getattr(p, 'y'))

Theoutput of the above code will be −

getattr(p, 'x'): 10getattr(p, 'y'): 20

NamedTuple Methods

Namedtuples come with additional built-in methods to handle common operations. The section below discusses some of these methods with examples.

The _fields() method

The_fields() method is used to access the field names of the namedtuple. It doesn't need any arguments and returns a tuple of the field names.

The followingexample demonstrates how to use the_fields() method −

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20)# Access fields using _fields()print("Fields of p:", p._fields)

Theoutput of the above code will be −

Fields of p: ('x', 'y')

The _replace() method

The_replace() method is used to create a new instance of the namedtuple with one or more fields replaced with new values. It takes keyword arguments where the keys are the field names and the values are the new values to be assigned.

The followingexample demonstrates how to use the_replace() method −

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20)# Replace a field valuep2 = p._replace(x=30)# Access fieldsprint("p2.x:", p2.x)print("p2.y:", p2.y)

Theoutput of the above code will be −

p2.x: 30p2.y: 20

The _asdict() method

The_asdict() method is used to convert the namedtuple into a regular dictionary. This function returns the OrderedDict() as constructed from the mapped values of namedtuple().

The followingexample demonstrates how to use the_asdict() method −

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20)# Convert to dictionaryd = p._asdict()print(d)

Theoutput of the above code will be −

{'x': 10, 'y': 20}

The _make() method

The_make() method is used to create a new instance of the namedtuple from an iterable (like a list or a tuple).

The followingexample demonstrates how to use the_make() method −

from collections import namedtuple# Define a namedtuplePoint = namedtuple('Point', ['x', 'y'])# Create an instancep = Point(10, 20)# Create a new instance using _make()p2 = Point._make([30, 40])# Access fieldsprint("p2.x:", p2.x)print("p2.y:", p2.y)

Theoutput of the above code will be −

p2.x: 30p2.y: 40

The ** (double star) operator

The** (double star) operator is used to unpack the fields of the namedtuple into keyword arguments. This can be useful when you want to pass the fields of a namedtuple to a function that accepts keyword arguments.

The followingexample demonstrates how to use the** operator −

import collections# Declaring namedtuple()Student = collections.namedtuple('Student',                                 ['name', 'age', 'DOB'])# Adding valuesS = Student('farhan', '23', '2541997')# initializing iterableli = ['nishu', '19', '411997']# initializing dictdi = {'name': "ravi", 'age': 24, 'DOB': '1391997'}# using ** operator to return namedtuple from dictionaryprint("The namedtuple instance from dict is  : ")print(Student(**di))

Theoutput of the above code will be −

The namedtuple instance from dict is  :Student(name='ravi', age=24, DOB='1391997')

NamedTuple vs Dictionary vs Classes

The main differences between NamedTuple, Dictionary, and Classes are as follows −

Conclusion

In this chapter, we have learned about namedtuples in Python, and it's differences from dictionaries and classes. A common question arise is that, when to use NamedTuple, Dictionary, or a Class? TheNamedTuple can be used when you need an immutable object with fixed fields, i.e., if you want features of both tuples and dictionaries. TheDictionary can be used when you need a mutable object with dynamic keys. andClass is used when you need a complex data structure with methods and behavior.