How to use nested loops practically?

That's an excellent follow-up question! Understanding how nested loops work is one thing, but applying them practically is where the real fun begins.

Nested loops are incredibly useful for tasks where you need to compare, combine, or process data that has a two-dimensional (or even higher) relationship. Here are a few practical scenarios where you'd commonly use nested loops:

1. Iterating Over 2D Data Structures (Matrices/Grids):
   Imagine you have a grid of data, like a spreadsheet or a game board. Nested loops are perfect for accessing each element.

   # Example: Printing a simple 2x3 matrix
   matrix = [
       [1, 2, 3],
       [4, 5, 6]
   ]
   
   for row in matrix: # Outer loop iterates through each row (which is a list itself)
       for element in row: # Inner loop iterates through each element in the current row
           print(element, end=" ") # end=" " prints elements on the same line, separated by space
       print() # Prints a new line after each row

   Output:

   1 2 3 
   4 5 6 

2. Generating Combinations or Permutations:
   When you need to pair up items from two different lists.

   # Example: Pairing clothes (shirts with pants)
   shirts = ["red shirt", "blue shirt"]
   pants = ["jeans", "khakis", "shorts"]
   
   print("Possible Outfits:")
   for shirt in shirts:
       for pant in pants:
           print(f"- {shirt} with {pant}")

   Output:

   Possible Outfits:
   - red shirt with jeans
   - red shirt with khakis
   - red shirt with shorts
   - blue shirt with jeans
   - blue shirt with khakis
   - blue shirt with shorts

3. Implementing Search Algorithms (e.g., finding pairs that sum to a target):
   If you need to check every possible pair within a single list.

   # Example: Find pairs of numbers that sum to 10
   numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
   target_sum = 10
   
   print(f"\nPairs that sum to {target_sum}:")
   for i in range(len(numbers)):
       for j in range(i + 1, len(numbers)): # Start inner loop from i+1 to avoid duplicate pairs and self-pairing
           if numbers[i] + numbers[j] == target_sum:
               print(f"({numbers[i]}, {numbers[j]})")

   Output:

   Pairs that sum to 10:
   (1, 9)
   (2, 8)
   (3, 7)
   (4, 6)

4. Prime Number Checks (as shown in the current step):
   The example you just saw uses nested loops to determine prime numbers:

   # Outer loop iterates through numbers to check
   for num in range(2, 10): 
       # Inner loop checks if 'num' is divisible by any number from 2 up to num-1
       for i in range(2, num):
           if num % i == 0: # If divisible, it's not prime
               # print(f"{num} is not prime") # This line was in the example
               break # Exit the inner loop (no need to check further divisors)
       else: # This 'else' belongs to the INNER loop, executes if inner loop completed without 'break'
           # print(f"{num} is prime") # This line was in the example
           pass # No print needed for this explanation

   Here, the inner loop's job is to exhaustively check for divisors for each number presented by the outer loop.

These are just a few common examples. Whenever you find yourself needing to perform an operation for "each item in X for each item in Y," or "each item in X compared against every other item in X," nested loops are often the solution!

Do any of these practical examples resonate with a problem you might be thinking about, or would you like to explore another use case?