Index error tuple index out of range

The IndexError: tuple index out of range error occurs when you access an item that does not exist in the tuple. The python error IndexError: tuple index out of range occurs when an item in a tuple is accessed using invalid index. The access index should be within the tuple index range. The error will be thrown if the index is out of range in python. To solve this error, make sure the item you are searching for is accessed from a tuple

The tuple is an ordered collection of objects. The tuples are indexed starting at 0 up to the total number of elements length. You can reach the elements in the tuple using reverse indexing stating -1. If an element is accessed outside the permitted tuple index range, then the error IndexError: tuple index out of range is thrown.

Otherwise, at a specific index, you attempt to access an object but the object is not currently available in that index. In this case the index error tuple index out of range will be thrown by the python tuple.

Exception

The stack trace of the index error will appear as shown below. The stack trace will display the line this error is being thrown at.

Traceback (most recent call last):
  File "/Users/knatarajan2/Desktop/test.py", line 2, in <module>
    print a[5]
IndexError: tuple index out of range
[Finished in 0.0s with exit code 1]

How to reproduce this error

If an object is accessed beyond the permissible tuple range, the object can not be located at that location. Hence the error “IndexError: out-of-range tuple index” is thrown. The index ranges from 0 through to the total tuple items. In the example below, the index range is from 0 to 4 and reverse index is -5 to -1. The accessed index 5 is out of range of tuple.

test.py

a = ( 'A', 'B', 'C', 'D', 'E' )
print a[5]

Output

Traceback (most recent call last):
  File "/Users/python/Desktop/test.py", line 2, in <module>
    print a[5]
IndexError: tuple index out of range
[Finished in 0.0s with exit code 1]

Root Cause

The tuple is an ordered collection of objects. The objects are managed using the indexes. The index values starts from 0 up to the total value count. The reverse index starts with -1 unto the total number of items negative. If an object is accessed using an index outside the range of a tuple, the error will be thrown.

Forward index of the tuple

Python allows two forms of indexation, forward indexing and backward indexing. The index forwards begins at 0 and finishes with the number of items in the tuple. The forward index is used to iterate a tuple in the forward direction.

Backward index of the tuple

The reverse index starts from-1 and the index ends with the negative value of the number of elements in the tuple. The backward index is used in reverse direction to iterate the elements. The objects in the tuple is printed in the reverse sequence of the index. The reverse index shall be as shown below

Solution 1

The index value should be within the permissible range of the index value. Typically, the tuple contains index beginning at 0 to the length of the tuple. The negative index value beginning at -1 would point to the tuple’s last index

test.py

a = ( 'A', 'B', 'C', 'D', 'E' )
print a[3]

Output

D
[Finished in 0.1s]

Solution 2

If the tuple is created dynamically, then the tuple length is unknown. The tuple is iterated and the elements are retrieved based on the index. The index value is uncertain in this situation. If an index retrieves the element in the tuple the index value should be validated with the tuple length.

a = ( 'A', 'B', 'C', 'D', 'E' )
index = 3
if index < len(a) :
	print a[index]

Output

D
[Finished in 0.1s]

Solution 3

The python membership operator is used to iterate all elements with in the tuple. The membership operator gets all the elements in the tuple without using the element index. The loop helps to iterate all the elements in the tuple. The example below shows how to use a membership in a loop. The error IndexError: tuple index out of range will be resolved by the membership operators.

test.py

a = ( 'A', 'B', 'C', 'D', 'E' )
for item in a:
	print item

Output

A
B
C
D
E
[Finished in 0.0s]

Like lists, Python tuples are indexed. This means each value in a tuple has a number you can use to access that value. When you try to access an item in a tuple that does not exist, Python returns an error that says “tuple index out of range”.

In this guide, we explain what this common Python error means and why it is raised. We walk through an example scenario with this problem present so that we can figure out how to solve it.

Problem Analysis: IndexError: tuple index out of range

Tuples are indexed starting from 0. Every subsequent value in a tuple is assigned a number that is one greater than the last. Take a look at a tuple:

birds = ("Robin", "Collared Dove", "Great Tit", "Goldfinch", "Chaffinch")

This tuple contains five values. Each value has its own index number:

To access the value “Robin” in our tuple, we would use this code:

Our code returns: Robin. We access the value at the index position 1 and print it to the console. We could do this with any value in our list.

If we try to access an item that is outside our tuple, an error will be raised.

An Example Scenario

Let’s write a program that prints out the last three values in a tuple. Our tuple contains a list of United Kingdom cities. Let’s start by declaring a tuple:

cities = ("Edinburgh", "London", "Southend", "Bristol", "Cambridge")

Next, we print out the last three values. We will do this using a for loop and a range() statement. The range() statement creates a list of numbers between a particular range so that we can iterate over the items in our list whose index numbers are in that range.

Here is the code for our for loop:

for i in range(3, 6):
	print(birds[i])

Let’s try to run our code:

Goldfinch
Chaffinch
Traceback (most recent call last):
  File "main.py", line 4, in <module>
	print(birds[i])
IndexError: tuple index out of range

Our code prints out the values Goldfinch and Chaffinch. These are the last two values in our list. It does not print out a third value.

The Solution

Our range() statement creates a list of numbers between the range of 3 and 6. This list is inclusive of 3 and exclusive of 6. Our list is only indexed up to 4. This means that our loop will try to access a bird at the index position 5 in our tuple because 5 is in our range.

Let’s see what happens if we try to print out birds[5] individually:

Our code returns:

Traceback (most recent call last):
  File "main.py", line 3, in <module>
	print(birds[5])
IndexError: tuple index out of range

The same error is present. This is because we try to access items in our list as if they are indexed from 1. Tuples are indexed from 0.

To solve this error, we need to revise our range() statement so it only prints the last three items in our tuple. Our range should go from 2 to 5:

for i in range(2, 5):
	print(birds[i])

Let’s run our revised code and see what happens:

Great Tit
Goldfinch
Chaffinch

Our code successfully prints out the last three items in our list. We’re now accessing items at the index positions 2, 3, and 4. All of these positions are valid so our code now works.

Conclusion

The IndexError: tuple index out of range error occurs when you try to access an item in a tuple that does not exist. To solve this problem, make sure that whenever you access an item from a tuple that the item for which you are looking exists.

The most common cause of this error is forgetting that tuples are indexed from 0. Start counting from 0 when you are trying to access a value from a tuple. As a beginner, this can feel odd. As you spend more time coding in Python, counting from 0 will become second-nature.

Now you’re ready to solve this Python error like an expert!

IndexError: tuple index out of range

Tuples in Python are a series of objects that are immutable. They are like lists. The elements of a tuple are accessed the same way a list element is accessed – by mentioning indices. But when using tuples you might have encountered «IndexError: tuple index out of range«. This happens when you are trying to access an element that is out of bounds of the tuple.

The way to solve this error is by mentioning the correct index. Let us look a little more closely at this error and its solution.

Examples of IndexError: tuple index out of range

Take a look at this piece of code below:

# Declare tuple
tup = ('Apple', "Banana", "Orange")

# Print tuple value at index 10
print(tup[10])

Output:

File "pyprogram.py", line 5, in <module>
print(tup[10])
IndexError: tuple index out of range

As tuple has only 3 index and we are trying to print the value at index 10

Solution:

# Declare tuple
tup = ('Apple', "Banana", "Orange")

print(tup[0])
print(tup[1])
print(tup[2])

In the code above, there is a tuple called tup having three elements. So the index value starts from 0 and ends at 2. A print() method is called on the tuple to print out all of its elements.

The solution code executes successfully as the indices mentioned in the print() are 0,1 and 2. These indices are all within the range of the tuple, so the IndexError: tuple index out of range error is avoided.

Example with While Loop

# Declare tuple
tup = ('Apple', "Banana", "Orange")

print('Print length of Tuple: ',len(tup))

i=0

# While loop less then and equal to tuple "tup" length.
while i <= len(tup):
    print(tup[i])
    i += 1

Output:

  File "pyprogram.py", line 10
        print(tup[i])
            ^
SyntaxError: invalid character in identifier

len() function count length of tuple as «3» so while loop runs for 4 time starting from 0 because value of i is 0, due to which when our while loop print the value of tup[«3»] it goes out of range because out tuple «tup» has only 3 elements.

Correct Code:

# Declare tuple 
tup = ('Apple', "Banana", "Orange")
i=0

print('Print length of Tuple: ',len(tup))

# While loop less than tuple "tup" length.
while i < len(tup):
    print(tup[i])
    i += 1

Output

Print length of Tuple:  3
Apple
Banana
Orange

The tuple called «tup» has 3 elements. So, the index starts from 0 and ends at 2. In the solution code, there is a variable i having a value of 0. This variable is used as an incrementor in the while loop. The loop checks whether i is less than length of the tuple. Then, it prints out the element in the ith index.

So, the loop runs 3 times starting from 0 and going up to 2, while i is incremented at every iteration. It stops iterating when i=4 and it is greater than the length of the tuple. Thus, the IndexError: tuple index out of range is avoided, as the code does not try to access the 4th element that is out of range.  

Programming always comes at the cost of errors. Some of them are diabolic and are pretty tricky to deal with, even if you know the position of the error. There are many types of mistakes in a program- one of the most popular errors is the Python IndexError. IndexError refers to incorrect indexing of a variable. If you encounter an IndexError, you have probably given an index to that tuple that does not exist. To rectify it, check the index of the variable, or check the loop range if you are using a loop.

What is a Tuple?

A tuple is a collection of data in a single variable. A tuple can store multiple values within it. The values are separated by commas and are included in the first brackets.

An example of a tuple is as follows:

tup = (‘a’, ‘b’, 12, 16.45, ‘ab’)

As we can see, a tuple may contain anything, from a character and string to a number and float value.

Tuple vs. List

A list is similar to a tuple, but there is one fundamental difference. Here is an example of a list:

lst = [‘a’, ‘b’, 12, 16.45, ‘ab’]

A list also contains multiple values inside it and is bound by third brackets. The primary difference between a list and a tuple is that a list is mutable, but a tuple is not. It means that a list can be modified, but a value in a tuple cannot be modified once it has been created.

Indexing works similarly in lists and tuples. So, if you get the list index out of range, this solution will work for that too.

Indexing

Indexing is the method of calling one of the data in the list or tuple. For example, imagine you are in a queue, and everyone has a numbered token. The token number is the identity of yourself in the queue.

Similarly, data in a list or tuple are numbered based on their positions. The numbering starts from 0. So, the first element in the list has the number 0, the second element has the number 1, etc. Thus, when you want to use an element from a list, you can call it using its positional number, i.e., the index value.

How to Use Index Values

Let’s take an example. We will use the previously mentioned tuple.

tup = (‘a’, ‘b’, 12, 16.45, ‘ab’)

In this tuple, there are five elements in total. Suppose we need to do some work with the fourth element, i.e., the float value 16.45.

In that case, we call this element using its index number. Here is how we can do it.

var = tup[3]

The index number of the fourth element is 3 since indexing starts from 0. So once we write the above line, the variable var gets the value 16.45. tup[3] means to get the fourth value of the tuple ‘tup.’

A similar thing can be done using lists.

Error: Index Out of Range

Index out of range is one of the most challenging errors to solve, and it becomes even more difficult if there are multiple loops in a program.

Let’s understand why this error occurs. We use the same tuple to explain. Suppose we write:

tup = (‘a’, ‘b’, 12, 16.45, ‘ab’)

var = tup[5]

This will fetch an index out of range error. The reason is simple. There are five elements in the tuple. The index of the last element is 4. But var demands the element with index 5. Since no such element is present in the tuple, Python shows this error.

It’s easy enough to fix the problem here. But when things get complicated, the problem arises.

Index Out of Range Error in Loops

tup = (‘a’, ‘b’, 12, 16.45, ‘ab’)

for i in range(10):

print tup[i]

This will also give index out-of-range error. In this case, we use a for loop, and the index is changing every time the for loop is encountered.

The for loop has a range of 0 to 10. So i range from 0 to 10. For the first four times, the loop works perfectly, printing the results, but then, it fails because the situation becomes this: print tup[5], print tup[6], and so on.

The problem is that the error only tells you the line where the problem occurs. It does not tell you why. Therefore, it is up to the programmer to find and debug this error by looking at the range of all the loops used in the program.

How to Avoid Python Error: Index Out of Range

While it seems difficult to find and solve the index out-of-range error, we can avoid this error while writing a program. Here are some ways you can prevent it.

Suppose you need to print all the values in a tuple, but you don’t know the size of the tuple. In this case, if you write:

for i in range(10):

print tup[i]

The program will throw an error (assuming that you have assumed that the tuple size is 10). Hence, assuming a size and using it in the loop is useless.

In this case, we can write:

for i in range(len(tup)):

print tup[i]

Here, len(tup) gives the size of the tuple, i.e., the number of elements present in it. The len(tup) will return 5.

If we use lengths of tuples as a range for loops, there should not be any index out-of-range error. But there are times when we use multiple indexing methods from multiple tuples or lists within a single loop. In that case, it is better to be careful about this error while using indexing. Also, you must not be scared of this error. It can be fixed by the simple method of checking the range of loops so that the index value does not go out of bounds.

Negative Indexing

Giving a negative value in an index is allowed. A negative index value starts counting from the reverse. Unlike positive indexing, which starts from 0, negative indexing starts from 1. Thus, the last value has index -1, while the first value has index –(len(tup)).

To make things simpler, here is a table showing the index values.

From the table, you can understand how indexing works.

Using the tup example,

Hence, negative indexing has a different value from positive indexing. You need to keep this in mind while using negative indexing in loops.

Other Types of Errors

As a bonus, we will discuss some other types of errors programmers encounter often. While Python is easy and fun to work with, some errors need more time to fix than you can expect.

1. Invalid Syntax: This is the most common error in python. It happens when you write a syntax wrong. E.g. if you write for i in range (2) instead of for i in range(2), it will produce an error. This happens because the syntax (style of writing) is not perfect.
2. Variable is not defined: This happens when you use a variable not previously defined. This mostly occurs due to typo and can be easily fixed by correcting the name of the variable. E.g. if we define tup and then write var = put[5], the program encounters error put is not defined
3. Object not callable/subscriptable: This occurs when you do something with a type of object that you are not supposed to. E.g. if we write

integer = 2323

var = integer[3]

This will produce what we call a TypeError. It will show int object is not subscriptable. Sure enough, you cannot treat an integer as a string and break it into parts to extract a single digit.

These are some of the popular troublesome errors Python users face daily. However, it is important to note that having errors does not mean you are bad at programming. In fact, solving programming errors is fun, entertaining, and rewarding!

Conclusion

Programming may be fun, but sometimes errors spring up that can make a coder’s day a nightmare. One such example is the Python IndexError: tuple index out of range. This can also be encountered while using lists. The logic behind this error is pretty simple.

Solving the errors requires you to understand the indexing techniques and range used in loops if any. In case of any errors, a program stops its execution there, so there may be more such errors lying after that line. Lastly, having an idea about positive and negative indexing can be helpful when it comes to solving this error. Big programs have lots of variables using indexing techniques. Hence, a programmer must be careful in using indexes to avoid this error.

Frequently Asked Questions

• How to deal with different errors in Python?
  Each error has different a solution. NameError needs you to check the names of the variables. TypeError needs you to check the usage of an element. SyntaxError needs you to correct the wrong syntax in that particular line.
• Can Index Error cause other errors in the program?
  Each error is dependable on other errors. In general, if you write one wrong line, Python cannot understand the subsequent lines of code. Hence, Python gives errors on those lines too. It is important for you to understand the root of the error and fix it accordingly.
• I have a lot of errors in a program? How long will it take me to fix it?
  Errors are best not measured using count. This is because one error may produce numerous new errors. Yet, those lines are perfect. E.g., An extra quote may cause Python to think that the remaining program is an endless script. This makes Python prompt more errors than there actually are. Hence, try to fix the genuine errors, and the others will be gone.
• How to start debugging a buggy program?
  The errors in the program are displayed as the most recent call last. This is the specialty of python traceback, where the console should be read from bottom to top. This is how you should look at the debug console and fix the errors. Hence, the bottom error should be taken care of first.
• Which one is more advantageous, a tuple or a list?
  It depends whether a tuple or a list will be more appropriate. A tuple and a list are two similar variables that store elements in them. Both can be used similarly, except that a value in a tuple cannot be modified. Whenever python wants to produce a list of elements, it uses a tuple. You can easily convert a tuple into a list with some lines of code. A list is the best choice when you are working on it, but a tuple is preferred when you are using it as the output.
• Does negative indexing give index out-of-range error?
  Negative indexing is used to view the list in reverse, and should not encounter any error. However, there are some compilers where the use of the negative index is not permitted. In such cases, you may encounter errors. If you want to access the last element of a tuple without the use of a negative index, you can write var = tup[len(tup)-1] . This will fetch the last element of the tuple. Decreasing 1 from the length is important because positive indexing starts from 0, but len(tup) will return the number of elements in the tuple.
• What is the difference between (1,2) and (‘1’, ‘2’)?
  (1,2) is a tuple that contains two integers, 1 and 2. (‘1’, ‘2’) is a tuple that contains two strings, ‘1’ and ‘2’. The strings cannot be used as integers and will have to be converted. Similarly, integers cannot be used as strings and will have to be converted.
  • To convert a string to an integer, we use int(), e.g. int(‘2’)
  • To convert an integer to a string, we use str(), e.g. str(2)