IndexError: List Index Out of Range in Python, Explained and Fixed

Your loop works for the first few items and then Python stops with IndexError: list index out of range. Somewhere, your code asked a list for a position that does not exist. This error is so common that learning to fix it quickly is practically a rite of passage. In this guide you will learn how Python indexing really works, the off-by-one mistake behind most cases, and a set of safe patterns that keep your code inside the list’s boundaries.

Quick Answer

An IndexError means you used an index equal to or larger than the list’s length, or below its negative range. A list with 5 items has indexes 0 to 4, never 5. Fix it by checking len(my_list) before indexing, looping with range(len(my_list)) or directly over the items, and guarding user-chosen positions with an if test before you use them.

How Python Indexing Works

Python counts positions starting from zero. For the list ["a", "b", "c"], index 0 is "a", index 1 is "b", and index 2 is "c". There is no index 3, even though the length is 3. This gap between “how many items” and “the last valid index” is the single biggest source of the error. The last valid index is always len(list) - 1.

Python also allows negative indexes that count from the end: -1 is the last item, -2 the second last, down to -len(list) for the first item. Go one step further, to -4 on a three-item list, and you get the same IndexError from the other direction. Strings and tuples follow identical rules, so everything in this guide applies to text[10] on a short string too.

The Classic Off-By-One Loop Mistake

This broken pattern appears in beginner code everywhere:

names = ["Ali", "Sara", "John"]
for i in range(len(names) + 1):
    print(names[i])

The + 1 adds one extra lap, where i becomes 3 and the list has no index 3. Remove the + 1 and the loop is correct. Even better, skip indexes entirely when you only need the values:

for name in names:
    print(name)

And when you need both the position and the value, use enumerate:

for i, name in enumerate(names):
    print(i, name)

These patterns make the IndexError impossible in that loop, because Python itself supplies indexes that are guaranteed valid. The official tutorial on data structures shows these iteration styles with more examples.

How to Fix Your Specific Case Step by Step

1. Note the line and the index involved. Add a temporary print just above the failing line: print(len(my_list), "items; trying index", i) so you can see the exact numbers Python was working with.
2. Print the whole list. Sometimes the list is simply shorter than you assumed, or even empty, because an earlier filter, file read, or split produced fewer items than expected. An empty list has no valid index at all, not even 0.
3. Check where the index came from. If a user typed it, remember that humans count from 1 while Python counts from 0, so subtract 1 from human-style input or validate it. If a calculation produced it, test the calculation with the printed length.
4. Add a guard when the index is external. Use if 0 <= i < len(my_list): around the access and decide what should happen instead, such as printing a friendly message.
5. Remove the debug prints and re-run. Test the smallest and largest inputs your program should accept, including an empty list.

Special Case: Split Results and File Lines

A sneaky variant appears when you split text: parts = line.split(",") followed by parts[3]. Most lines have four fields, but one malformed line has only two, and the program explodes halfway through a file. Before indexing split results, check len(parts), or use a loop over whatever fields exist. Real-world data is never as tidy as the sample data, so defensive checks where data enters your program pay for themselves quickly. If your indexes come from another part of the program entirely, consider whether a name or scope mix-up like a NameError is feeding you an unexpected value.

Common Mistakes to Avoid

• Using len(list) as an index. The length is the count, not the last position. The last position is always one less.
• Hard-coding indexes for data you do not control. Files, APIs, and user input change. Compute positions from the actual data instead.
• Wrapping everything in try/except IndexError. Silently swallowing the error hides real bugs and can leave your data half-processed. Guard the specific risky access instead.
• Forgetting that remove() and pop() shrink the list. Removing items while looping by index skips elements and can push the final index out of range. Loop over a copy or collect items to remove first.

IndexError in Nested Lists and Grid Data

Beginners meet a trickier version when data becomes two-dimensional, such as a grid stored as a list of lists:

grid = [[1, 2, 3], [4, 5], [6, 7, 8]]
print(grid[1][2])

The outer index 1 is valid, but the middle row has only two items, so index 2 within it raises IndexError. Rows in real data — CSV records, game boards, image pixels — are not guaranteed equal lengths, and code that assumes a neat rectangle eventually meets a ragged row. Defensive habits for grid data mirror the one-dimensional ones: check len(grid[row]) before reaching inside it, and when processing every cell, loop over rows and then over each row’s own items rather than over fixed column numbers. If your data truly must be rectangular, validate it once when it is loaded and report bad rows early, with a message naming the row, instead of letting a bare IndexError surface deep inside unrelated logic. That one validation step turns a whole family of mysterious crashes into a single clear complaint at the exact place the data entered your program.

Conclusion

IndexError: list index out of range means your code asked for a position beyond the list’s edges. Remember that indexes run from 0 to len(list) - 1, print the length and the list when debugging, prefer looping directly over items or with enumerate, and guard any index that comes from outside your code. With those habits, this error becomes a thirty-second fix.

Frequently Asked Questions

Why does index 0 fail on my list?

Because the list is empty at that moment. An empty list has a length of 0 and no valid indexes at all. Check why the list is empty: perhaps a file had no lines, a filter removed everything, or you created the list but never filled it before using it.

What is the safest way to get the last item of a list?

Use my_list[-1], which always means the final item regardless of length. It still raises IndexError on an empty list, so test if my_list: first when the list might be empty.

Can slicing cause an IndexError too?

No. Slices are forgiving: my_list[0:100] on a five-item list simply returns all five items. Only single-index access raises IndexError. This difference makes slicing a handy way to grab “up to N items” without length checks.

Why does my loop fail only on the last item?

That is the signature of an off-by-one error. Your loop runs one lap too many, usually because of range(len(list) + 1) or a while i <= len(list) condition. Change the condition so the largest index used is len(list) - 1.

Why does the error appear only on some runs of my program?

Because the data differs between runs. One file has ten lines and the next has eight; one user picks item three and another picks item thirty. Code with a latent indexing bug passes every test until the first input that is shorter than an assumed index arrives. That is why testing with empty, tiny, and unusually large inputs matters: it forces exactly the boundary conditions this error feeds on, in your test environment rather than in front of a user.

Does this error happen with dictionaries?

Dictionaries raise a KeyError instead when a key is missing, but the spirit is the same: you asked for something that is not there. Use .get(key, default) for dictionaries and length guards for lists, and both errors become rare.