Loops - for and while

A for loop takes a collection and hands you its items one at a time, running the same indented block for each. The shape is simple and reads almost aloud:

rooms = ["living", "kitchen", "bath", "bed1"]

for room in rooms:
    print(f"Designing the {room}")

Read it as 'for each room in rooms, do the following'. On the first pass, the variable room holds "living"; on the next, "kitchen"; and so on until the list is exhausted. The name room is yours to choose - for r in rooms: works identically - but a meaningful name makes the loop self-documenting. The indented block, exactly like a conditional's block, is defined by its four-space indentation; when the indentation stops, the loop body is over.

The power shows the moment the collection grows. That same four lines process a list of four rooms or four thousand with no change at all - that is the leverage. And a for loop is not limited to lists: it will walk the characters of a string, the lines of a file, the rows of a spreadsheet, or the points of a grid. Anywhere you have 'a bunch of things to handle one by one', a for loop is the tool. You can also do real work inside it - accumulate a total, build a new list, print a report:

areas = [24.0, 12.5, 4.5, 15.0]
total = 0
for a in areas:
    total = total + a
print(f"Total floor area: {total} sqm")   # 56.0

That running-total shape - a variable set before the loop and updated on every pass - is worth pausing on, because it is the simplest example of accumulation, one of the two things loops do. The first is to act on each item in turn: print it, rename it, draw it, tag it. The second is to build up a single answer from many items: a total, a count, a maximum, or a new list. Almost every loop you write is one or the other, or both at once, and naming which you need is half of designing the loop. In design work the accumulation is usually a schedule being assembled or a quantity being summed, which is why this pattern reappears the moment you start handling real project data.

Sometimes you do not have a list to walk - you just want to repeat something a set number of times, or work with numbers in sequence. That is what range() is for. It generates a sequence of integers on demand:

for i in range(4):
    print(i)          # 0, 1, 2, 3

Three things about range() surprise beginners, and all three are worth memorising. First, it starts at 0 by default, matching how Python numbers positions everywhere. Second, it stops before the number you give - range(4) yields 0, 1, 2, 3, which is four numbers but never reaches 4. Third, it can take a start and a step: range(2, 6) gives 2, 3, 4, 5, and range(0, 10, 2) gives 0, 2, 4, 6, 8. The 'stops before the end' rule feels odd at first but pays off - range(len(rooms)) gives exactly the valid index positions of a list, with no off-by-one to worry about.

In practice, when you want both the position and the item, reach for enumerate() rather than range(len(...)) - it is cleaner and it is what experienced Python programmers use:

rooms = ["living", "kitchen", "bath"]
for number, room in enumerate(rooms, start=1):
    print(f"{number}. {room}")   # 1. living / 2. kitchen / 3. bath

A while loop repeats its block as long as a condition remains True. Use it when you do not know up front how many iterations you need - you are looping until some state changes:

budget = 100000
cost_per_unit = 18000
units = 0

while budget >= cost_per_unit:
    budget = budget - cost_per_unit
    units = units + 1

print(f"Afforded {units} units, {budget} left")   # 5 units, 10000 left

The loop checks the condition, runs the body, checks again, and stops the first time the condition is False. The critical discipline with while is that something inside the loop must eventually make the condition false - here, budget shrinks each pass until it can no longer cover a unit. Forget that, and you get an infinite loop: the program runs forever because the condition never changes. Every programmer writes one eventually; when your script hangs, an infinite loop is the first suspect, and Ctrl-C stops it. A good rule of thumb: prefer a for loop when you know the collection or the count in advance (which is most of the time in design work), and reach for while only when the number of repetitions genuinely depends on something that changes as you go.

Two keywords let you steer a loop from inside it. `break` jumps out immediately, abandoning the rest of the loop - useful when you have found what you were looking for and there is no point continuing. `continue` skips the rest of the current pass and jumps straight to the next item - useful for filtering out cases you want to ignore.

rooms = ["living", "", "kitchen", "corridor", "bath"]

for room in rooms:
    if room == "":
        continue                 # skip blanks, go to next room
    if room == "corridor":
        print("reached circulation, stopping")
        break                    # stop the whole loop
    print(f"Processing {room}")

Here the empty string is skipped by continue, "living" and "kitchen" are processed normally, and hitting "corridor" triggers break, so "bath" is never reached. This pairing of a loop with an if inside it is one of the most common patterns in all of scripting: loop over everything, decide something about each item, and act or skip accordingly. It is exactly how you filter a schedule to just the wet rooms, find the first drawing that fails a check, or process files until you hit one that does not fit. Notice how naturally the conditionals from the previous lesson slot inside the loop - control flow is these pieces combined. Master the loop-with-an-if and you can express most of the everyday logic a designer needs to automate.

Loops nest, and that is how a script covers a grid rather than a line. Put one for loop inside another and the inner loop runs completely for each pass of the outer one - which is exactly the logic of rows and columns, a structural grid, or a matrix of options:

for row in range(3):
    for col in range(4):
        print(f"position ({row}, {col})")

That prints twelve positions - three rows, four columns each - and is the seed of generating a grid of columns, a run of facade panels, or a table of layout combinations. The rule to keep in mind is that the work multiplies: a loop over 100 items nested inside another over 100 items runs ten thousand times. Nesting is powerful but not free, so most everyday design tasks are happier with a single level; reach for a second only when your data is genuinely two-dimensional.

The other pattern worth cementing is building a result as you loop. You saw a running total above; the same shape builds a new list, a filtered subset, or a report. Start with an empty container before the loop, and add to it inside:

rooms = ["living", "kitchen", "bath", "bed1"]
areas = [24.0, 12.5, 4.5, 15.0]
large = []
for room, area in zip(rooms, areas):
    if area >= 15:
        large.append(room)
print(large)   # ['living', 'bed1']

This 'empty container, loop, conditionally add' pattern is the backbone of filtering and transforming data, and you will meet it again as the list comprehension in the next lesson and as the heart of the pandas work in Module 4. Notice how the pieces from this whole module click together here: a loop to iterate, zip to walk two lists in step, and a conditional to decide - control flow is not a bag of isolated tricks but these few moves combined. One honest caution about loops and leverage: a loop makes repetition free to write, not free to run. A script that loops over ten thousand files still takes real time, and a clumsy nested loop can be genuinely slow. That rarely matters at the scale of one project, but it is worth knowing that 'the computer will just do it' has limits - and that choosing the right collection, the subject of the next two lessons, is often what keeps a loop fast enough to feel instant.

It also helps to remember what a loop is not for. If you only ever do a thing once, a loop adds noise rather than value - just write the single line. If the collection is empty, the loop body simply never runs, which is usually what you want but occasionally hides a bug where the data failed to load. And if you find a loop growing long and tangled, that is often the moment to lift its body out into a function - the subject of the next module - so the loop reads as a clear sentence: 'for each room, do this named thing'. The loop is the engine, but like any engine it runs best when what it drives is well organised. Keep the body short, name your variables for what they hold, and a loop stays as readable a year later as the day you wrote it.