Exploring Nested Loops in Python

I trust you're as excited as I am to delve further into this intriguing topic. Having established a solid foundation with for and while loops, it is now time to elevate your understanding of these looping concepts by exploring nested loops. Nested loops enable us to tackle more complex situations and augment the power of our code.

Nested loops signify the placement of one loop inside another. These loops prove particularly useful when we need to address scenarios involving more than one sequence, or when the number of iterations depends on the data itself. The set-up could involve a for loop inside another for loop, a for loop inside a while loop, or a combination of for and while loops.

Consider the following example. Suppose you're planning a trip and desire to list the key sights in the countries you intend to visit.

# We might want to do some sightseeing in each country. For each country, we have a list of sights.
country_sights = {"France": ["Eiffel Tower", "Louvre Museum"],
                  "Italy": ["Colosseum", "Piazza San Marco"],
                  "Spain": ["Park Güell", "The Alhambra"],
                  "Japan": ["Mt. Fuji", "Fushimi Inari Taisha"]}

for country, sights in country_sights.items():
    print(f"***In {country}, I want to see:")
    for sight in sights:
        print(sight)

In this code snippet, we have a for loop that iterates over all countries, and within that loop, there is another for loop that cycles through all the sights for the current country. There you have it: a nested loop! Here is what you'd get if you run the code above:

***In France, I want to see:
Eiffel Tower
Louvre Museum
***In Italy, I want to see:
Colosseum
Piazza San Marco
***In Spain, I want to see:
Park Güell
The Alhambra
***In Japan, I want to see:
Mt. Fuji
Fushimi Inari Taisha

When working with nested loops, especially over collections containing mutable objects like dictionaries or lists, it is important to understand that the loop variable is a reference to the original object — not a copy. This means that any modifications you make to the loop variable will affect the original data in the collection.

Consider the following example, where we have a list of employee dictionaries and want to give everyone a raise:

employees = [{"name": "Alice", "salary": 50000},
             {"name": "Bob", "salary": 60000},
             {"name": "Charlie", "salary": 70000}]

for employee in employees:
    employee["salary"] += 5000  # This modifies the original dictionary!

print(employees)

Output:

[{'name': 'Alice', 'salary': 55000}, {'name': 'Bob', 'salary': 65000}, {'name': 'Charlie', 'salary': 75000}]

Notice that even though we only modified employee inside the loop, the original employees list reflects the changes. This is because employee is not a copy of each dictionary — it points to the same dictionary stored in the list. So modifying employee["salary"] is equivalent to modifying the actual dictionary in employees.

This behavior can be incredibly useful when you want to update data in place, but it can also lead to unintended bugs if you assume the loop variable is independent of the original collection. If you want to avoid modifying the original data, you can make an explicit copy:

import copy

for employee in employees:
    employee_copy = copy.copy(employee)  # Create a shallow copy
    employee_copy["salary"] += 5000      # Modifying the copy, not the original

Keep this concept in mind when iterating over collections of mutable objects — it will save you from many head-scratching moments down the road!