Loops: Beginner

Loop through any list or string

The for loop iterates over each item in a sequence (like a list, string, or tuple) one at a time. On each iteration, the loop variable is assigned the next item from the sequence, and the loop body executes with that value.

A for loop has the form: for variable in sequence: followed by an indented block. The variable takes on each value from the sequence in order:

The loop executes three times. On the first iteration, fruit is "apple". On the second, it is "banana". On the third, "cherry". After all items are processed, the loop ends and execution continues with the next unindented statement.

total = 0
for n in [1, 2, 3]:
    total ___=+=*= n
print(total)

Generate number sequences with range()

The range() function generates a sequence of numbers. It is commonly used with for loops when you need to repeat an action a specific number of times or iterate over a sequence of integers.

range(n) generates numbers from 0 up to (but not including) n. This gives you exactly n iterations:

Notice that range(5) produces 0, 1, 2, 3, 4 - five numbers starting from 0, not including 5. This is consistent with zero-based indexing.

range(start, stop) generates numbers from start up to (but not including) stop:

range(start, stop, step) lets you specify the increment between numbers:

Each form of range() gives you a different level of control over the generated sequence. Here are the three signatures and their behavior at a glance:

Sometimes you need both the index and the value. You can use range with len to loop by index:

Using range(len(list)) for index access works, but Python has a better way: enumerate(). You will learn this in the intermediate lesson. For now, range(len()) is fine.

The range function is not limited to controlling loops. You can convert a range to a list to create numeric sequences for various purposes:

The list() function converts the range object into an actual list. This is useful when you need to store the sequence or pass it to a function that requires a list rather than an iterator.

nums = list(___(2, 8))
print(nums[0])
print(___(nums))

range() is memory efficient: it does not store all the numbers at once. It generates each value on demand, making it safe to use with very large ranges like range(1_000_000) without consuming extra memory.

The three-argument form range(start, stop, step) covers almost every numeric sequence you will need in a for loop, including counting up, counting down, and selecting every nth value.

When you need the actual list of numbers for slicing, indexing, or repeated access, wrap range() in list(). Otherwise, iterating over the range object directly in a for loop is the preferred approach.

Repeat actions until a condition fails

A while loop repeats as long as its condition is True. Unlike for loops that iterate a fixed number of times, while loops continue until the condition becomes False. This makes them ideal when you do not know in advance how many iterations you need.

A while loop has the form: while condition: followed by an indented block. The condition is checked before each iteration:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

count = 0
while count < 5:
  print(count)
  count = count + 0

A common pattern is to use while True combined with break to create loops that exit based on complex conditions. This is especially useful when the exit condition is checked in the middle of the loop body rather than at the beginning:

Exit or skip iterations on demand

Python provides two statements to control loop execution: break exits the loop immediately, and continue skips the rest of the current iteration and moves to the next one.

break immediately terminates the innermost loop. Execution continues with the first statement after the loop:

When the loop finds -2, break executes and the loop ends immediately. The remaining items (7, 8) are never checked.

continue skips the rest of the current iteration and jumps to the next iteration of the loop:

When continue executes, the loop immediately moves to the next item. The print statement after continue is skipped for negative numbers.

The break statement only exits the innermost loop. If you have nested loops and want to exit the outer loop, you need additional logic like a flag variable:

Knowing when to use break versus continue prevents subtle bugs and keeps loop logic readable. Follow these guidelines:

result = []
for n in range(10):
    if n % 2 == 0:
        ___
    result.append(n)
    if len(result) == 3:
        ___
print(result)

break and continue are most valuable when processing input that has mixed valid and invalid entries. Use continue to skip bad records and break to stop as soon as a target is found.

A common pattern in searching is to use break when a match is found and rely on a flag variable or else clause to detect when no match was found after the full loop completes.

In while loops, forgetting to update the loop counter before a continue statement is a frequent cause of infinite loops. Always ensure the condition can eventually become False regardless of which path through the loop body is taken.

Predict variable values after loops end

In Python, loop variables (the variable after for or used in a while condition) remain accessible after the loop ends. This is different from some other languages where loop variables are scoped only to the loop body.

After a for loop completes, the loop variable retains its last value:

After the loop, i holds the last value it was assigned, which is 4 (the last number in range(5)). For letters, it holds "C".

Variables persist after loops

The loop variable keeps its last assigned value after the loop completes

Use descriptive names

Prefer item, row, or char over single letters like i or x

Empty loops skip assignment

If the sequence is empty, the loop variable is never created

Initialize before the loop

Set a default value before the loop if you need the variable afterward