Loops & Iteration

Data science is repetition at scale: apply the same step to every row, every file, every experiment. Copy-pasting a line five times doesn't scale to five million — loops do. In this lesson you'll learn for and while, the helpers range, enumerate, and zip, list comprehensions, and the accumulator pattern that underlies nearly every summary statistic.

Why loops exist

Suppose you need to print a reminder five times. You could write five print() calls... and then the requirement changes to fifty. A for loop with range(n) runs its indented body n times:

Python — runs in your browser

Run

# The painful way print("I will not repeat the same mistake again") print("I will not repeat the same mistake again") # The loop way - change 5 to 5000 without touching anything else for i in range(5): print(f"({i}) I will not repeat the same mistake again")

Note that range(5) yields 0, 1, 2, 3, 4 — it starts at 0 and stops before 5, exactly like list slicing. range(start, stop) and range(start, stop, step) give you more control: range(2, 10, 2) is 2, 4, 6, 8.

Looping over collections

The real power move: for iterates directly over any collection — no index bookkeeping needed. Lists yield items, strings yield characters, and dictionaries yield keys:

Python — runs in your browser

Run

animals = ["cat", "dog", "fish"] for animal in animals: print(animal.upper()) for letter in "data": print(letter) person = {"name": "Rama", "age": 22} for key in person: print(f"{key} -> {person[key]}") # Or get key and value together with .items() for key, value in person.items(): print(key, "=", value)

Read for animal in animals aloud: "for each animal in animals". Choosing a singular loop variable for a plural collection makes loops self-explanatory.

enumerate and zip

Two built-ins solve the most common loop chores. enumerate gives you the index and the item — perfect for numbered output. zip walks two (or more) lists in lockstep, pairing up corresponding items:

Python — runs in your browser

Run

animals = ["cat", "dog", "fish"] for i, animal in enumerate(animals): print(f"{i + 1}. {animal}") products = ["pc", "laptop", "mouse"] prices = [9000, 12000, 300] for product, price in zip(products, prices): print(f"{product}: {price}")

If you ever catch yourself writing for i in range(len(items)) just to do items[i], reach for enumerate (need the index) or plain for item in items (don't) instead — same result, far more readable.

The accumulator pattern

Here is the single most important loop idiom in data work. To compute a total (or count, or running maximum), you: (1) create a variable before the loop, (2) update it on every iteration, (3) use it after the loop:

Python — runs in your browser

Run

quantities = [5, 4, 8, 9] prices = [1000, 2000, 3000, 4000] revenue = 0 # 1. start the accumulator for quantity, price in zip(quantities, prices): revenue += quantity * price # 2. update it each pass print(f"Total revenue: {revenue}") # 3. use the result # Counting is the same pattern with += 1 scores = [80, 45, 92, 55, 71, 38] passed = 0 for score in scores: if score >= 60: passed += 1 print(f"{passed} of {len(scores)} students passed")

revenue += x is shorthand for revenue = revenue + x. Built-ins like sum() are this exact pattern packaged up — but you'll constantly need custom versions of it, like the conditional count above.

while: loop until a condition changes

A for loop runs once per item; a while loop keeps running as long as its condition stays true. Use it when you don't know the number of iterations in advance:

Python — runs in your browser

Run

# How many years to double your money at 8% interest? balance = 1000 years = 0 while balance < 2000: balance = balance * 1.08 years += 1 print(f"Doubled after {years} years (balance: {balance:.0f})")

The body must move the condition toward False — here the balance grows every pass. Forget that, and you get an infinite loop that never stops (if it happens in a notebook, interrupt the kernel).

break and continue

Two keywords fine-tune any loop. break exits the loop immediately; continue skips the rest of the current iteration and jumps to the next:

Python — runs in your browser

Run

readings = [4.2, 3.9, None, 5.1, -999, 4.8] total, count = 0, 0 for r in readings: if r is None: continue # skip missing values, keep looping if r == -999: print("Sensor failure code found - stopping early") break # abandon the loop entirely total += r count += 1 print(f"Averaged {count} readings: {total / count:.2f}")

This is a very realistic pattern: skimming a data stream, skipping bad records, and bailing out on a fatal one.

Nested loops

A loop inside a loop: the inner loop runs completely for each pass of the outer one. That's how you cover every combination — every cell of a grid, every pair of items:

Python — runs in your browser

Run

sizes = ["S", "M", "L"] colors = ["red", "blue"] for size in sizes: for color in colors: print(f"{size}-{color}") print("---") # Total iterations = len(sizes) * len(colors) = 6

Nested loops multiply: 1000 × 1000 items means a million iterations. Fine for small data — but when things feel slow later in the course, a nested loop is often the culprit (and NumPy or pandas the cure).

List comprehensions

Python has a beloved shortcut for the "build a new list from an old one" loop. A list comprehension packs create-loop-append into one readable line, with an optional if to filter:

Python — runs in your browser

Run

scores = [80, 45, 92, 55, 71] # The loop way curved = [] for s in scores: curved.append(s + 5) print(curved) # The comprehension way - identical result curved = [s + 5 for s in scores] print(curved) # With a filter: keep only passing scores passing = [s for s in scores if s >= 60] print(passing) # Transform AND filter at once labels = [f"pass ({s})" for s in scores if s >= 60] print(labels)

The template is [expression for item in collection if condition]. Comprehensions are everywhere in real Python code — use them for simple transform/filter jobs, and fall back to a full loop when the logic needs multiple statements.

Check your understanding

5 questions · free

1. Q1.What numbers does range(5) produce?

   A1, 2, 3, 4, 5B0, 1, 2, 3, 4C0, 1, 2, 3, 4, 5D5 zeros

2. Q2.You need both the position and the value of each list item. Which tool is most idiomatic?

   Afor i in range(len(items))Bzip(items, items)Cfor i, item in enumerate(items)Da while loop with a manual counter

3. Q3.Inside a loop over data records, what does continue do?

   AExits the loop entirelyBSkips the rest of THIS iteration and moves to the next itemCRestarts the loop from the first itemDPauses the loop until a key is pressed

4. Q4.What's wrong with: total = 0 placed INSIDE the for loop body of an accumulator?

   ANothing - it works the sameBIt resets total to 0 on every iteration, so you end up with only the last item's contributionCIt causes an infinite loopDIt raises a NameError

5. Q5.What does [s * 2 for s in [1, 2, 3] if s != 2] evaluate to?

   A[2, 4, 6]B[1, 3]C[2, 6]D[4]

Exercise: A weekly sales report

You have four weeks of sales, one list of sold items per week, in the dict data shown in the hints/solution (weeks week1–week4 with items like "pc", "laptop", "mouse"). Write (1) a function total_sold(data, product) that loops over the dictionary and uses .count() with an accumulator to return how many units of product were sold across all weeks — verify "pc" → 9, "mouse" → 4, "keyboard" → 2. Then (2) find which week sold the most items overall, and (3) build the set of unique products ever sold.

That wraps up Python fundamentals — next module, you'll put these building blocks to work on real tabular data with NumPy and pandas.