loops pt2

Author: karlsoderby

content/micropython/03.micropython/01.basics/02. loops/loops.md

@@ -55,26 +55,24 @@ MicroPython is officially supported on several Arduino boards. Here’s a list o
 
 MicroPython supports two primary loop structures, each with a specific purpose:
 
-- **`for` loops**: These loops iterate over a predefined sequence, such as a list, tuple, or string. The loop automatically retrieves each item in the sequence, one at a time, and performs actions until every item has been handled.
+- **`for` loops**: for loops iterate over a predefined sequence, such as a list, tuple, or string. The loop automatically retrieves each item in the sequence, one at a time, and performs actions until every item has been handled.
 
-- **`while` loops**: These loops continue executing as long as a specified condition is true. Unlike `for` loops, which depend on a sequence, `while` loops rely on a conditional expression that determines when the loop should stop.
+- **`while` loops**: while loops continue executing as long as a specified condition is true. Unlike `for` loops, which depend on a sequence, `while` loops rely on a conditional expression that determines when the loop should stop.
 
 To better understand these loops, let’s imagine them as tasks at the supermarket:
 
-- **`for` loops**: Imagine walking down a supermarket aisle with a shopping list that specifies exactly how many items to pick up, one by one, in order. Once you’ve gathered all the items on your list, your task is complete. This is like a `for` loop iterating over a sequence, handling each specified item one at a time.
+- **for loops** - imagine walking down a supermarket aisle with a shopping list that specifies exactly how many items to pick up, one by one, in order. Once you’ve gathered all the items on your list, your task is complete. This is like a `for` loop iterating over a sequence, handling each specified item one at a time.
 
 ![How for loops work.]()
 
-- **`while` loops**: Imagine going to the supermarket to buy a certain product that’s on sale, as long as it stays in stock. You keep coming back, day after day, until the sale ends or the stock runs out. In a `while` loop, you keep “coming back” as long as a condition (like the sale continuing) remains true.
+- **while loops** - imagine going to the supermarket to buy a certain product that’s on sale, as long as it stays in stock. You keep coming back, day after day, until the sale ends or the stock runs out. In a `while` loop, you keep “coming back” as long as a condition (like the sale continuing) remains true.
 
 ![How while loops work.]()
 
 ## For Loops
 
 The `for` loop is used for iterating over a sequence. It automatically retrieves each item in the sequence one after another.
 
-### Syntax
-
 ```python
 for variable in sequence:
     # Code block to execute
@@ -86,35 +84,31 @@ for variable in sequence:
 - **`sequence`**: The collection (like a list, tuple, or string) over which the loop iterates.
 - **Code block**: The indented block of code that runs on each iteration.
 
-### Example: Iterating Over "Arduino" with a `for` Loop
+### Example Code
 
-```python
-import time
+Let's try out making a for loop. In this example, we set `i` which stands for *iteration*, in a range of 5.
 
-cycle = 1
-for letter in "Arduino":
-    print(f"{cycle} - {letter} - printed with for loop")
-    cycle += 1
-    time.sleep(3)
+```python
+for i in range(5):
+    print(i)
 ```
 
-Let's take a look at what's included in this code example:
-
-- `import time` - we import the `time` module to use the `sleep()` function for delays.
-- **Initialize `cycle` Variable**: We start a `cycle` counter at 1.
-- **`for letter in "Arduino"`**: The loop iterates over each character in the string `"Arduino"`, assigning each character to the variable `letter`.
-- **Print Statement**: Outputs the cycle number, the current letter, and mentions that it's printed with a `for` loop.
-- **Increment `cycle`**: Increases the cycle counter by 1 after each iteration.
-- **`time.sleep(3)`**: Pauses the program for 3 seconds before the next iteration.
+Running this script will result in printing `i` for five times. Each time the loop is run, `i` is increased, so in the REPL, we should see:
 
+```
+0
+1
+2
+3
+4
+```
 
+This is because we start counting from 0. So the first time the loop runs, we print `0`, the second time it runs `1` and so on.
 
-## Using a `while` Loop
+## While Loops
 
 A `while` loop continues to execute as long as a specified condition is true.
 
-### Syntax of a `while` Loop
-
 ```python
 while condition:
     # Code block to execute
@@ -124,34 +118,35 @@ while condition:
 - **`condition`**: A boolean expression evaluated before each iteration; if `True`, the loop continues.
 - **Code block**: The indented block of code that runs on each iteration.
 
-### Example: Iterating Over "Arduino" with a `while` Loop
+### Example Code
+
+Let's try making a while loop! In the example below, we have a counter, which we print to the REPL. This is to track how many times the loop has run. We pause between each print using the `time.sleep(1)` function, so that it is easier to read in the REPL.
 
 ```python
 import time
+counter = 0
 
-word = "Arduino"
-index = 0
-cycle = 1
-
-while index < len(word):
-    letter = word[index]
-    print(f"{cycle} - {letter} - printed with while loop")
-    index += 1
-    cycle += 1
-    time.sleep(3)
+while True:
+    counter += 1
+    print('Number of iterations: ' + str(counter))
+    time.sleep(1)
 ```
 
-**Explanation:**
+In this example, we used:
+
+- `while True:` - this keeps a while loop running forever.
+- `print('Number of iterations: ' + str(counter))`, to print out the current iteration.
+- because we cannot mix numeric values with strings when using the `print()` function, we need to use `str(counter)` when printing to the REPL.
+
+The result will be an infinite loop, that will print the current iteration:
 
-- **Initialize Variables**:
-  - `word`: The string we're iterating over.
-  - `index`: Starts at 0, used to access each character in `word`.
-  - `cycle`: Counts the number of iterations.
-- **`while index < len(word)`**: The loop continues as long as `index` is less than the length of `word`.
-- **Retrieve Letter**: `letter = word[index]` gets the character at the current index.
-- **Print Statement**: Outputs the cycle number, the current letter, and mentions that it's printed with a `while` loop.
-- **Increment Counters**: Increases `index` and `cycle` by 1.
-- **`time.sleep(3)`**: Pauses the program for 3 seconds before the next iteration.
+```python
+Number of iterations: 10
+Number of iterations: 11
+Number of iterations: 12
+.....
+Number of iterations: 99999 # this loop has been running for a long time..
+```
 
 ## Control Statements
 
@@ -206,9 +201,9 @@ Running this script will result in:
 
 ## Conclusion
 
-Loops are essential for automating repetitive tasks in MicroPython. Understanding how to use different loop structures allows you to write more efficient and effective code. In these examples, we've demonstrated how to iterate over the string "Arduino" using various loop methods, printing each letter with a delay to observe the output in real time.
+Loops are essential for automating repetitive tasks in MicroPython. Understanding how to use different loop structures allows you to write more efficient and effective code. 
 
-**Try Modifying the Examples**
+In these examples, we've demonstrated how to create loops that can: 
+- Run *for* a specific amount of iterations (for loops)
+- Loops that can run *while* a condition is met (while loops)
 
-- **Different Strings**: Replace `"Arduino"` with another word to see how the loops handle different sequences.
-- **Additional Information**: Include more details in the print statement, such as the ASCII value of each letter.