Loops

A loop repeats a block of code. Python has two:

for — do something for each item

for x in <collection> walks through a list (or string, or range) one item at a time, putting each into x. This is the loop you'll reach for 90% of the time.

❓ Cross-question — "Is for x in xs like JS for...in or for...of?" It's for...of — you get the values, not indices. (JS for...in gives keys/indices — that trap doesn't exist here.) Looping a dict directly gives its keys, so for k in menu: ≈ for (const k of Object.keys(menu)). Need the index too? Use enumerate (below).

The accumulator pattern

To total a list, keep a running sum. Set it to 0 before the loop, add to it inside the loop, use it after:

Indentation decides what's "inside" the loop. If return total is indented under the for, it runs on the first item and quits early. It must be at the same level as total = 0 — after the loop.

Step through it and watch total climb — this is the pattern behind almost every "add up the bill" function you'll ever write:

Here is that early-return mistake as running code. It returns after the first price instead of the whole list:

range() — loop a set number of times

while — repeat until a condition is false

The #1 while-loop bug: forgetting to change the condition variable, so it never becomes false → an infinite loop. (Our sandbox will stop it after a few seconds, but avoid it!)

break, continue, and pass

Three little words steer what happens inside a loop:

• break — stop the whole loop immediately.
• continue — skip to the next item, ignoring the rest of this round.
• pass — do nothing — a placeholder that means "no action here."

pass is the odd one out — it does nothing at all. Python sometimes requires a statement (you can't leave the block after a : empty), so pass fills the gap. Use it as a placeholder while you're sketching, or when a branch genuinely has nothing to do:

break vs continue vs pass: break leaves the loop, continue jumps to the next round, and pass just falls through to the next line. pass isn't loop-only — it's Python's "empty statement," used anywhere a line is required but you have none (empty functions, if branches, class bodies).

for … else — "we finished without breaking"

A loop can have an else. It's an unusual piece of Python and the name is genuinely misleading, so read the rule carefully: else runs when the loop finished normally — that is, when break never fired.

Read it as "for … then, if nothing broke out". It saves you the "did I find it?" flag variable you'd otherwise have to keep:

Idioms & real-world patterns

Basic for/while loops work, but Python rewards going higher-level. These patterns are what fluent Python looks like — shorter, faster, clearer.

enumerate — index and item, together

Need the position while looping? Don't manage a counter by hand:

Coming from Java/JS: replaces for (let i = 0; i < a.length; i++) and JS forEach((x, i) => …) — but the order is (i, x), index first.

zip — walk two lists in lockstep

zip pairs items position-by-position, stopping at the shortest:

List comprehensions — a loop that builds a list

The single most important Python idiom. It turns "make an empty list, loop, append" into one expression:

Add a trailing if to filter:

Coming from Java/JS: this replaces .map() / .filter() chains. nums.map(x => x*2).filter(x => x > 3) ≈ [x*2 for x in nums if x*2 > 3].

❓ Cross-question — "Can't I just call .map() on a list?" No — Python lists have no .map/.filter/.reduce methods. The comprehension is the idiom (the free functions map()/filter() also exist, but comprehensions read better), and it builds a real list, not a lazy iterator.

Dict & set comprehensions

Same shape, different braces — build a dict with key: value, or a set (auto-unique):

⚡ Advanced — generators: build items lazily

A generator expression looks like a list comprehension with () instead of [], but it doesn't build the whole list — it yields items one at a time, on demand. Ideal for huge streams or feeding sum()/any()/max():

A generator function uses yield to produce values across calls, pausing and resuming its own state — memory stays flat no matter how many items:

Coming from Java/JS: yield is like a JS generator (function*), and a lazy generator is like a Java Stream — nothing is computed until you iterate it.

❓ Cross-question — "When do I use a generator (…) vs a list […]?" Use a list comp […] when you need the whole thing now — indexing, len, reuse (eager, like a JS array). Use a generator (…) for large/streaming data or a one-pass feed into sum()/any()/max() (lazy, single-use, like a JS generator). Iterating a generator a second time yields nothing.

⚡ Advanced — itertools, the loop power tools

The itertools module has battle-tested building blocks. Two you'll reach for:

🎯 Your turn

Write sum_items(prices) — it adds up a list of prices with a loop and returns the total:

• sum_items([10, 20, 5.5]) → 35.5
• sum_items([]) → 0

Hint — start total = 0, then for price in prices: total += price, and return total after the loop.

Then press ▶ Run, tap the Live App try chips to call it with different inputs, and hit ✓ Check. Green = this piece of the app is built. ✅