Nested Loops in Python Explained — How They Work, When to Use Them, and Mistakes to Avoid

Loops are one of the most powerful ideas in programming — they let you repeat a task without writing the same code ten times over. But what happens when your data has layers? A school has classrooms AND students. A cinema has rows AND seats. A spreadsheet has rows AND columns. That's where nested loops come in, and they show up constantly in real software.

What Is a Nested Loop — and Why Does Python Need Them?

A nested loop is simply a loop that lives inside another loop. Python runs the outer loop once, then runs the entire inner loop from start to finish, then goes back and advances the outer loop by one step, then runs the entire inner loop again — and so on until both loops are done.

Think of it like a clock. The minute hand (inner loop) has to complete a full 60-minute revolution before the hour hand (outer loop) moves forward by one hour. The inner loop always finishes completely before the outer loop takes its next tick.

You need nested loops whenever your problem has two dimensions — two things you need to iterate over together. Printing a multiplication table, searching a grid, processing a list of lists, or generating coordinates on a map — all of these need nested loops.

Python's indentation makes nested loops visually obvious. The inner loop's code is indented further than the outer loop, so you can see the structure at a glance. That clarity is one of Python's greatest strengths.

# We have 3 school buildings, each with 4 classrooms.
# We want to visit every classroom in every building.

number_of_buildings = 3
classrooms_per_building = 4

# The outer loop moves through each building one at a time.
for building_number in range(1, number_of_buildings + 1):

    print(f"--- Entering Building {building_number} ---")

    # The inner loop runs fully for EVERY single iteration of the outer loop.
    # So for Building 1, we visit all 4 classrooms before moving to Building 2.
    for classroom_number in range(1, classrooms_per_building + 1):

        # This line runs building_number * classrooms_per_building times total = 12 times.
        print(f"  Visiting Classroom {classroom_number} in Building {building_number}")

print("\nAll classrooms visited!")

Building a Real Example — A Cinema Seat Selector

Let's make this concrete with something everyone understands: a cinema. A cinema has rows (let's say A, B, C) and each row has numbered seats (1 through 5). Every combination of row and seat is a unique ticket — 'A1', 'A2', 'B3', and so on.

Generating every possible seat is a perfect two-dimensional problem. The outer loop walks through the rows. The inner loop walks through the seat numbers within that row. Together they produce every seat combination without us having to write it out by hand.

Notice how the variable from the outer loop (the row letter) is used inside the inner loop. That's the real power of nesting — the inner loop has access to the outer loop's current value and can use it to build something meaningful.

This pattern — combining one variable from the outer loop with one from the inner loop — is the bread and butter of nested loops. You'll use it constantly.

# A cinema with rows A, B, C and seats 1 through 5.
# We want to print every available seat in the cinema.

row_labels = ['A', 'B', 'C']       # Each letter is one row of seats.
seats_per_row = 5                  # Every row has exactly 5 seats.

print("Available Seats:")
print("----------------")

# Outer loop: move through each row one at a time.
for row_letter in row_labels:

    # Inner loop: for THIS row, go through every seat number.
    for seat_number in range(1, seats_per_row + 1):

        # We combine the outer loop's variable (row_letter) with
        # the inner loop's variable (seat_number) to build a seat label.
        seat_label = f"{row_letter}{seat_number}"

        # end=' ' keeps everything on one line per row — cleaner output.
        print(seat_label, end='  ')

    # After all seats in a row are printed, drop to a new line.
    print()  # This print() runs once per outer loop iteration.

print("----------------")
print(f"Total seats: {len(row_labels) * seats_per_row}")

A Classic Interview Example — The Multiplication Table

The multiplication table is the go-to nested loop exercise in interviews and coding tests, and for good reason — it perfectly demonstrates two-dimensional iteration. Every cell in the table is the product of a row number and a column number. Row 3, Column 4 = 12. That's it.

The outer loop controls which row we're on (the number we're multiplying by). The inner loop controls which column we're in (the number being multiplied). For every row, we multiply the row number by every column number from 1 to 10.

The formatting here is important too. We use Python's f-string alignment feature to make the numbers line up neatly in columns. This shows that nested loops aren't just about generating data — they're also about presenting it well.

If an interviewer asks you to write a multiplication table with a nested loop, they're checking that you understand that the outer loop variable changes slowly and the inner loop variable changes quickly.

# Print a 5x5 multiplication table.
# The outer loop is the row (multiplier 1-5).
# The inner loop is the column (multiplier 1-5).

table_size = 5

print("Multiplication Table (5x5)")
print("=" * 30)

# Print column headers so the table is readable.
print("    ", end='')   # Leading space to align with row labels.
for column_header in range(1, table_size + 1):
    # :>5 right-aligns the number in a 5-character-wide space.
    print(f"{column_header:>5}", end='')
print()  # New line after headers.
print("-" * 30)

# Outer loop: each row represents one multiplier (1, 2, 3, 4, 5).
for row_multiplier in range(1, table_size + 1):

    # Print the row label on the left.
    print(f"{row_multiplier:>3} |", end='')

    # Inner loop: multiply the row number by every column number.
    for column_multiplier in range(1, table_size + 1):

        result = row_multiplier * column_multiplier   # The actual calculation.

        # :>5 right-aligns each result so columns stay neat.
        print(f"{result:>5}", end='')

    print()  # Move to the next line after all columns in this row are done.

print("=" * 30)

Nested Loops with Lists of Lists — Real Data Structures

In real Python programs, you'll often encounter a list of lists — sometimes called a 2D list or a matrix. Picture a spreadsheet: the outer list is all the rows, and each inner list is the data in one row. Nested loops are the natural way to visit every single cell.

This pattern comes up constantly: student grade books, game boards, pixel grids in images, seating charts, survey results. Any time data has rows and columns, you're looking at a list of lists, and nested loops are your tool.

The key insight here is that the outer loop gives you each inner list (a full row), and the inner loop gives you each individual item within that row. You're peeling the data structure apart layer by layer.

You can also use enumerate() if you need to know which row number or column number you're on — that's a very common pattern in production code.

# A gradebook stored as a list of lists.
# Each inner list is one student's scores across 3 subjects.

student_names = ["Alice", "Ben", "Clara"]
subject_names = ["Maths", "Science", "English"]

# Each inner list holds [maths_score, science_score, english_score]
gradebook = [
    [88, 92, 75],   # Alice's scores
    [70, 85, 91],   # Ben's scores
    [95, 78, 88],   # Clara's scores
]

print("Student Report Cards")
print("=" * 35)

# Outer loop: enumerate() gives us both the index AND the inner list.
# student_index lets us look up the student's name from student_names.
for student_index, student_scores in enumerate(gradebook):

    student_name = student_names[student_index]  # Get the name by index.
    print(f"\n{student_name}'s Grades:")

    total_score = 0

    # Inner loop: go through each score within this student's row.
    # zip() pairs each score with the matching subject name.
    for subject, score in zip(subject_names, student_scores):
        print(f"  {subject}: {score}/100")
        total_score += score  # Accumulate for the average.

    # This average is calculated once per student — after the inner loop finishes.
    average_score = total_score / len(subject_names)
    print(f"  Average: {average_score:.1f}/100")

print("\n" + "=" * 35)

Frequently Asked Questions