For Loops & The Iteration Protocol

# The High-Level Way
colors = ["red", "green", "blue"]
for color in colors:
    print(color)

# What Python ACTUALLY does (The Low-Level Way)
colors = ["red", "green", "blue"]

# 1. Get the iterator
iterator = iter(colors)  # Calls colors.__iter__()

while True:
    try:
        # 2. Get the next item
        item = next(iterator)  # Calls iterator.__next__()
        print(item)
    except StopIteration:
        # 3. Handle the end of the loop
        break  # The loop finishes gracefully

# ✅ The Optimized Way (O(n))
set_b = set(list_b)       # O(n) to create set

common = []
for a in list_a:          # Runs 10,000 times
    if a in set_b:        # O(1) Instant Lookup!
        common.append(a)

# Total operations: ~15,000. 
# This runs instantly.

for user in users:
    if user.is_banned:
        # TODO: Implement ban logic later
        pass 
    else:
        email(user)

names = ["Alice", "Bob", "Charlie"]

# ❌ The Anti-Pattern (Manual Indexing)
for i in range(len(names)):
    print(f"{i + 1}: {names[i]}")

# ✅ The Pythonic Way (Enumerate)
# start=1 makes it human-readable (1-based index)
for i, name in enumerate(names, start=1):
    print(f"{i}: {name}")

names = ["Alice", "Bob"]
scores = [85, 92]

# ❌ The Anti-Pattern
for i in range(len(names)):
    print(f"{names[i]}: {scores[i]}")

# ✅ The Pythonic Way
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# Note: zip stops at the shortest list! 
# Use itertools.zip_longest if you need to keep going.

scores = {"Alice": 85, "Bob": 92}

# Just keys
for name in scores:
    print(name)

# Keys and Values
for name, score in scores.items():
    print(f"{name} scored {score}")

class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        # 1. Boilerplate: Return self
        return self

    def __next__(self):
        # 2. Logic: Return value or raise StopIteration
        if self.current <= 0:
            raise StopIteration
        
        value = self.current
        self.current -= 1
        return value

# Usage
# It works in a for loop automatically!
for num in Countdown(3):
    print(num)  # 3, 2, 1

numbers = [1, 2, 3, 4, 5]

# 1. The Standard Loop Way
squares = []
for n in numbers:
    squares.append(n * n)

# 2. The Comprehension Way
# [expression for item in iterable]
squares = [n * n for n in numbers]

# Get only even numbers
evens = [n for n in numbers if n % 2 == 0]

# Equivalent to:
# for n in numbers:
#     if n % 2 == 0:
#         evens.append(n)

import itertools

ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']

# ❌ Nested Loop Way
deck = []
for suit in suits:
    for rank in ranks:
        deck.append((rank, suit))

# ✅ The itertools Way
# cleaner, flat, and expresses intent better
deck = list(itertools.product(ranks, suits))

colors = ["Red", "Green", "Yellow"]
light = itertools.cycle(colors)

next(light) # Red
next(light) # Green
next(light) # Yellow
next(light) # Red (Starts over!)

list1 = range(1000)
list2 = range(1000)

# ❌ Bad (Creates 3rd list of 2000 items)
for i in list1 + list2: ...

# ✅ Good (Zero memory overhead)
for i in itertools.chain(list1, list2): ...

# List Comprehension (Eager)
# Creates a 100MB list in RAM instantly
squares_list = [x**2 for x in range(10000000)]

# Generator Expression (Lazy)
# Creates a generator object (48 bytes)
squares_gen = (x**2 for x in range(10000000))

# We can loop over it just the same!
for s in squares_gen:
    # process s...
    if s > 100: break

# ❌ Bad (Eager Pattern)
# Reads the ENTIRE file into a list of strings
with open("massive_log.txt") as f:
    lines = f.readlines() # 💥 Memory Error!
    for line in lines:
        process(line)

# ✅ Good (Lazy Pattern)
# The file object yields one line at a time
with open("massive_log.txt") as f:
    for line in f: # Reads line, processes, discards from memory
        process(line)

scores = [88, 50, 99, 70]

# ✅ Loop in ascending order
for score in sorted(scores):
    print(score) # 50, 70, 88, 99

# ✅ Loop in descending order
for score in sorted(scores, reverse=True):
    print(score)

# ⚠️ Note: sorted() creates a NEW list. It uses O(n) memory.

# ❌ Slice (Uses Extra Memory)
for item in large_list[::-1]: ...

# ✅ Iterator (Zero Memory Overhead)
for item in reversed(large_list): ...

# Get only valid users
users = [user1, None, user2, None]

# ❌ Manual Check
for u in users:
    if u is not None:
        process(u)

# ✅ Filter Iterator
for u in filter(None, users):
    process(u)

users = ["Active", "Banned", "Active", "Banned"]

# This works perfectly
for user in users[:]:
    if user == "Banned":
        users.remove(user)

print(users) # ["Active", "Active"]

users = ["Active", "Banned", "Active", "Banned"]

# Create a new list instead of fighting the old one
users = [u for u in users if u != "Banned"]

def my_enumerate(iterable, start=0):
    count = start
    for item in iterable:
        yield count, item  # Pause and return the pair
        count += 1

# Testing our version
colors = ["Red", "Blue"]
for i, color in my_enumerate(colors, 1):
    print(f"{i}: {color}")
    
# Output:
# 1: Red
# 2: Blue

import asyncio

async def fetch_data():
    # Simulate network delay
    for i in range(3):
        await asyncio.sleep(1) # Pause here
        yield f"Data chunk {i}"

async def main():
    # âš¡ The loop yields control while waiting
    async for chunk in fetch_data():
        print(chunk)

# Run the async loop
# asyncio.run(main())

# raw_data.csv content:
# id,name,score
# 1,Alice,85
# 2,Bob,90
# 3,Charlie,invalid
# 4,Dave,75

cleaned_data = []

with open("raw_data.csv") as f:
    # 1. Enumerate to track line numbers for error logs
    for line_num, line in enumerate(f, start=1):
        
        # 2. Guard Clause: Skip header or empty lines
        line = line.strip()
        if not line or line.startswith("id"):
            continue

        # 3. Unpacking
        parts = line.split(",")
        if len(parts) != 3:
            print(f"Error on line {line_num}: Bad format")
            continue
            
        user_id, name, score_str = parts

        # 4. Data Processing
        if not score_str.isdigit():
            print(f"Warning line {line_num}: Invalid score for {name}")
            continue
            
        # 5. Success! Add to valid list
        cleaned_data.append({
            "id": int(user_id),
            "name": name,
            "score": int(score_str)
        })

print(f"Successfully loaded {len(cleaned_data)} users.")