1   Why Do We Need Loops?

Suppose you want to print a countdown from 5 to 1. You could write it out by hand:

print(5)
print(4)
print(3)
print(2)
print(1)
print("Liftoff!")

That works for five numbers. But what if you needed a countdown from 1,000? Or if you had a list of 500 student names to process? Writing one line per item is not programming — it is just typing. Loops solve this.

Here is the same countdown written with a loop — it will work whether the starting number is 5 or 5,000:

n = 5
while n > 0:
    print(n)
    n -= 1
print("Liftoff!")

2   The while Loop

A while loop keeps running its body as long as a condition is True. Every time Python reaches the bottom of the loop body, it jumps back to the top and checks the condition again. When the condition becomes False, the loop stops and Python moves on to whatever comes next.

2.1   The Structure

while condition:
    # body: runs repeatedly as long as condition is True

The rules are the same as for if statements: a colon after the condition, and the body indented. The critical difference is that an if runs its body at most once. A while loop can run its body thousands of times.

2.2   A Full Example with Trace

count = 1

while count <= 4:
    print("Count is:", count)
    count += 1

print("Done.")

Let's trace this execution step by step — this is called a loop trace. Good programmers do this on paper before running unfamiliar loops:

After the loop exits, Python prints "Done." — that line is outside the loop (not indented under while), so it runs exactly once.

2.3   The Infinite Loop — and How to Avoid It

The most dangerous mistake with a while loop is writing one where the condition never becomes False. This is called an infinite loop — the program runs forever and never moves on:

# DANGER: infinite loop — count never changes, condition never becomes False
count = 1
while count <= 4:
    print("Count is:", count)
    # forgot count += 1 !

Every while loop needs something inside it that changes the state so the condition can eventually become False. Before you write a while loop, always ask: "What will make this condition false, and does my loop actually do that?"

2.4   A Practical while Loop: Input Validation

One of the most common real uses of a while loop is asking the user for input repeatedly until they give a valid answer. This is called an input validation loop:

age = int(input("Enter your age: "))

while age < 0 or age > 120:
    print("That does not look like a valid age. Please try again.")
    age = int(input("Enter your age: "))

print("Thank you! Age recorded:", age)

The loop keeps running as long as the input is invalid. The moment a valid age is entered, the condition becomes False and the loop exits cleanly. This pattern — keep asking until the answer is acceptable — is something you will use constantly.

3   The for Loop

A for loop steps through a sequence — a list, a range of numbers, or a string — one item at a time. For each item, it runs the loop body once. When there are no more items, the loop ends automatically.

Unlike a while loop, a for loop has a built-in stopping point: the end of the sequence. You do not need to worry about updating a counter or creating an infinite loop.

3.1   The Structure

for variable in sequence:
    # body: runs once for each item in the sequence

The variable is a new name that holds the current item in each iteration. You choose the name — pick something descriptive. The sequence is whatever you are stepping through.

3.2   Looping Over a List

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

Output:

apple
banana
cherry

On the first iteration, fruit is "apple". On the second, it is "banana". On the third, "cherry". After that, the list is exhausted and the loop ends.

3.3   Looping Over a String

A string is also a sequence — a sequence of characters. A for loop will step through each character one at a time:

word = "Python"

for letter in word:
    print(letter)

Output:

P
y
t
h
o
n

3.4   Combining Loops and Conditionals

Loops and conditionals work naturally together. Here a loop steps through a list and a conditional picks out only certain items:

scores = [85, 42, 91, 67, 55, 78, 39, 95]

print("Students who need extra support:")
for score in scores:
    if score < 60:
        print(" -", score)

The loop visits all eight scores; the if inside it only prints the ones below 60. This pattern — loop through everything, act on some — is one of the most useful in programming.

4   Counting with range()

Very often you want to loop a specific number of times, or step through a range of numbers, without having to create a list yourself. Python's built-in range() function generates a sequence of numbers for you — and works perfectly with a for loop.

4.1   Three Forms of range()

4.2   range() in Action

# Print 0 to 4
for i in range(5):
    print(i)

# Print 1 to 5
for i in range(1, 6):
    print(i)

# Print even numbers from 0 to 10
for i in range(0, 11, 2):
    print(i)

# Count backwards from 5 to 1
for i in range(5, 0, -1):
    print(i)
print("Liftoff!")

4.3   Using range() to Repeat an Action

Sometimes you want to run a block of code a fixed number of times and you do not need the loop variable at all. This is completely valid:

# Ask for 3 quiz answers
for i in range(3):
    answer = input("Enter your answer: ")
    print("Recorded:", answer)

Here i is never used inside the loop body — the loop just ensures the block runs exactly 3 times. Some programmers write _ as the variable name in this case (for _ in range(3):) to signal that the variable is intentionally unused. Both styles are fine.

5   Choosing Between while and for

Knowing which loop to use is an important design skill. Here is the core rule:

6   Controlling a Loop: break and continue

Python gives you two keywords that let you take control of a loop from inside its body. Both work in for and while loops.

6.1   break — Exit the Loop Early

break immediately stops the loop and jumps to the first line after it — no matter what the condition says or how many items are left in the sequence.

names = ["Alice", "Ben", "Carol", "Dan", "Eve"]
target = "Carol"

for name in names:
    if name == target:
        print("Found:", name)
        break
    print("Checking:", name)

print("Search complete.")

Output:

Checking: Alice
Checking: Ben
Found: Carol
Search complete.

Once "Carol" is found, break exits the loop immediately. "Dan" and "Eve" are never checked.

6.2   continue — Skip to the Next Iteration

continue skips the rest of the current iteration and jumps straight back to the top of the loop to start the next one. It does not exit the loop — it just skips one pass.

scores = [85, -1, 42, -1, 91, 67]

print("Valid scores:")
for score in scores:
    if score < 0:
        continue    # skip invalid entries
    print(score)

Output:

Valid scores:
85
42
91
67

The -1 entries are skipped; the loop continues normally for all other values.

6.3   break and continue in while Loops

Both keywords work in while loops too. A common pattern is a while True: loop — one that would run forever on its own — controlled entirely by a break:

# A menu that keeps running until the user chooses to quit
while True:
    choice = input("Enter command (help / quit): ").lower()

    if choice == "quit":
        print("Goodbye!")
        break
    elif choice == "help":
        print("Available commands: help, quit")
    else:
        print("Unknown command. Try 'help'.")

while True: creates an intentional infinite loop. The only way out is the break when the user types "quit". This is a widely used and perfectly acceptable pattern — as long as there is a clear, reachable break inside.

7   Common Loop Patterns

Certain loop structures appear so frequently in real programs that they are worth learning by name. Once you recognise these patterns, you will be able to write them from memory and spot them instantly in other people's code.

7.1   The Accumulator Pattern

Create a variable before the loop. Update it inside the loop. Read the result after the loop.

# Sum all numbers in a list
scores = [78, 92, 55, 84, 67]
total = 0                    # accumulator starts at 0

for score in scores:
    total += score           # add each score to the running total

print("Total:", total)
print("Average:", total / len(scores))

7.2   The Counter Pattern

Count how many items in a sequence meet a condition.

scores = [78, 92, 55, 84, 40, 67, 38]
passing = 0                  # counter starts at 0

for score in scores:
    if score >= 60:
        passing += 1         # increment when condition is met

print(passing, "students passed out of", len(scores))

7.3   The Search Pattern

Loop through a sequence and stop as soon as you find what you are looking for.

usernames = ["alice", "bob", "carol", "dan"]
search = "carol"
found = False

for name in usernames:
    if name == search:
        found = True
        break

if found:
    print(search, "exists in the system.")
else:
    print(search, "was not found.")

7.4   The Collector Pattern

Build a new list by collecting only the items that meet a condition.

scores = [78, 92, 55, 84, 40, 67, 38]
high_scores = []             # start with an empty list

for score in scores:
    if score >= 80:
        high_scores.append(score)   # add qualifying scores

print("High scores:", high_scores)

7.5   The Input-Until-Valid Pattern

Keep asking the user for input until they provide something acceptable.

while True:
    response = input("Type yes or no: ").lower()
    if response == "yes" or response == "no":
        break
    print("Please type exactly 'yes' or 'no'.")

print("You chose:", response)

8   Putting It All Together

Here is a complete program that uses both types of loops, range(), break, and three of the patterns above. Read it carefully and trace the execution before looking at the explanation below.

PASSING_SCORE = 60
NUM_STUDENTS = 4

scores = []
total = 0
failing = []

# Input loop — collect scores from the user
print("--- Score Entry ---")
for i in range(1, NUM_STUDENTS + 1):
    while True:
        score = int(input(f"Enter score for student {i} (0–100): "))
        if 0 <= score <= 100:
            break
        print("Invalid score. Please enter a number between 0 and 100.")
    scores.append(score)

# Processing loop — analyse the collected scores
for score in scores:
    total += score                     # accumulator
    if score < PASSING_SCORE:
        failing.append(score)          # collector

average = total / len(scores)

# Results
print("\n--- Results ---")
print("Scores entered:", scores)
print(f"Average score: {average:.1f}")
print(f"Students failing ({len(failing)}):", failing)

if len(failing) == 0:
    print("All students passed!")

What this program demonstrates:

• A <strong>for</strong> loop over range() controls how many students are entered.
• A <strong>while True</strong> loop inside the for loop validates each entry — a loop inside a loop, called a nested loop.
• The accumulator pattern builds the total; the collector pattern gathers failing scores.
• break exits the inner while loop the moment a valid score is entered.
• All processing happens in a single pass through the list — one loop, three things happening at once.

9   Final Check: The Big Picture

10   Quick-Reference Summary