Nested For Loops — Star Pattern Printing

A loop inside a loop, traced step by step with Python Tutor — outer loop controls rows, inner loop controls stars per row.

Overview

This topic covers nested for loops in Python, using the classic example of printing a right-angled triangle made of stars (*). It combines two learning tools:

1. Python Tutor (pythontutor.com) — used to visualize, step-by-step, how the outer and inner loop variables change and how output is built line by line.
2. Jupyter Notebook — used to run the actual code and make it dynamic by accepting the number of rows from user input.

The goal is to understand how a nested loop executes internally (which is often the confusing part), not just what code to write.

Key Concepts

• A nested loop is a loop inside another loop (an inner loop running completely for every single iteration of the outer loop).
• The outer loop (i) controls the number of rows.
• The inner loop (j) controls how many stars are printed in each row.
• print("*", end=" ") prints a star without moving to a new line (keeps printing on the same line, separated by a space).
• print("") after the inner loop finishes prints an empty string, which just moves the cursor to the next line — this is what creates the new row.
• The number of stars in row i equals i (row 1 → 1 star, row 2 → 2 stars, etc.), because the inner loop runs range(0, i).

The Core Code

for i in range(1, 6):
    for j in range(0, i):
        print("*", end=" ")
    print("")

Line-by-line explanation

Line	What it does
for i in range(1, 6):	Outer loop — runs i from 1 to 5 (5 rows total, since range(1,6) excludes 6).
for j in range(0, i):	Inner loop — runs j from 0 up to i-1, so it loops i times for each row.
print("*", end=" ")	Prints a star and a space, staying on the same line (end=" " overrides the default newline).
print("")	After the inner loop completes, this moves to a new line to start the next row.

Expected Output:

*
* *
* * *
* * * *
* * * * *

Note: Row i prints exactly i stars — this is the key relationship to remember for any triangle-pattern problem.

Tracing Execution with Python Tutor

Python Tutor was used to visualize the code execution step by step. This is very useful for understanding how variable values change over time in a nested loop.

How it works

• The tool shows:
  • The code on the left, with an arrow (→) marking: the line that just executed, and the line that will execute next (shown in red).
  • The Global frame (variables) on the right, showing current values of i and j.
  • The Print output panel showing what has been printed so far.
  • A step counter (e.g. "Step 1 of 46") and Prev/Next/First/Last navigation buttons to move through execution one step at a time.

Step-by-step trace observed in the screenshots

Step	Line executing	i	j	Output so far
1	for i in range(1,6): (about to start)	—	—	(empty)
2	for i in range(1,6): just executed → next is for j in range(0,i)	1	—	(empty)
3	for j in range(0,i): executing	1	0 (about to be assigned)	(empty)
...	inner loop runs, printing stars	1	0	*
... (many steps)	outer and inner loops continue	increasing	increasing	building up triangle
46 (final)	Done running	5	4	Full triangle: * / * * / * * * / * * * * / * * * * *

Key observations from the trace:

• The program takes 46 total steps to fully execute for range(1,6) — every loop check, assignment, and print statement counts as a step.
• The inner loop variable j resets back to the start of its range every time the outer loop moves to a new i. This is the essence of "nested" loops — the inner loop is a completely fresh loop on every outer iteration.
• Watching i and j change in the Global frame panel while watching the Print output grow is the best way to build intuition for nested loops.

💡 Tip: If a nested loop pattern is confusing, paste the code into Python Tutor and step through it line-by-line. Watching the variable values update alongside the output makes the logic click much faster than just reading the code.

Making It Dynamic — Taking User Input

Instead of hardcoding range(1, 6), the number of rows can be taken from the user so the pattern size becomes flexible.

rows = int(input("Enter the number of rows"))

for i in range(1, rows + 1):
    for j in range(0, i):
        print("*", end=" ")
    print("")

Explanation of changes

• input("Enter the number of rows") — prompts the user and returns their input as a string.
• int(...) — converts that string into an integer, since range() requires integers.
• range(1, rows + 1) — changed from a hardcoded 6 to rows + 1, so the loop runs exactly rows times (e.g., if rows = 10, it loops i from 1 to 10).

Example Run (Jupyter Notebook)

Input:

Enter the number of rows: 10

Output:

*
* *
* * *
* * * *
* * * * *
* * * * * *
* * * * * * *
* * * * * * * *
* * * * * * * * *
* * * * * * * * * *

Note: This confirms the pattern rule holds for any input — row i always has exactly i stars, up to rows.

Practice Reference (from notebook comments)

Before writing the loop, the pattern to build was sketched out as a comment for planning:

# *
# **
# ***
# ****
# *****

This is a useful habit — sketch the expected output first (as comments), then reverse engineer the loop logic (rows vs. stars-per-row) from that shape.

Things to Remember

Quick Revision

To print a triangle of stars with n rows:

rows = int(input("Enter the number of rows"))
for i in range(1, rows + 1):      # controls row number / stars in that row
    for j in range(0, i):         # runs i times for row i
        print("*", end=" ")       # stay on same line
    print("")                     # move to next line after row is done

• Row i → i stars.
• Inner loop fully completes before outer loop moves to the next i.
• Use Python Tutor to step through and watch i, j, and the output panel update in real time if the logic feels unclear.