Introduction
As it has tuple in it's name, one thing is clear that it will add some superpower🦸♀️ to the tuples.
namedtuple is a special type of tuple that has named indices. Ofcourse, they also have normal integer indices as they are tuples anway.
Importing namedtuple
from collections import namedtuple
namedtuple creation
# Step 1: Define namedtuple
# 'typename'=> used when printing an obj & low-lvl stuff
# 'fieldnames'=> list of names of indices
Student = namedtuple(typename='Student',
field_names=['fname', 'lname', 'age']
)
# Step 2: Create a namedtuple
# explicitly assigning named indices
s1 = Student(fname="Shan", lname="Patel", age=19)
# named indices are inferred
s2 = Student("Kathan", "Vakharia", 19)
print(s1, s2, sep='\n')
"""OUTPUT
Student(fname='Shan', lname='Patel', age=19)
Student(fname='Kathan', lname='Vakharia', age=19)
"""
📑 It is important to note that the identifier you use for defining the
namedtuple(Student here) is the one you have to use while instantiating anamedtuple. It has nothing to do with thetypenameargument-It's just a name for your custom tuple sub-class.
Quoting the python documentation,
collections.namedtuple(typename, field_names,...)
- Returns a new tuple subclass named typename.
We can cross-verify if we want using issubclass function.
>>> issubclass(Student, tuple) True
# CORRECT WAY
s0 = Student("heet", "vakharia")
print(s0)
"""OUTPUT
blah(fname='heet', lname='vakharia')
""""
# INCORRECT way
Student = namedtuple(typename="blah",
field_names=["fname", "lname"]
)
s1 = blah("kathan", "vakharia")
"""OUTPUT
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'blah' is not defined
"""
Indexing namedtuples
Indexing namedtuple object is very straight-forward. Here's how you do it,
# way1 : using integer indices
# Same like 'plain-tuples'
print("First element of s1: {}"
.format(s1[0]))
# way 2: using named indices 'NEW'
print("Element of s2 having named index lname: {}"
.format(s2.lname))
"""OUTPUT
First element of s1: Shan
Element of s2 having named index lname: Vakharia
"""
As it is a sub-class of tuple, it inherits all the methods and attributs of tuple.
However, there are some interesting methods pertaining to namedtuple. Let's see what are those,
classmethod somenamedtuple._make(iterable)
fields = ["John", "Doe", 34]
print(Student._make(fields))
"""OUTPUT
Student(fname='John', lname='Doe', age=34)
"""
somenamedtuple._asdict()
Returns a new dict which maps field names to their corresponding values,
from collections import namedtuple
Student = namedtuple(typename='Student',
field_names=['fname', 'lname', 'age'],
)
shan = Student(fname="Shan", lname="Patel", age=19)
kathan = Student("Kathan", "Vakharia", 19)
# namedtuple._asdict()
print(shan._asdict())
print(kathan._asdict())
"""OUTPUT
{'fname': 'Shan', 'lname': 'Patel', 'age': 19}
{'fname': 'Kathan', 'lname': 'Vakharia', 'age': 19}
"""
somenamedtuple._replace(**kwargs)
Returns a new instance of the named tuple replacing specified fields with new values.
kathan = Student("Kathan", "Vakharia", 19)
# a new tuple will be created with changed fname
kathan_v2 = kathan._replace(fname="Karsh")
print(kathan_v2)
# Old kathan is still unchanged
print(kathan)
"""OUTPUT
Student(fname='Karsh', lname='Vakharia', age=19)
Student(fname='Kathan', lname='Vakharia', age=19)
"""
And that wraps our discussion on namedtuple. I have intentionally left some minor functionalities because they are too trivial :) However, feel free to check out the documentation for that remaining 5% stuff.
Top comments (0)