for Loops

The Mechanics of Iteration

At its core, a Python for loop functions by interacting with an object's internal iterator protocol. When you define a loop, Python calls the __iter__() method on the collection, obtaining an iterator object. It then repeatedly calls next() on that iterator to retrieve the next item, assigning it to the target variable before executing the block of code inside the loop. This process continues automatically until the iterator raises a StopIteration exception, which signals that no further elements remain. Understanding that the loop interacts with the iterator—not necessarily the original container—is crucial for writing performant code. This mechanism ensures that the loop is efficient and memory-conscious, as it fetches elements one at a time rather than loading an entire sequence into memory if a generator is used.

# Iterating over a list of server health statuses
server_statuses = ['online', 'offline', 'maintenance', 'online']

for status in server_statuses:
    # The loop fetches each string one by one until exhausted
    print(f"Current server status: {status}")

Iterating Over Numeric Sequences

While it may seem intuitive to think of loops as counting numbers, the range() function actually generates a sequence object that produces integers lazily. When you pass a range into a for loop, the loop consumes this sequence until the specified endpoint is reached. This is conceptually different from languages where you manually increment an index variable because the range handles its own internal state tracking. By using range(), you can control the start, stop, and step of your iteration, allowing for precise execution patterns. Because the object is lazy, creating a range of one million numbers does not consume significant memory; it merely calculates the next integer on demand. This makes range() the standard tool for cases where an action must be repeated a specific number of times.

# Repeating a data collection task 5 times
for i in range(5):
    # i starts at 0 and ends at 4
    print(f"Attempt {i + 1}: Connecting to database...")

Traversing Dictionaries

Dictionaries in Python are collections of key-value pairs, and iterating over them requires understanding that the default behavior targets the keys. When you perform a loop directly on a dictionary, Python yields each unique key in the order they were inserted. However, to access the associated data, you frequently need both the key and the value simultaneously. The items() method solves this by returning a view object that yields tuples containing both elements. Using tuple unpacking within the loop header allows you to assign these values to separate, descriptive variables in one clean step. This approach is superior to looking up keys inside the loop using square brackets, as it reduces the number of hashing operations required, leading to cleaner and more efficient code execution.

# Processing user configuration settings
user_config = {'theme': 'dark', 'notifications': True, 'volume': 85}

for setting, value in user_config.items():
    # Unpacking key and value directly in the loop
    print(f"Setting {setting} is currently set to: {value}")

Modifying Iteration with enumerate

Often, you need to track the position of an item while simultaneously accessing its value. While a beginner might use a counter variable and increment it manually, the enumerate() function provides an idiomatic and safer alternative. This function wraps an iterable and yields pairs consisting of the current index and the corresponding element. By keeping the counting logic internal to Python, you eliminate the possibility of off-by-one errors or forgetting to increment the counter within complex loop logic. This is particularly useful when you need to update a specific index in a list or print formatted logs that require item numbering. Because enumerate accepts a start argument, you can even begin your indexing at a number other than zero, further increasing its versatility.

# Adding ranks to a list of competition finalists
finalists = ['Alice', 'Bob', 'Charlie']

for rank, name in enumerate(finalists, start=1):
    # enumerate handles the index tracking for us
    print(f"Rank {rank}: {name}")

Control Flow within Loops

Inside a loop, you can further refine execution using the break and continue statements. The break statement immediately terminates the entire loop, jumping to the first line of code following the loop block. This is vital for search operations where you find the target and no longer need to process remaining elements. Conversely, the continue statement skips the remainder of the current iteration and forces the loop to move immediately to the next item. Additionally, Python provides a unique else clause for loops, which executes only if the loop finishes normally without encountering a break statement. This is an advanced feature that allows for cleaner logic when checking if a search condition was never met during the entire cycle of iteration.

# Filtering out restricted file types
files = ['script.py', 'image.png', 'notes.txt', 'data.csv']

for file in files:
    if file == 'notes.txt':
        continue  # Skip processing the text file
    if file == 'data.csv':
        break     # Stop entirely when reaching the data file
    print(f"Processing: {file}")

Interview questions

All Python interview questions →

Check yourself

Take the full Python quiz →