Index error string index out of range

The python error IndexError: string index out of range occurs if a character is not available at the string index. The string index value is out of range of the String length. The python error IndexError: string index out of range occurs when a character is retrieved from the out side index of the string range.

The IndexError: string index out of range error occurs when attempting to access a character using the index outside the string index range. To identify a character in the string, the string index is used. This error happens when access is outside of the string’s index range.

If the character is retrieved by an index that is outside the range of the string index value, the python interpreter can not locate the location of the memory. The string index starts from 0 to the total number of characters in the string. If the index is out of range, It throws the error IndexError: string index out of range.

A string is a sequence of characters. The characters are retrieved by the index. The index is a location identifier for the ordered memory location where character is stored. A string index starts from 0 to the total number of characters in the string.

Exception

The IndexError: string index out of range error will appear as in the stack trace below. Stack trace shows the line the error has occurred at.

Traceback (most recent call last):
  File "/Users/python/Desktop/test.py", line 2, in <module>
    print ("the value is ", x[6])
IndexError: string index out of range
[Finished in 0.1s with exit code 1]

Root cause

The character in the string is retrieved via the character index. If the index is outside the range of the string index the python interpreter can’t find the character from the location of the memory. Thus it throws an error on the index. The string index starts from 0 and ends with the character number in the string.

Forward index of the string

Python allows two forms of indexing, forward indexing and backward indexing. The forward index begins at 0 and terminates with the number of characters in the string. The forward index is used to iterate a character in the forward direction. The character in the string will be written in the same index order.

Backward index of the string

Python allows backward indexing. The reverse index starts from-1 and ends with the negative value of the number of characters in the string. The backward index is used to iterate the characters in the opposite direction. In the reverse sequence of the index, the character in the string is printed. The back index is as shown below

Solution 1

The index value should be within the range of String. If the index value is out side the string index range, the index error will be thrown. Make sure that the index range is with in the index range of the string. 

The string index range starts with 0 and ends with the number of characters in the string. The reverse string index starts with -1 and ends with negative value of number of characters in the string.

In the example below, the string contains 5 characters “hello”. The index value starts at 0 and ends at 4. The reverse index starts at -1 and ends at -5.

Program

x = "hello"
print "the value is ", x[5]

Output

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

Solution

x = "hello"
print "the value is ", x[4]

Output

the value is  o
[Finished in 0.1s]

Solution 2

If the string is created dynamically, the string length is unknown. The string is iterated and the characters are retrieved based on the index. In this case , the value of the index is unpredictable. If an index is used to retrieve the character in the string, the index value should be validated with the length of the string.

The len() function in the string returns the total length of the string. The value of the index should be less than the total length of the string. The error IndexError: string index out of range will be thrown if the index value exceeds the number of characters in the string

Program

x = "hello"
index = 5
print "the value is ", x[index]

Output

Traceback (most recent call last):
  File "/Users/python/Desktop/test.py", line 3, in <module>
    print "the value is ", x[index]
IndexError: string index out of range
[Finished in 0.1s with exit code 1]

Solution

x = "hello"
index = 4
if index < len(x) :
	print "the value is ", x[index]

Output

the value is  o
[Finished in 0.1s]

Solution 3

Alternatively, the IndexError: string index out of range error is handled using exception handling. The try block is used to handle if there is an index out of range error.

x = "hello"
print "the value is ", x[5]

Exception

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

Solution

try:
	x = "hello"
	print "the value is ", x[5]
except:
	print "not available"

Output

the value is  not available
[Finished in 0.1s]

Surprise, surprise! We’re back with another article on a Python exception. Of course, this time we’re moving away from the SyntaxError and into a more specialized error, the IndexError, which is accompanied by various error messages. The error message we’ll be talking about today reads: `IndexError: string index out of range`raw.

In case you’re short on time, this IndexError arises when a string is accessed using an invalid index. For example, the string “VirtualFlat” has 11 characters. If a user were to try to access a character beyond this limit—say `”VirtualFlat”[15]`python—an IndexError would arise.

In the remainder of this article, we’ll look at this IndexError more deeply. For instance, we’ll take a look at the IndexError broadly. Then, we’ll hone in on the specific message. After that, we’ll wrap things up with some potential solutions and offer up an opportunity to share your code if you’re still having trouble.

Table of Contents

What Is an IndexError?

According to Python documentation, an IndexError is raised whenever “a sequence subscript is out of range.” Of course, what does that really mean?

To break down this definition, we need to understand a few terms. First, a sequence is a list-like object where items are stored in order; think lists, strings, and tuples. In this context, a subscript is then another name for an item’s index.

In Python, for an index to be out of range, it must not exist. For example, if we had a string like “VirtualFlat”, a valid index would be any value less than the length of the string and greater than or equal to the negative length of the string:

# Declare some index
brand = "VirtualFlat"
is_valid_index = -len(brand) <= index < len(brand)

As we can see, the range of indices is actually asymmetric. This is because negative indexing starts from negative one—as opposed to zero during regular indexing.

On a side note, I probably should have represented the range mathematically, but I struggled to come up with a syntax where the length operator wasn’t the exact same operator as absolute value (i.e. `|x|`). Also, the lack of symmetry made the expression clunky either way. I would have preferred something like `|index| < |brand|`, but it ends up being `-|brand| <= index < |brand|`. Perhaps interval notation would be a bit cleaner: `[-|brand|, |brand|)`.

At any rate, all this means is that there are valid and invalid indices. For instance, the following code snippets will result in an IndexError:

brand = "VirtualFlat"
brand[17]  # out of range
brand[-12]  # out of range

Of course, this same idea applies to any sequence type. For example, we could see this same error turn up for any of the following sequences:

nums = [1, 4, 5]
nums[7]  # IndexError: list index out of range

nums = (1, 4, 5)
nums[7]  # IndexError: tuple index out of range

nums = range(5)
nums[7]  # IndexError: range object index out of range

In the next section, we’ll take a look at this error in the context of its error message.

What Does This IndexError Message Mean?

Up to this point, we’ve talked about the IndexError broadly, but the error message we’re dealing with gives us a bit more information: `IndexError: string index out of range`raw.

Here, we can see that we’re not dealing with a list or tuple. Instead, we’re working with a string. As a result, our original example still holds:

brand = "VirtualFlat"
brand[17]  # out of range
brand[-12]  # out of range

That said, there are other ways we could get this error message to arise. For example, the Formatter class of string can throw the same error when using the `get_value()`python method.

In fact, there are probably thousands of libraries that could throw this error, so it’s tough for me to assume your situation. As a result, in the next section, we’ll take a look at the simple case and try to come up with some general problem solving strategies.

How to Fix This IndexError?

Now that we know we have some sort of indexing issue with our string, it’s just a matter of finding the root cause.

Like the original scenario we explores, it’s possible that we have some hardcoded value that is breaching the range of our string:

brand = "VirtualFlat"
brand[17]  # out of range

In this case, we’ll probably want to generate a constant from this index and give it a good name. After all, maintaining a magic number is usually a bad idea:

brand = "VirtualFlat"
LAST_CHAR = 10
brand[LAST_CHAR]

Having solved our magic number issue, I’d argue that there’s an even better solution: we should compute the last character programatically. Of course, if we’re not careful, we could find ourselves with yet another IndexError:

brand = "VirtualFlat"
brand[len(brand)]  # out of range, again

To get the last character, we’ll need to subtract one from the length:

brand = "VirtualFlat"
brand[len(brand) - 1]

That said, if you’ve read my guide to getting the last item of a list, you know there’s an even cleaner solution. Of course, we’re not here to get the last character of a string; we’re trying to anticipate different ways in which this error could arise.

For instance, we might be doing something a bit more complicated like looping over a string:

brand = "VirtualFlat"
i = 0
while i <= len(brand):
  if i % 2 == 0:
    print(brand[i])  # sometimes out of range

Here, we’ll notice that the loop condition always takes the index one step too far. As a result, we’ll need to correct it:

brand = "VirtualFlat"
i = 0
while i < len(brand):
  if i % 2 == 0:
    print(brand[i])  # sometimes out of range

Or even better, we can take advantage of the for loop:

brand = "VirtualFlat"
for i, c in enumerate(brand):
  if i % 2 == 0:
    print(c)  # sometimes out of range

Of course, this doesn’t even begin to scratch the realm of possibility for this error. As a result, in the next section, we’ll take a look at getting you some extra help—if you need it!

Need Help Fixing This IndexError?

As someone who has been relieved of their teaching duties for a little while, I figured I’d start sharing my time with the folks of the internet. In other words, if you find this article helpful but didn’t quite give you what you needed, consider sharing your code snippet with me on Twitter.

To do that, you’re welcome to use the #RenegadePython hashtag. Typically, I use that for Python challenges, but I figured I’d open it up for general Python Q&A. Here’s a sample tweet to get you started:

At any rate, that’s all I’ve got for today. If you liked this article, I’d appreciate it if you made your way over to my list of ways to grow the site. There, you’ll find links to my newsletter, YouTube channel, and Patreon.

Likewise, here are a few related articles for your perusal:

• Rock Paper Scissors Using Modular Arithmetic
• How to Get the Last Item of a List in Python

Finally, here are a few additional Python resources on Amazon (ad):

Otherwise, thanks for stopping by and enjoy the rest of your day!

Python Errors (3 Articles)—Series Navigation

As someone trying to build up their collection of Python content, I figured why not create another series? This time, I thought it would be fun to explain common Python errors.

Like lists, Python strings are indexed. This means each value in a string has its own index number which you can use to access that value. If you try to access an index value that does not exist in a string, you’ll encounter a “TypeError: string index out of range” error.

In this guide, we discuss what this error means and why it is raised. We walk through an example of this error in action to help you figure out how to solve it.

TypeError: string index out of range

In Python, strings are indexed starting from 0. Take a look at the string “Pineapple”:

“Pineapple” contains nine letters. Because strings are indexed from 0, the last letter in our string has the index number 8. The first letter in our string has the index number 0.

If we try to access an item at position 9 in our list, we’ll encounter an error. This is because there is no letter at index position 9 for Python to read.

The “TypeError: string index out of range” error is common if you forget to take into account that strings are indexed from 0. It’s also common in for loops that use a range() statement.

Example Scenario: Strings Are Indexed From 0

Take a look at a program that prints out all of the letters in a string on a new line:

def print_string(sentence):
	count = 0

	while count <= len(sentence):
		print(sentence[count])
		count += 1

Our code uses a while loop to loop through every letter in the variable “sentence”. Each time a loop executes, our variable “count” is increased by 1. This lets us move on to the next letter when our loop continues.

Let’s call our function with an example sentence:

Our code returns:

S
t
r
i
n
g
Traceback (most recent call last):
  File "main.py", line 8, in <module>
	print_string("test")
  File "main.py", line 5, in print_string
	print(sentence[count])
IndexError: string index out of range

Our code prints out each character in our string. After every character is printed, an error is raised. This is because our while loop continues until “count” is no longer less than or equal to the length of “sentence”.

To solve this error, we must ensure our while loop only runs when “count” is less than the length of our string. This is because strings are indexed from 0 and the len() method returns the full length of a string. So, the length of “string” is 6. However, there is no character at index position 6 in our string.

Let’s revise our while loop:

while count < len(sentence):

This loop will only run while the value of “count” is less than the length of “sentence”.

Run our code and see what happens:

Our code runs successfully!

Example Scenario: Hamming Distance Program

Here, we write a program that calculates the Hamming Distance between two sequences. This tells us how many differences there are between two strings.

Start by defining a function that calculates the Hamming distance:

def hamming(a, b):
	differences = 0

	for c in range(0, len(a)):
		if a[c] != b[c]:
			differences += 1

	return differences

Our function accepts two arguments: a and b. These arguments contain the string values that we want to compare.

In our function, we use a for loop to go through each position in our strings to see if the characters at that position are the same. If they are not the same, the “differences” counter is increased by one.

Call our function and try it out with two strings:

answer = hamming("Tess1", "Test")
print(answer)

Run our code and see what happens:

Traceback (most recent call last):
  File "main.py", line 10, in <module>
	answer = hamming("Tess1", "Test")
  File "main.py", line 5, in hamming
	if a[c] != b[c]:
IndexError: string index out of range

Our code returns an error. This is because “a” and “b” are not the same length. “a” has one more character than “b”. This causes our loop to try to find another character in “b” that does not exist even after we’ve searched through all the characters in “b”.

We can solve this error by first checking if our strings are valid:

def hamming(a, b):
	differences = 0

	if len(a) != len(b):
		print("Strings must be the same length.")
		return 

	for c in range(0, len(a)):
		if a[c] != b[c]:
			differences += 1

	return differences

We’ve used an “if” statement to check if our strings are the same length. If they are, our program will run. If they are not, our program will print a message to the console and our function will return a null value to our main program. Run our code again:

Strings must be the same length.
None

Our code no longer returns an error. Try our algorithm on strings that have the same length:

answer = hamming("Test", "Tess")
print(answer)

Our code returns: 1. Our code has successfully calculated the Hamming Distance between the strings “Test” and “Tess”.

Conclusion

The “TypeError: string index out of range” error is raised when you try to access an item at an index position that does not exist. You solve this error by making sure that your code treats strings as if they are indexed from the position 0.

Now you’re ready to solve this common Python error like a professional coder!

Published December 30, 2020

Introduction

Strings are still an integral portion of any programming language. A string can be an array of characters. Even the string index out of range usually means the index you’re looking for doesn’t exist. At some string, which usually means you are attempting to receive yourself a character out of the string at a particular level. If that specified position doesn’t exist, subsequently, you definitely might be hoping to find yourself a personality that isn’t interior to the string.

Read how to remove Last character from String in Python

For example:

Output

Now try the following code—

Output: 8

What happens if we index 20? Let’s check

numbers = «12404608»
print(numbers[20])

We received an error string index out of range, as we’re seeking something which will not exist. Back in Python, a string can be actually just a single-dimensional array of characters. Indexes in Python programming begin from 0. It means that the index for any string will up to length-1. This creates your amounts [8] fall short as the requested index is larger compared to the length of this string.

Summary

In python string indexing starts from 0 that means the index for any string will be upto length -1. 

Even the string index out of range error must complete having a common beginner issue when obtaining parts of the string with its index. You’ll find a number of techniques to account for because of it in particular. Recognizing that the length of one’s string can undoubtedly give you the capacity to keep going through your index

Output:

You will notice that when you are running len() function, you are getting the length of the string as 8 and the length is not starting from 0. As python programming uses 0-level indexing, the maximum index of any string is equal to the length of the string — 1. So you can easily get the max index of any string by subtracting 1 by the length of the string.

Hence the index error: string index out of range is resolved