Python foreach equivalent

Collection types: Lists, Tuples, Dictionaries

Looping Lists and Tuples

For lists and tuples, it's as easy as a walk in the park:

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit) # Even fruits get their 15 seconds of fame!


The loop goes through each fruit in the fruits list.

Sail through Dictionaries

When dealing with dictionaries, we use the .items() function:

fruit_colors = {'apple': 'red', 'banana': 'yellow', 'cherry': 'red'}
for fruit, color in fruit_colors.items():
    print(f"{fruit} is {color}") # Betcha can't guess these fruit colors!


This will let us access both the keys (fruit) and the values (color).

Indexing: Position matters

To get both the index and the value, use enumerate:

for index, fruit in enumerate(fruits):
    print(f"Fruit number {index} is a {fruit}") # Some fruits are more equal than others


Looping over Indices

Use range() with len() for when indices fall into play:

for i in range(len(fruits)):
    print(fruits[i]) # Dial I for 'index'!


Superpower your loops: Advanced techniques

Build your own forEach method

With a bit of wizardry, you can add a forEach method to your lists:

class CustomList(list):
    def forEach(self, action):
        for item in self:
            action(item) # This is my favorite trick!

my_list = CustomList(['apple', 'banana', 'cherry'])
my_list.forEach(print)


Prevent mutations with Clones

To avoid causing havoc by modifying a list while it's being iterated, go for a copy.

for fruit in fruits[:]:
    # Sulfa...umm...safe removal of item
    if condition_to_remove(fruit):
        fruits.remove(fruit)


Or iterate over a dictionary using .items(), which returns a safe copy of the key-value pairs.

Functions to simplify operations

To make your for loop clean and tidy, house your complex operations in a function:

def process_fruit(fruit):
    # Complex operations - where the magic happens
    pass

for fruit in fruit:
    process_fruit(fruit)


The Map-Reduce-Filter magic

Embrace map(), reduce(), and filter() for a more functional approach:

# Map: Apply a function to each element
fruit_uppers = map(str.upper, fruits)

# Filter: Retains elements that satisfy a condition
red_fruits = filter(lambda fruit: fruit_colors[fruit] == 'red', fruit_colors.keys())

# Reduce: Squeeze all elements to a single Bartlett pear...err...pair!
from functools import reduce
fruit_sentence = reduce(lambda acc, fruit: acc + ' ' + fruit, fruits)


Tips, Tricks and Traps

List comprehensions: A slick move

List comprehensions can combine for loops and if conditions into one efficient line:

fruits_starting_with_a = [fruit for fruit in fruits if fruit.startswith('a')]


Efficiency with itertools

Python's itertools module is your ally in writing efficient loops:

import itertools

# Infinite looping with 'cycle'
looping_colors = itertools.cycle(['red', 'green', 'blue'])

# Loop with accumulated results using 'accumulate'
sum_until_n = itertools.accumulate(range(10))


Generators: Large data, small memory

Generators provide memory friendly alternatives to handle large data sets:

def generate_numbers():
    for i in [1, 2, 3, 4, 5]:
        yield i # Generously, I yield!

for number in generate_numbers():
    print(number) # Print numbers, like a boss!


Common pitfalls

Changes during a loop

Altering a list while looping through it can sometimes cause unanticipated results – it's like changing the track of a running train!

Python 2 <> Python 3

Python 3's range() is superior in performance to Python 2's xrange(). Good to know if you're time-traveling between versions.

Looping within loops

Nested loops could cause performance issues faster than you can say "Inception"!

for pet in pets:
    for toy in pet_toys:
        print(f"{pet} loves {toy}")
# Could be a pet peeve for performance


Best practices

Clarity over cleverness

Readable code is always a winner over clever, abstruse code.

Test with variety

Ensure that your looping logic is compatible with all types of iterables.

Alignment with PEP 8

Whether it's for a project or personal use, being consistent and following Python's PEP 8 guidelines goes a long way.