Tuples and Namedtuples in Python Explained (Part 1)



Ever wondered what are tuples and namedtuples data types in Python? (Part 1)

Tuples are cool!

In Python, tuples and namedtuples are two unordered collections of immutable objects.

Tuples can be created using the tuple() constructor.

Tuples are used to store collections of data. Let's see an example:

empty_tuple = () # creates an empty tuple
another_empty_tuple = tuple() # creates another empty tuple
type(empty_tuple) # returns <class 'tuple'>
empty_typle == another_empty_tuple # returns True

Initialising a tuple with values

A tuple can be initialised with default values placed between the square brackets or by invoking the tuple() constructor.

even_numbers = (2, 4, 6, 8, 10)
odd_numbers = (1, 3, 5, 7, 9)
sequence_list = tuple(1, 2, 3, 4) # new list with default values being assigned

Accessing individual items from a tuple

Items can be accessed using the indexing/slicing notation. If you try to access an item which is not present in the tuple, an IndexError will be raised.

numbers = (1, 10, 100, 1000, 10000)
numbers[0] # first element in the tuple, returns 1
numbers[1] # second element in the tuple, returns 10
numbers[-1] # last element in the tuple, return 10000
numbers[100] # returns IndexError: tuple index out of range

Adding new items to a tuple

Tuples do not have any built-in members and therefore we can make use of the + operator to add an item to an existing tuple. Note the extra comma at the end of the tuple list.

a = ()
id(a) # returns a unique id
a = a + (2,)
a = a + (3,)
a # returns (2, 3)
id(a) # returns another unique id proving that tuples are immutable

Remove items from a tuple

As tuples are immutable, so once a tuple is created, there is no way to modify that tuple. One way to remove an item from a tuple is to convert the tuple to list, remove the item and then convert it back to a tuple:

a = (2, 3) # new tuple with 2 and 3 as values
b = list(a) # convert to list
b.remove(3) # remove 3 from the list
a = tuple(b) # a is now (3,)

Membership testing in tuples

The in operator is used to demonstrate membership testing in Python and it's quite central when using tuples to check for items being present in a specific tuple. Using the in operator will always return a boolean result.

Here's an example:

a = (1, 2, 3, 4)
5 in a # returns False
3 in a # returns True

Counting items in a tuple

We can use Python's in-built len() method to count the total number of items in a tuple.

a = (1, 2, 3, 4)
len(a) # returns 4

Finding the posiiton of an item

We can use dict.index() method to find the position of an item in a tuple. Note that only the first occurence's index will be shown:

a = (1, 2, 3, 4, 1)
a.index(1) # returns 0
a.index(3) # returns 2

Counting the exact occurences of an item in a tuple

One can make use of the tuple.count() method to count the number of occurences of an item in a tuple.

a = (1, 2, 3, 4, 5, 1)
a.count(1) # returns 2, there are 2 instances of the number 1 being present in the tuple.

Extending items in a tuple

The + operator method allows a tuple to extend or concatenate its result set to another tuple.

a = (1, 2, 3)
b = (3, 4, 5)
a + b # returns (1, 2, 3, 3, 4, 5)

Sorting items in a tuple

The sorted() method creates a new sorted tuple from an iterable and works for other types other than tuples. As sorted returns a list, we'll need to convert it back to a tuple. Let's see an example:

students = ("Mark", "Tom", "John", "Oz")
tuple(sorted(students)) # returns ('John', 'Mark', 'Oz', 'Tom')

We have a slight problem when we have to sort items which in turn have both lower and uppercase characters.

fruits = ('apples', 'Bananas', 'oranges', 'Pears', 'Apples')
tuple(sorted(fruits)) # returns ('Apples', 'Bananas', 'Pears', 'apples', 'oranges')

As we can see, the lowercase apples and oranges did not get properly sorted to our liking.

To solve this issue, we can make use of a key function.

fruits = ('apples', 'Bananas', 'oranges', 'Pears', 'Apples')
tuple(sorted(fruits, key=lambda v: v.upper())) # returns ['apples', 'Apples', 'Bananas', 'oranges', 'Pears']

Awesome, isn't it?? Using the lambda function defined in the key allowed us to specify in which order the values will be returned.

Now what if we wanted the uppercase values first? Hmm..let's see how we can solve this one:

fruits = ('apples', 'Bananas', 'oranges', 'Pears', 'Apples')
tuples(sorted(fruits, key=lambda v: (v.upper(), v[0].islower()))) # returns ('Apples', 'apples', 'Bananas', 'oranges', 'Pears')

We have not really talked much about lambdas so far but we'll get to this in a future tutorial.

Named Tuples

A named tuple is very much similar to a tuple. It is indexable, iterable and is a subclass of tuple.

A named tuple can prove to be really useful when we want to make our code more readable but at the same time, do not want to create a custom object.

Named tuples have to be imported from the collections module in Python.

Let's see an example:

from collections import namedtuple
Headlight = namedtuple('Headlight', ['left, right']) # create a namedtuple instance supporting 2 fields(left, right).
bmw_headlight = Headlight('Full', 'Half')
bmw_headlight[0] # returns Full
bmw_headlight[1] # returns Half
bmw_headlight.left # returns Full
bmw_headlight.right # returns Half

Do you use tuples or named tuples in Python or want to suggest an improvement to this article? Please share it with us by leaving a reply below.

Part 2 coming soon. Stay tuned!

About the Author

Alvin Luchmun
Alvin Luchmun is a freelance developer, trainer and co-founder at and currently lives in London. Alvin is passionate about anything tech/biz related but is also a firm believer in agile clean code, he loves preaching about code to fellow humanoids!.

Leave a comment