What is the common pitfall with Writing C-Style Index Loops in Python?

Index-based access is slower and introduces unnecessary subscripting overhead. Exam trap note: Undergraduate coding interviews heavily penalize `for i in range(len(x)):` when `enumerate()` is appropriate.

What are the core concepts of Python For Loops & Range?

In Python 3, `range(start, stop, step)` does not generate a list of numbers in memory; it returns a lazy range object. Memory consumption of `range(1_000_000)` is O(1) constant 48 bytes because numbers are generated on demand during iteration.

← Previous: Python While Loops All Modules Next: Python Functions & Parameters →

MOD-15 · Sequence #15 · Control Flow

Python For Loops & Range

Python for loops are sequence iterators (equivalent to foreach in other languages). Instead of managing loop index variables, Python uses iterables, range generators, enumerate for index tracking, and zip for parallel iteration.

Live Interactive Code Snippet (Python 3.12 CPython WASM) Open in Practice Mode →

names = ["Alice", "Bob"]
for idx, name in enumerate(names, 1):
    print(f"{idx}: {name}")

Core Principles & Mental Models

1. The range() Lazy Sequence Generator

O(1) Memory Regardless of Size

In Python 3, `range(start, stop, step)` does not generate a list of numbers in memory; it returns a lazy range object.
Memory consumption of `range(1_000_000)` is O(1) constant 48 bytes because numbers are generated on demand during iteration.

import sys
r1 = range(10)
r2 = range(10_000_000)
print("Size of range(10):", sys.getsizeof(r1), "bytes")
print("Size of range(10M):", sys.getsizeof(r2), "bytes")

💡 Key Takeaway: range() produces numbers on demand with O(1) memory footprint.

2. Idiomatic Iteration: enumerate() and zip()

Eliminating Manual Index Variables

`enumerate(iterable, start=0)` yields (index, item) pairs, eliminating manual counter variables.
`zip(seq1, seq2)` iterates through multiple sequences in lockstep, terminating at the shortest sequence.

names = ["Alice", "Bob", "Charlie"]
scores = [95, 88, 92]

for i, (name, score) in enumerate(zip(names, scores), start=1):
    print(f"Rank {i}: {name} -> {score}")

💡 Key Takeaway: Never write `for i in range(len(lst)):` when `enumerate(lst)` is available.

Interactive Walkthrough Examples

Iterating Over Multiple Sequences in Parallel (Basic)

Using zip to aggregate student names, subjects, and test grades.

students = ["Alice", "Bob"]
subjects = ["Math", "Physics"]
grades = ["A", "B+"]

for s, sub, g in zip(students, subjects, grades):
    print(f"{s} got {g} in {sub}")

Explanation: zip aggregates elements from each iterable until the shortest iterable is exhausted.

Common Misconceptions & Exam Traps

Common Pitfall: Writing C-Style Index Loops in Python

Index-based access is slower and introduces unnecessary subscripting overhead.

Buggy Code

items = ["a", "b", "c"]
for i in range(len(items)):  # Unpythonic & error-prone
    print(i, items[i])

Correct Solution

items = ["a", "b", "c"]
for i, val in enumerate(items):  # Idiomatic Python
    print(i, val)

Exam Trap Note: Undergraduate coding interviews heavily penalize `for i in range(len(x)):` when `enumerate()` is appropriate.

Conceptual Knowledge Self-Check Quiz

Q1: What does `enumerate(["cat", "dog"], start=1)` yield on its first iteration?

("cat", 1)
(1, "cat")
[0, "cat"]
1

enumerate yields a tuple of `(index, element)`. With start=1, the first yield is `(1, "cat")`.

Algorithmic Practice Challenges

Idiomatic Best Practices

✅ Use `for item in collection:` to iterate directly over items.
✅ Use `for i, item in enumerate(collection):` when you need indices.
✅ Use `zip(strict=True)` in Python 3.10+ if sequences must have equal length.

← Python While Loops Take Assessed Test → Python Functions & Parameters →

All 26 Curriculum Modules

MOD-01: Python Syntax & Indentation — Whitespace blocks, execution statements, and semicolon absence in Python.
MOD-02: Python Comments — Single-line comments (#) and multiline docstrings.
MOD-03: Python Variables & Dynamic Binding — Variable creation, dynamic typing, unpacking, and multiple assignment.
MOD-04: Python Data Types — Built-in fundamental types: int, float, str, bool, list, tuple, dict, set, None.
MOD-05: Python Numbers & Type Casting — Int, float, complex numbers, and casting via int(), float(), str().
MOD-06: Python Strings & Slicing — String arrays, indexing [start:stop:step], negative indices, and string methods.
MOD-07: Python Booleans & Logical Evaluation — Boolean truth values, truthy vs falsy values, and logical operators.
MOD-08: Python Operators — Arithmetic, assignment, comparison, logical, identity (is), and membership (in).
MOD-09: Python Lists (Arrays) — Ordered, mutable sequences, indexing, append, insert, remove, pop, and list comprehensions.
MOD-10: Python Tuples — Ordered, immutable sequences, unpacking, and tuple hashing for dictionary keys.
MOD-11: Python Sets — Unordered, unindexed collections of unique elements; union, intersection, difference.
MOD-12: Python Dictionaries — Key-value associative mappings, keys(), values(), items(), and dict comprehensions.
MOD-13: Python If...Else & Branching — Conditional branching, elif ladder, nested conditions, and ternary conditional operators.
MOD-14: Python While Loops — Conditional loops, break, continue, and the while...else loop construct.
MOD-15: Python For Loops & Range — Sequence iteration, range(start, stop, step), enumerate(), and zip().
MOD-16: Python Functions & Parameters — def declarations, positional args, keyword args, *args, **kwargs, and return statements.
MOD-17: Python Lambda Functions — Anonymous inline functions, map(), filter(), and sorted(key=lambda).
MOD-18: Python Classes & Objects (OOP) — Class definition, the __init__ constructor, the self receiver, and instance methods.
MOD-19: Python Inheritance & Polymorphism — Subclassing, super() initializer, method overriding, and polymorphism.
MOD-20: Python Iterators & Generators — __iter__ and __next__ protocols, and generator functions with the yield keyword.
MOD-21: Python Scope & LEGB Rule — Local, Enclosing, Global, and Built-in namespaces; global and nonlocal keywords.
MOD-22: Python Modules & Packages — import, from ... import ..., as alias, dir() inspection, and __name__ == "__main__".
MOD-23: Python Dates & Math — datetime module (now, strftime, strptime) and math functions (pow, sqrt, ceil, floor).
MOD-24: Python JSON & Regular Expressions — json.loads(), json.dumps(), and the re module (search, findall, sub, split).
MOD-25: Python Try...Except & Error Handling — Exception catching with try, except, else, finally, and raising custom exceptions.
MOD-26: Python File Handling — File open modes ("r", "w", "a", "x"), with context manager, and os removal.