Skip to main content

How to Solve "IndexError: tuple index out of range" in Python

The IndexError: tuple index out of range error occurs in Python when you try to access a tuple element using an index that is outside the valid range of indices for that tuple.

This guide explains why this error happens, how to avoid it using proper indexing, and how to handle it gracefully using try-except blocks.

Understanding Tuple Indexing​

Tuples, like lists, are ordered sequences in Python. Each element in a tuple has a corresponding index, which is an integer value.

However, unlike lists, tuples are immutable (you can not change their contents after creation).

Positive Indexing​

Python uses zero-based indexing. The first element has an index of 0, the second has an index of 1, and so on.

my_tuple = ('a', 'b', 'c')
print(my_tuple[0])      # Output: a
print(my_tuple[1])      # Output: b
print(my_tuple[2])      # Output: c
# print(my_tuple[3])    # ⛔️ IndexError: tuple index out of range

Negative Indexing​

Negative indices count backward from the end of the tuple:

my_tuple = ('a', 'b', 'c')
print(my_tuple[-1])     # Output: c (last element)
print(my_tuple[-2])     # Output: b (second-to-last element)
print(my_tuple[-3])     # Output: a (third-to-last element)
# print(my_tuple[-4])   # ⛔️ IndexError: tuple index out of range

Empty Tuples​

An empty tuple has a length of 0. Any attempt to access an element of an empty tuple by index will result in an IndexError.

my_tuple = ()
print(len(my_tuple))    # Output: 0
# print(my_tuple[0])    # ⛔️ IndexError: tuple index out of range

Causes of IndexError​

Accessing a Non-Existent Index​

The primary cause is trying to access an index that is outside the valid range:

my_tuple = ('a', 'b', 'c')

# ⛔️ IndexError: tuple index out of range
# print(my_tuple[3])   # sIndex 3 is out of range (valid indices: 0, 1, 2)
# print(my_tuple[-4])  # Index -4 is out of range

Accessing an Empty Tuple​

my_tuple = ()

# ⛔️ IndexError: tuple index out of range
# print(my_tuple[0])  # Accessing any index on an empty tuple is an error.

Preventing IndexError​

Checking Tuple Length Before Accessing​

Before accessing an element by index, check if the index is within the valid range using len():

my_tuple = ('a', 'b', 'c')
index = 3  #  Potentially out-of-range index

if index < len(my_tuple) and index >= -len(my_tuple): #Handles negative indexes
    print(my_tuple[index])
else:
    print(f'index {index} is out of range') # Output: index 3 is out of range
  • len(my_tuple): Returns the number of elements in the tuple.
  • index < len(my_tuple): Checks if the index is a valid positive index.
  • index >= -len(my_tuple): Checks if the index is a valid negative index.

Using try-except Blocks​

Use a try-except block to gracefully handle potential IndexError exceptions:

my_tuple = ('a', 'b', 'c')

try:
    result = my_tuple[100]  # This will raise an IndexError
except IndexError:
    print('Index out of range') # Output: Index out of range
  • The try block contains the code that might raise an IndexError.
  • The except IndexError: block is executed only if an IndexError occurs within the try block. This prevents the program from crashing.
  • You can also use pass to ignore the error.

Tuple Slicing vs. Indexing​

Indexing with square brackets ([]) returns a single element. Slicing ([:]) returns a new tuple (or list, or string, depending on the object being sliced) containing a portion of the original sequence. Importantly, slicing never raises an IndexError, even if the slice indices are out of bounds.

my_tuple = ('a', 'b', 'c', 'd')

print(my_tuple[0:2])    # Output: ('a', 'b')    (Valid slice)
print(my_tuple[2:100])  # Output: ('c', 'd')    (No error, returns available elements)
print(my_tuple[100:])   # Output: ()            (Empty tuple, no error)
# print(my_tuple[100])  # ⛔️ IndexError         (Indexing with a single out-of-bounds index)
  • Slicing is often a safer way to get a portion of a tuple (or list) because it handles out-of-bounds indices gracefully.

Conclusion​

The IndexError: tuple index out of range error occurs when you attempt to access a tuple element using an invalid index.

This guide covered how to understand tuple indexing, the causes of the error, and several ways to solve it.

  • The best practice is to always check if the length of the list is valid for the index you are trying to get, before accessing the tuple at an index.
  • You also learned how to use a try-except block to handle the exception.
  • Finally, we discussed the crucial difference between indexing and slicing, and how slicing can help avoid IndexError.

Table of Contents