06. Loops and Comprehensions¶

# Concept-01: A while loop repeats while its condition is True; change the variable inside or it runs forever
# Question: How do we count from 1 to 5 with a loop, and make sure it actually stops? (the block must change the variable the condition tests)
count = 1
while count <= 5:      # keep going while count is 5 or less
    print(count)
    count += 1         # += 1 moves count forward; WITHOUT this line the loop never stops
# This block would run FOREVER because count never changes - never uncomment it:
# count = 1
# while count <= 5:
#     print(count)

# Concept-02: A while loop can run UNTIL a condition becomes false, even with no fixed count
# Question: How do we keep doubling the number 1 while it stays 100 or less? (no fixed count - it stops before printing anything above 100)
value = 1
while value <= 100:    # keep going while value is 100 or less
    print(value)
    value = value * 2  # reassign value to twice its size

# Concept-03: Count DOWN by subtracting from the variable each turn with -=
# Question: How do we count down from 5 to 1, and then print "Done"? (-= 1 walks the variable back toward the stop)
n = 5
while n >= 1:          # keep going while n is 1 or more
    print(n)
    n -= 1             # -= 1 moves n backward toward the stop
print("Done")          # runs once, after the loop finishes

# Concept-04: Keep a running total (an accumulator) by adding into one variable each turn
# Question: How do we add up the numbers 1 to 5 into one total? (start a total at 0 and add each number in - the accumulator pattern)
total = 0
i = 1
while i <= 5:
    total += i         # add this number into the running total
    i += 1
print("total:", total)  # 15

# Concept-05: Walk a list one position at a time with while i < len(list) (fiddly - for is cleaner)
# Question: How do we go through the list [70, 95, 60, 88] by its index positions, 0 to the last? (while i < len(scores) stops right after the last item)
scores = [70, 95, 60, 88]
i = 0
while i < len(scores):  # stop when i reaches the length (no item at that index)
    print(scores[i])    # scores[i] is the item at position i
    i += 1

# Concept-06: A while test can be ANY truthy value, not only a number comparison (a non-empty list is truthy)
# Question: How do we keep taking items from the list ["Sam", "Tom", "Ben"] until it is empty? (a non-empty list is truthy)
names = ["Sam", "Tom", "Ben"]
while names:            # loops while the list is non-empty (an empty list is "falsy")
    print(names.pop())  # pop() removes AND returns the last item, so the list shrinks each turn

# Concept-01: A for loop runs the block once for each item, no counter needed
# Question: How do we print every item in the list [70, 95, 60, 88], without a counter? (a for loop hands you one item per turn and stops when they run out)
scores = [70, 95, 60, 88]
for score in scores:
    print(score)

# Concept-02: A for loop works on ANY sequence, even the letters of a string
# Question: How do we look at the word "PYTHON" one letter at a time? (a string is a sequence too, so a for loop reads it character by character)
for letter in "PYTHON":
    print(letter)

# Concept-03: A for loop reads a tuple the same way
# Question: How do we go through the values in the tuple (10, 20, 30) one by one?
point = (10, 20, 30)
for value in point:
    print(value)

# Concept-04: Build a running total by adding each item into an accumulator
# Question: How do we add up all the numbers in the list [70, 95, 60, 88] into one total? (the same accumulator as the while loop, with no counter to manage)
scores = [70, 95, 60, 88]
total = 0
for score in scores:
    total += score        # add this score onto the running total
print("total:", total)     # 313

# Concept-05: Put an if inside the for loop to count only the items that match
# Question: How many of the numbers [70, 95, 60, 88] are 80 or above? (count up by 1 only when the test is True)
scores = [70, 95, 60, 88]
passed = 0
for score in scores:
    if score >= 80:        # 80 itself counts, because >= includes the boundary
        passed += 1
print("80 or above:", passed)   # 2

# Concept-06: Unpack a tuple right in the for header (for a, b in list_of_pairs)
# Question: How do we pair each name with its score in one loop, given [("Sam", 70), ("Tom", 95), ("Ben", 60)]?
pairs = [("Sam", 70), ("Tom", 95), ("Ben", 60)]
for name, score in pairs:  # each item is a (name, score) tuple, split into two variables
    print(name, score)

# Concept-07: for vs while - reach for "for" when you already have the items
# Question: We can print the same list ["Sam", "Tom", "Ben"] both ways - which reads cleaner when the list is already in hand? (for when you have the items, while when you loop until a condition)
names = ["Sam", "Tom", "Ben"]
# E1 (for): for-each, no index or counter to manage
for name in names:
    print(name)
# E2 (while): you manage the index i and the stop yourself
i = 0
while i < len(names):
    print(names[i])
    i += 1

# Concept-01: range(n) gives the numbers 0 up to n-1, so it repeats an action n times
# Question: How do we repeat an action 5 times, counting 0 to 4? (range(n) runs n times, counting 0..n-1)
for i in range(5):
    print(i)

# Concept-02: range(start, stop) starts where you say and stops BEFORE the stop value
# Question: How do we count from 2 up to 5, leaving out the stop value 6? (range(start, stop) leaves the stop out)
for n in range(2, 6):
    print(n)

# Concept-03: range(start, stop, step) jumps by the step you give
# Question: How do we list only the even numbers from 0 to 10? (a step of 2 skips the odd ones)
for n in range(0, 11, 2):
    print(n)

# Concept-04: A negative step counts DOWN instead of up
# Question: How do we count down 5, 4, 3, 2, 1 without a while loop? (a step of -1 walks backward)
for i in range(5, 0, -1):
    print(i)
print("Done")

# Concept-05: Pair range with an accumulator to add up a run of numbers
# Question: How do we add up the numbers 1 to 10 into one total? (add each number into one total)
total = 0
for n in range(1, 11):
    total += n
print("total:", total)   # 55

# Concept-06: range is lazy, so wrap it in list() to see the numbers it will produce
# Question: How do we see the exact numbers range(1, 6) will produce? (printing the range shows range(1, 6); list() shows the numbers)
# E1: printing the range itself just shows range(1, 6) - it has not built the numbers yet (lazy)
print(range(1, 6))
# E2: list() forces it to produce the numbers, so now you can see them
nums = list(range(1, 6))
print(nums)

# Concept-01: break stops the loop early; leave as soon as you are done
# Question: How do we stop as soon as we find the first score of 90 or above in [70, 95, 60, 88]? (break exits the loop right away)
# E1: no break - the loop announces the answer and then keeps checking the rest anyway
scores = [70, 95, 60, 88]
for score in scores:
    if score >= 90:
        print("first 90+:", score)
    print("still checking:", score)   # 95 is "still checking" right after we found it
# E2: break leaves the loop on the line that found the answer
scores = [70, 95, 60, 88]
for score in scores:
    if score >= 90:
        print("first 90+:", score)
        break
    print("still checking:", score)
print("done checking")

# Concept-02: break also exits a while True loop - the SAME search as Concept-01, now without a for
# Question: How do we find the first score of 90 or above in [70, 95, 60, 88] again, this time with a while True loop? (while True never ends on its own, so break is the only way out)
# E1: the older trick is a FLAG - but it only stops the loop at the NEXT trip to the top
scores = [70, 95, 60, 88]
i = 0
running = True
while running:
    if scores[i] >= 90:
        print("first 90+:", scores[i])
        running = False
    print("still checking:", scores[i])   # 95 is reported as "still checking" AFTER we found it
    i += 1
# E2: break leaves on the line that found it, so the turn really does stop
# CAREFUL: a while True that walks an index MUST be sure to find its match. With no 90+ score in
# the list, scores[i] would run past the end and raise IndexError - guaranteeing the exit is YOUR job.
scores = [70, 95, 60, 88]
i = 0
while True:
    if scores[i] >= 90:
        print("first 90+:", scores[i])
        break
    print("still checking:", scores[i])
    i += 1
print("done checking")

# Concept-03: continue skips the rest of THIS turn and jumps to the next item
# Question: How do we skip "Tom" but still give chocolate to every other name in ["Sam", "Tom", "Ben"]? (continue jumps to the next turn without leaving the loop)
# E1: no continue - we announce the skip, then hand Tom a chocolate anyway
names = ["Sam", "Tom", "Ben"]
for name in names:
    if name == "Tom":
        print("skipping", name)
    print("Give chocolate to:", name)
# E2: continue ends THIS turn, so the print below is never reached for Tom
names = ["Sam", "Tom", "Ben"]
for name in names:
    if name == "Tom":
        print("skipping", name)
        continue
    print("Give chocolate to:", name)
print("done")

# Concept-04: continue guards a loop by skipping bad values before the real work
# Question: How do we add up only the scores of 80 or above in [70, 95, 60, 88] and skip the rest? (continue past the low ones so the total stays clean)
scores = [70, 95, 60, 88]
total = 0
for score in scores:
    if score < 80:
        print("skipping low score:", score)   # without this line you never SEE the guard work
        continue
    total += score
print("total of 80+:", total)

# Concept-05: continue works inside a while loop too - but move the counter FIRST or it loops forever
# Question: How do we print the odd numbers 1 to 7 and skip the even ones with a while loop? (bump the counter before continue, or the skip freezes the loop)
# E1: counter AFTER the continue - the skip jumps back to the top with n unchanged, so the same
# even number is tested forever. This HANGS. Never uncomment it; Ctrl+C stops a runaway loop.
# n = 0
# while n < 7:
#     if n % 2 == 0:
#         continue      # n never moves, so this same even n is tested again, and again...
#     print("odd:", n)
#     n += 1
# E2: counter FIRST, so every turn moves n on before the skip can happen
n = 0
while n < 7:
    n += 1
    if n % 2 == 0:
        continue
    print("odd:", n)
print("done")

# Concept-06: pass is a do-nothing placeholder; the turn CARRIES ON, which is what makes it different from continue
# Question: How do we leave one branch empty on purpose, and still finish the rest of that turn? (pass does nothing and falls through; continue would jump to the next name)
# E1: an empty branch is not allowed - Python needs at least one line inside every block, so this
# file would not even start: IndentationError: expected an indented block after 'if' statement
# names = ["Sam", "Tom", "Ben"]
# for name in names:
#     if name == "Tom":
#     else:
#         print("greet", name)
# E2: pass fills the branch, and the turn carries on to the line below
names = ["Sam", "Tom", "Ben"]
for name in names:
    if name == "Tom":
        pass    # nothing special for Tom yet - fill this in later
    else:
        print("greet", name)
    print("logged", name)  # runs for EVERY name, Tom included - a continue here would have skipped it
print("done")

# Concept-07: A for loop can carry an else; it runs ONLY if the loop finished without break
# Question: How do we tell "Amy" was NOT in the list ["Sam", "Tom", "Ben"] after checking every name? (the else fires only because break never fired - the "searched all, found none" case)
# E1: the older way - track it with a flag. It works, but the flag is one more thing to keep in
# step: forget the found = True line and it reports "not found" for a name that IS in the list.
names = ["Sam", "Tom", "Ben"]
found = False
for name in names:
    if name == "Amy":
        found = True
        break
if not found:
    print("Amy is not in the list")
# E2: for ... else - the loop tracks it for you, and there is no flag to forget
names = ["Sam", "Tom", "Ben"]
for name in names:
    if name == "Amy":
        print("found Amy")
        break
else:
    print("Amy is not in the list")

# Concept-08: The same for else is SKIPPED when break fires - proving the rule
# Question: How do we see that finding "Sam" in ["Sam", "Tom", "Ben"] and breaking makes the else stay silent? (break fired, so the else block is skipped)
# This is Concept-07's second example with ONE name changed, "Amy" -> "Sam". Amy was never in the
# list so the break never fired and the else ran; Sam IS in it, so the break fires and the else is skipped.
names = ["Sam", "Tom", "Ben"]
for name in names:
    if name == "Sam":
        print("found Sam")
        break
else:
    print("Sam is not in the list")

# Concept-09: else works on a while loop too - it runs only if the while ended without break
# Question: How do we tell a countdown from 3 that finished on its own from one that a break cut short at n == 2? (the while else runs after a natural finish, but a break skips it)
# E1: the break is RIGHT THERE, but a countdown from 3 never reaches 4, so it never fires
# and the else runs. The else depends on whether break FIRED, not on whether break EXISTS.
n = 3
while n >= 1:
    if n == 4:
        print("stopped early")
        break
    print("countdown", n)
    n -= 1
else:
    print("finished on its own")

# E2: the SAME code with ONE number changed - n does reach 2, so the break fires and the else is SKIPPED
n = 3
while n >= 1:
    if n == 2:
        print("stopped early")
        break
    print("countdown", n)
    n -= 1
else:
    print("finished on its own")

# Concept-01: enumerate gives the position AND the item together (default start 0)
# Question: How do we number the list ["Sam", "Tom", "Ben"] the computer's way, like "0 Sam, 1 Tom"? (enumerate hands you the position, so you keep no counter of your own)
names = ["Sam", "Tom", "Ben"]
# E1: the long way - keep your own counter and remember to move it on every turn
index = 0
for name in names:
    print(index, name)
    index += 1     # forget this line and every row reports position 0
# E2: the SAME result from enumerate, with no counter to keep and none to forget
for index, name in enumerate(names):
    print(index, name)

# Concept-02: enumerate can start the count at 1, for a numbered list people read
# Question: How do we print a numbered list people can read, like "1. Sam"? (enumerate(names, start=1) begins the count at 1 instead of 0)
names = ["Sam", "Tom", "Ben"]
for position, name in enumerate(names, start=1):
    print(f"{position}. {name}")

# Concept-03: Looping a dictionary gives you its keys, in the order they were added
# Question: How do we read the field names off the record {"name": "Sam", "age": 20, "city": "Delhi"}, one per turn? (looping a dict gives you its KEYS by default)
student = {"name": "Sam", "age": 20, "city": "Delhi"}
for field in student:   # same as: for field in student.keys()
    print(field)  # a dict loops in insertion order, so this output is always the same
# Do NOT add or delete keys while looping a dict; loop student.copy() if you must change it while looping.
# Uncomment to see the trap - changing the dict mid-loop stops it dead:
# for field in student:
#     student["extra"] = 1   # RuntimeError: dictionary changed size during iteration

# Concept-04: .items() gives the key AND the value together
# Question: How do we print each field of {"name": "Sam", "age": 20, "city": "Delhi"} with its value, like "name -> Sam"? (.items() hands you the key and the value together)
student = {"name": "Sam", "age": 20, "city": "Delhi"}
for field, value in student.items():
    print(field, "->", value)

# Concept-05: Add up a dictionary's values with a running total
# Question: How do we add up all the scores in the name-to-score dictionary {"Sam": 70, "Tom": 95, "Ben": 60}? (.values() gives just the values, so the keys are never touched)
scores_by_name = {"Sam": 70, "Tom": 95, "Ben": 60}
total = 0
for score in scores_by_name.values():
    total += score
print("total:", total)

# Concept-06: zip() pairs up two lists, position by position, so loop them side by side
# Question: How do we line up each name in ["Sam", "Tom", "Ben"] with its score in [70, 95, 60], side by side? (zip pairs two lists and stops at the shorter one)
# E1: the everyday use - two lists of the same length, paired position by position
names = ["Sam", "Tom", "Ben"]
scores = [70, 95, 60]
for name, score in zip(names, scores):
    print(f"{name}: {score}")
# E2: one score short - zip stops at the SHORTER list, so Ben is never reached
names = ["Sam", "Tom", "Ben"]
scores = [70, 95]
for name, score in zip(names, scores):
    print(f"{name}: {score}")
print("Ben never appears - zip stopped when the scores ran out")

# Concept-01: A loop inside a loop; the inner loop runs fully on every outer turn
# Question: How do we visit every value in the list of lists [[10, 20, 30], [40, 50, 60], [70, 80, 90]], row by row? (the outer loop hands you a whole row, the inner loop walks the numbers inside it)
numbers = [
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
]
# E1: without nesting - one loop per row, so you write the same loop again for every row
for number in numbers[0]:
    print(number)
for number in numbers[1]:
    print(number)
for number in numbers[2]:
    print(number)
# E2: the outer loop on its own - each turn hands you one ROW, which is itself a list
for row in numbers:
    print(row)
# E3: add the inner loop - it walks that row's numbers before the outer loop moves on
for row in numbers:
    print(row)
    for number in row:
        print(number)      # the inner loop finishes completely before the outer loop takes the next row

# Concept-02: Pair every item of one list with every item of another; the total pairs are len(first_list) * len(second_list)
# Question-1: How do we make every pair from the lists ["A", "B"] and [1, 2, 3]?
# (Each item of the first list is paired with every item of the second list.)
# Question-2: How many pairs are there?
# (The total pairs are len(first_list) * len(second_list).)
letters = ["A", "B"]
numbers = [1, 2, 3]

for letter in letters:
    for number in numbers:
        print(letter, number)

print("Total pairs:", len(letters) * len(numbers))   # 2 x 3 = 6

# Concept-03: Nested range() loops build a multiplication table.
# Question: How do we build the 1 to 3 multiplication tables?
# (For each row, print the table from 1 to 10.)
for row in range(1, 4):
    print(f"\n--- Table of {row} ---")
    for column in range(1, 11):
        print(f"{row} x {column} = {row * column}")

# Concept-04: break stops only the INNERMOST loop, so the outer loop keeps going
# Question: When we break inside the inner loop, does the whole thing stop or just that pass?
# (Only the inner loop stops; the outer loop continues.)
# E1: No break - the inner loop runs fully for every outer loop iteration
for row in range(1, 3):
    print(f"\nStarting row {row}")
    for col in range(1, 4):
        print(f"{row}-{col}")
# E2: break in the INNER loop at column 2
# Only the inner loop stops; the outer loop still moves to the next row.
for row in range(1, 3):
    print(f"\nStarting row {row}")
    for col in range(1, 4):
        if col == 2:
            break
        print(f"{row}-{col}")

# Concept-05: continue inside the inner loop skips one inner item and keeps going
# Question: How do we skip one inner item on every outer turn but keep the loop going?
# (continue skips only the current inner loop iteration.)
# E1: No continue - every inner item prints
for row in range(1, 3):
    print(f"\nStarting row {row}")
    for col in range(1, 4):
        print(f"{row}-{col}")
# E2: continue skips column 2 on every row, but the inner loop keeps going
for row in range(1, 3):
    print(f"\nStarting row {row}")
    for col in range(1, 4):
        if col == 2:
            continue
        print(f"{row}-{col}")

# Concept-01: A list comprehension builds a new list in one line:
# [expression for item in collection]
# Question: How do we double every score in [10, 20, 30, 40]
# without writing a longer for loop?
scores = [10, 20, 30, 40]

# E1: The long way - build the list step by step
doubled = []
for n in scores:
    doubled.append(n * 2)
print(doubled)

# E2: The same result with a one-line comprehension
# Read it as: "n * 2 for each n in scores"
doubled = [n * 2 for n in scores]
print(doubled)

# E3: The collection does not have to be a list
# A range() works exactly the same way
squares = [n * n for n in range(1, 6)]
print(squares)

# Concept-02: Add an if at the end to keep only items that pass a test: [expr for item in collection if test]
# Question: How do we keep only the passing scores (80 or more) in [70, 95, 88, 88] in one line? (>= includes 80)
scores = [70, 95, 88, 88]
passing = [n for n in scores if n >= 80]
print(passing)

# Concept-03: A dict comprehension builds a dictionary in one line:
# {key: value for item in collection}
# Question: How do we map each score in [10, 20, 30, 40]
# to its double in one line?
scores = [10, 20, 30, 40]

score_map = {score: score * 2 for score in scores}
print(score_map)

# Concept-04: Add an if to a dict comprehension to keep only the items that pass a test:
# {key: value for item in collection if condition}
# Question: How do we build a dictionary for only the passing scores (20 or more)
# from [10, 20, 30, 40] in one line?
scores = [10, 20, 30, 40]

passing_map = {score: score * 2 for score in scores if score >= 20}
print(passing_map)

# Concept-05: A set comprehension builds a set in one line and removes duplicates:
# {expression for item in collection}
# Question: How do we keep only the distinct scores from [70, 95, 88, 88]?
# (A set keeps each value only once.)
scores = [70, 95, 88, 88]

unique_scores = {score for score in scores}
print(sorted(unique_scores))   # Sort only for display because sets have no fixed order.

# Concept-06: Use if/else inside a comprehension to choose between two values:
# [value_if_true if condition else value_if_false for item in collection]
# Question: How do we label each score in [70, 95, 80, 65, 55, 89] as "pass" or "fail"
# - first as a list of labels, then as a dictionary that keeps each score with its label?
# (80 or more passes.)
scores = [70, 95, 80, 65, 55, 89]
print(scores)

# A LIST comprehension gives you the labels on their own
labels = ["pass" if score >= 80 else "fail" for score in scores]
print(labels)

# A DICT comprehension keeps each score WITH its label; the same if/else works here
result_map = {score: "pass" if score >= 80 else "fail" for score in scores}
print(result_map)

# map() and filter() can solve similar problems.
# This course focuses on comprehensions because they clearly show
# the collection being built in a single expression.