Advanced Control Flow

What if you have a billion numbers and want to process them one at a time without loading all of them into memory? Generators are lazy iterators that produce values on-demand. Instead of creating the entire list upfront, they generate each item only when you ask for it. Perfect for big data!

[x for x in range(1000000)]
Memory: ~8 MB (all items stored)
          

(x for x in range(1000000))
Memory: ~120 bytes (one item at a time)
          

Generator Expressions

# List comprehension: Creates entire list in memory
squares_list = [x ** 2 for x in range(1000000)]
print(type(squares_list))  # 

# Generator expression: Creates generator object (lazy)
squares_gen = (x ** 2 for x in range(1000000))
print(type(squares_gen))   # 

# Generators are iterable - use in loops or convert to list
for i, sq in enumerate(squares_gen):
    if i >= 5: break
    print(sq)  # Output: 0, 1, 4, 9, 16

Generator Functions with yield

# Generator function using yield
def countdown(n):
    print("Starting countdown!")
    while n > 0:
        yield n    # Pauses here, returns n
        n -= 1     # Resumes here on next iteration
    print("Blastoff!")

# Create generator object
counter = countdown(5)
print(next(counter))  # Output: Starting countdown! 5
print(next(counter))  # Output: 4
print(next(counter))  # Output: 3

# Generator expression inside sum()
total = sum(x ** 2 for x in range(1, 101))
# No need for extra parentheses when generator is only argument
# Computes each square on-demand, never stores 100 values

print(f"Sum of squares 1-100: {total}")
# Output: Sum of squares 1-100: 338350

def fibonacci():
    a, b = 0, 1      # Initialize first two numbers
    while True:      # Infinite generator
        yield a      # Yield current number
        a, b = b, a + b  # Compute next pair

# Get first 10 Fibonacci numbers
fib = fibonacci()
first_ten = [next(fib) for _ in range(10)]
# next() gets one value at a time
# Generator never runs out (infinite loop)

print(first_ten)  # Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

def read_lines(filepath):
    with open(filepath, 'r') as file:
        for line in file:          # Files are iterators too!
            stripped = line.strip()
            if stripped:           # Skip empty lines
                yield stripped     # Yield cleaned line

# Usage example (memory-efficient for huge files)
# for line in read_lines('huge_file.txt'):
#     process(line)  # Only one line in memory at a time

def numbers(n):
    for i in range(1, n + 1):
        yield i

def filter_evens(gen):
    for x in gen:
        if x % 2 == 0:
            yield x

def square(gen):
    for x in gen:
        yield x ** 2

# Chain generators together (lazy pipeline)
pipeline = square(filter_evens(numbers(100)))
# Nothing computed yet - all lazy!

result = [next(pipeline) for _ in range(5)]
# Only computes as many values as needed
print(result)  # Output: [4, 16, 36, 64, 100]

def read_errors(logfile):
    """Read only ERROR lines from huge log file"""
    with open(logfile) as f:
        for line in f:  # File is iterator!
            if 'ERROR' in line:
                yield line.strip()

# Process millions of lines without loading all into memory
for error in read_errors('server.log'):
    print(error)

def fetch_pages(api_url):
    """Fetch paginated API results lazily"""
    page = 1
    while True:
        response = requests.get(f"{api_url}?page={page}")
        data = response.json()
        if not data['results']:
            break
        yield from data['results']  # yield each item
        page += 1

# Stop early if we find what we need
for user in fetch_pages('/api/users'):
    if user['name'] == 'Alice':
        break  # No more pages fetched!

def prime_numbers():
    """Generate primes forever"""
    n = 2
    while True:
        if all(n % i != 0 for i in range(2, int(n**0.5)+1)):
            yield n
        n += 1

# Get first 10 primes
primes = prime_numbers()
first_10 = [next(primes) for _ in range(10)]
print(first_10)  # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

def clean(data):
    for item in data:
        yield item.strip().lower()

def filter_valid(data):
    for item in data:
        if item and not item.startswith('#'):
            yield item

# Chain transformations - each is lazy!
with open('data.txt') as f:
    pipeline = filter_valid(clean(f))
    for line in pipeline:
        process(line)

Ever wanted to assign a value and use it in the same expression? The walrus operator (:=) lets you do exactly that! Introduced in Python 3.8, it is called "walrus" because := looks like a walrus face turned sideways. It helps avoid redundant calculations and makes certain patterns more elegant.

n = len(data)
if n > 10:
    print(f"Got {n} items")
          

if (n := len(data)) > 10:
    print(f"Got {n} items")
          

Basic Usage

# Without walrus: compute twice or use extra line
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Bad: computes len() twice
if len(data) > 5:
    print(f"List has {len(data)} items")  # Redundant call

# Better with walrus: assign and use in one expression
if (n := len(data)) > 5:
    print(f"List has {n} items")  # n is available here

Common Use Cases

# Use case 1: While loops with assignment
while (line := input("Enter text (q to quit): ")) != "q":
    print(f"You entered: {line}")

# Use case 2: List comprehensions with expensive operations
import re
text = "Email: test@example.com and info@site.org"
# Only include matches that exist
emails = [m.group() for s in [text] if (m := re.search(r'\S+@\S+', s))]

# Use case 3: Avoid repeated function calls
data = [5, 12, 3, 18, 7, 25]
filtered = [y for x in data if (y := x * 2) > 10]
print(filtered)  # Output: [24, 36, 14, 50]

# Original code
items = [1, 2, 3, 4, 5]
if len(items) > 3:
    print(f"Too many: {len(items)} items")

# Using walrus operator
items = [1, 2, 3, 4, 5]
if (n := len(items)) > 3:
    print(f"Too many: {n} items")
# len() is computed once, stored in n
# n is used both in condition and print

# Output: Too many: 5 items

# Using walrus to avoid computing square twice
result = [sq for x in range(1, 11) if (sq := x ** 2) > 20]
# sq := x ** 2 computes and stores the square
# if sq > 20 filters using the stored value
# sq is used as the output (no recomputation)

print(result)  # Output: [25, 36, 49, 64, 81, 100]

import re

text = "Scores: 45, 82, 33, 91, 67, 12, 55"

# Find all numbers, filter those > 50
numbers = [
    num for match in re.finditer(r'\d+', text)
    if (num := int(match.group())) > 50
]
# match.group() gets the string match
# int() converts to number and stores in num
# Filter and output use the same num value

print(numbers)  # Output: [82, 91, 67, 55]

Sometimes you need to break out of a loop early, skip certain iterations, or know if a loop completed without interruption. Python provides break, continue, pass, and the unique else clause on loops for fine-grained control over iteration.

Break, Continue, and Pass

# break: Exit the loop immediately
for i in range(10):
    if i == 5:
        break           # Exit when i is 5
    print(i, end=" ")   # Output: 0 1 2 3 4

# continue: Skip to next iteration
for i in range(10):
    if i % 2 == 0:
        continue        # Skip even numbers
    print(i, end=" ")   # Output: 1 3 5 7 9

# pass: Do nothing (placeholder)
for i in range(5):
    if i == 2:
        pass            # Placeholder - does nothing
    print(i, end=" ")   # Output: 0 1 2 3 4

The Loop else Clause

# else runs when loop completes WITHOUT break
def find_prime(numbers):
    for n in numbers:
        if n < 2:
            continue
        for i in range(2, int(n ** 0.5) + 1):
            if n % i == 0:
                break           # Not prime, exit inner loop
        else:
            return n            # else runs = no break = prime found
    return None

print(find_prime([4, 6, 8, 9, 11, 12]))  # Output: 11

Nested Loop Control

# Break only exits the innermost loop
found = False
for i in range(5):
    for j in range(5):
        if i * j == 12:
            print(f"Found at ({i}, {j})")
            found = True
            break       # Only exits inner loop
    if found:
        break           # Need this to exit outer loop

# Alternative: Use a function with return
def find_product(target):
    for i in range(10):
        for j in range(10):
            if i * j == target:
                return (i, j)  # Exits both loops
    return None

print(find_product(12))  # Output: (2, 6)

def find_user(users, email):
    """Find user by email - stop when found"""
    for user in users:
        if user['email'] == email:
            return user  # Early exit!
    return None

# Or with for-else:
for user in users:
    if user['email'] == target:
        print(f"Found: {user['name']}")
        break
else:
    print("User not found")

def get_positive_number():
    """Keep asking until valid input"""
    while True:
        try:
            n = int(input("Enter positive number: "))
            if n <= 0:
                print("Must be positive!")
                continue  # Skip to next iteration
            return n  # Valid - exit loop
        except ValueError:
            print("Invalid number!")
            continue

def process_records(records):
    """Process valid records, skip invalid ones"""
    results = []
    for record in records:
        if not record.get('id'):
            continue  # Skip records without ID
        if record.get('status') == 'deleted':
            continue  # Skip deleted records
        # Only reach here for valid records
        results.append(transform(record))
    return results

def fetch_with_retry(url, max_attempts=3):
    """Try API call with retries"""
    for attempt in range(1, max_attempts + 1):
        try:
            response = requests.get(url)
            response.raise_for_status()
            return response.json()  # Success - exit
        except RequestException:
            if attempt == max_attempts:
                raise  # Give up after max attempts
            time.sleep(2 ** attempt)  # Exponential backoff
            continue  # Try again

numbers = [1, 3, 5, 7, 8, 9, 10]
first_even = None

for num in numbers:
    if num % 2 == 0:
        first_even = num
        break  # Stop searching after finding first

print(f"First even: {first_even}")  # Output: First even: 8

numbers = [10, -5, 20, -3, 15, -8, 25]
total = 0

for num in numbers:
    if num < 0:
        continue  # Skip negative numbers
    total += num

print(f"Sum of positives: {total}")  # Output: Sum of positives: 70

def check_all_positive(numbers):
    for num in numbers:
        if num <= 0:
            print(f"Found non-positive: {num}")
            break  # Exit loop, skip else
    else:
        # Only runs if no break occurred
        print("All numbers are positive!")

check_all_positive([1, 2, 3, 4, 5])   # All positive!
check_all_positive([1, 2, -3, 4, 5]) # Found non-positive: -3

def find_in_grid(grid, target):
    for row_idx, row in enumerate(grid):
        for col_idx, val in enumerate(row):
            if val == target:
                return (row_idx, col_idx)  # Found! Exit both
    return None  # Not found after checking all

grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(find_in_grid(grid, 5))   # Output: (1, 1)
print(find_in_grid(grid, 10))  # Output: None