editing pass

Python/001_numbers.py

@@ -7,25 +7,20 @@
 
 import marimo
 
-__generated_with = "0.10.14"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
         # 🔢 Numbers in Python
 
-        Let's explore how Python handles numbers and mathematical operations! 
+        This tutorial provides a brief overview of working with numbers.
 
         ## Number Types
+
         Python has several types of numbers:
 
         ```python
@@ -104,11 +99,11 @@ def _(number):
 
 @app.cell
 def _(number):
-    number ** 2  # Exponentiation
+    number**2  # Exponentiation
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
@@ -134,7 +129,7 @@ def _(decimal_number):
 
 @app.cell
 def _(number):
-    float(number)  # Convert to float
+    float(number)  # Convert to "float" or decimal
     return
 
 
@@ -179,49 +174,72 @@ def _(mo):
         """
         ## Advanced Math Operations
 
-        For more complex mathematical operations, Python's `math` module is your friend:
+        For more complex mathematical operations, use Python's [math module](https://docs.python.org/3/library/math.html).
+        """
+    )
+    return
+
 
-        ```python
-        import math
+@app.cell
+def _():
+    import math
+    return (math,)
 
-        # Square root
-        math.sqrt(16)    # 4.0
 
-        # Trigonometry
-        math.sin(math.pi/2)  # 1.0
-        math.cos(0)      # 1.0
+@app.cell
+def _(math):
+    math.sqrt(16)
+    return
 
-        # Constants
-        math.pi          # 3.141592653589793
-        math.e           # 2.718281828459045
 
-        # Logarithms
-        math.log10(100)  # 2.0
-        math.log(math.e) # 1.0
-        ```
-        """
-    )
+@app.cell
+def _(math):
+    math.sin(math.pi/2)
+    return
+
+
+@app.cell
+def _(math):
+    math.cos(0)
+    return
+
+
+@app.cell
+def _(math):
+    math.pi, math.e
+    return
+
+
+@app.cell
+def _(math):
+    math.log10(100)
+    return
+
+
+@app.cell
+def _(math):
+    math.log(math.e)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    callout_text = mo.md("""
-    ## Master the Numbers!
-
-    Next Steps:
+    mo.md("""
+    ## Next Steps:
 
     - Practice different mathematical operations
-
     - Experiment with type conversions
-
     - Try out the math module functions
 
     Keep calculating! 🧮✨
     """)
+    return
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/002_strings.py

@@ -7,34 +7,38 @@
 
 import marimo
 
-__generated_with = "0.10.14"
-app = marimo.App()
-
-
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
+__generated_with = "0.10.19"
+app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 🔢 Numbers in Python
+        # 🎭 Strings
 
-        Let's explore how Python handles numbers and mathematical operations! 
+        This notebook introduces **strings**, which are containers for text.
 
-        ## Number Types
-        Python has several types of numbers:
+        ## Creating strings
+        Create strings by wrapping text in quotes:
 
         ```python
-        integer = 42          # whole numbers (int)
-        decimal = 3.14        # floating-point numbers (float)
-        complex_num = 2 + 3j  # complex numbers
+        # Use double quotes
+        greeting = "Hello, Python!"
+
+        # or single quotes
+        name = 'Alice'
+
+        # or triple quotes
+        multiline_string = \"""
+        Dear, Alice,
+        Nice to meet you.
+        Sincerely,
+        Bob.
+        \"""
         ```
 
-        Below is an example number we'll use to explore operations.
+        Below is an example string.
         """
     )
     return
@@ -42,79 +46,86 @@ def _(mo):
 
 @app.cell
 def _():
-    number = 42
-    return (number,)
+    text = "Python is amazing!"
+    text
+    return (text,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Basic Mathematical Operations
+        ## Essential string operations
 
-        Python supports all standard mathematical operations.
+        Here are some methods for working with strings.
 
-        Try changing the value of `number` above and watch how the results change.
+        Tip: Try changing the value of `text` above, and watch how the
+        computed values below change.
         """
     )
     return
 
 
 @app.cell
-def _(number):
-    number + 10  # Addition
+def _(text):
+    # the `len` method returns the number of characters in the string.
+    len(text)
     return
 
 
 @app.cell
-def _(number):
-    number - 5  # Subtraction
+def _(text):
+    text.upper()
     return
 
 
 @app.cell
-def _(number):
-    number * 3  # Multiplication
+def _(text):
+    text.lower()
     return
 
 
 @app.cell
-def _(number):
-    number / 2  # Division (always returns float)
+def _(text):
+    text.title()
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""Python also has special division operators and power operations.""")
+    mo.md("""Use string methods and the `in` operator to find things in strings.""")
     return
 
 
 @app.cell
-def _(number):
-    number // 5  # Floor division (rounds down)
+def _(text):
+    # Returns the index of "is" in the string
+    text.find("is")
     return
 
 
 @app.cell
-def _(number):
-    number % 5  # Modulus (remainder)
+def _(text):
+    "Python" in text
     return
 
 
 @app.cell
-def _(number):
-    number ** 2  # Exponentiation
+def _(text):
+    "Javascript" in text
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Type Conversion
+        ## Inserting values in strings
 
-        You can convert between different number types. Try changing these values!
+        Modern Python uses f-strings to insert values into strings. For example,
+        check out how the next cell greets you (and notice the `f''''`)!
+
+        **Try it!** Enter your name in `my_name` below, then run the cell.
         """
     )
     return
@@ -122,19 +133,13 @@ def _(mo):
 
 @app.cell
 def _():
-    decimal_number = 3.14
-    return (decimal_number,)
-
-
-@app.cell
-def _(decimal_number):
-    int(decimal_number)  # Convert to integer (truncates decimal part)
-    return
+    my_name = ""
+    return (my_name,)
 
 
 @app.cell
-def _(number):
-    float(number)  # Convert to float
+def _(my_name):
+    f"Hello, {my_name}!"
     return
 
 
@@ -142,86 +147,114 @@ def _(number):
 def _(mo):
     mo.md(
         """
-        ## Built-in Math Functions
-        Python provides many useful built-in functions for working with numbers:
+        ## Working with Parts of Strings
+        You can access any part of a string using its position (index):
         """
     )
     return
 
 
 @app.cell
-def _(number):
-    abs(-number)  # Absolute value
-    return
+def _(text):
+    first_letter = text[0]
+    first_letter
+    return (first_letter,)
 
 
 @app.cell
-def _():
-    round(3.14159, 2)  # Round to 2 decimal places
-    return
+def _(text):
+    last_letter = text[-1]
+    last_letter
+    return (last_letter,)
 
 
 @app.cell
-def _():
-    max(1, 5, 3, 7, 2)  # Find maximum value
-    return
+def _(text):
+    first_three = text[0:3]
+    first_three
+    return (first_three,)
 
 
 @app.cell
-def _():
-    min(1, 5, 3, 7, 2)  # Find minimum value
-    return
+def _(text):
+    last_two = text[-2:]
+    last_two
+    return (last_two,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Advanced Math Operations
+        ## Other helpful string methods
 
-        For more complex mathematical operations, Python's `math` module is your friend:
+        Finally, here are some other helpful string methods. Feel free to try them out on your own strings by modifying the value of `sentence` below.
+        """
+    )
+    return
 
-        ```python
-        import math
 
-        # Square root
-        math.sqrt(16)    # 4.0
+@app.cell
+def _():
+    sentence = "  python is fun  "
+    sentence
+    return (sentence,)
 
-        # Trigonometry
-        math.sin(math.pi/2)  # 1.0
-        math.cos(0)      # 1.0
 
-        # Constants
-        math.pi          # 3.141592653589793
-        math.e           # 2.718281828459045
+@app.cell
+def _(sentence):
+    # Remove extra spaces
+    sentence.strip()
+    return
 
-        # Logarithms
-        math.log10(100)  # 2.0
-        math.log(math.e) # 1.0
-        ```
-        """
-    )
+
+@app.cell
+def _(sentence):
+    # Split into a list of words
+    sentence.split()
     return
 
 
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Master the Numbers!
+@app.cell
+def _(sentence):
+    sentence.replace("fun", "awesome")
+    return
+
+
+@app.cell
+def _():
+    "123".isdigit(), "abc".isdigit()
+    return
+
+
+@app.cell
+def _():
+    "123".isalpha(), "abc".isalpha()
+    return
 
-    Next Steps:
 
-    - Practice different mathematical operations
+@app.cell
+def _():
+    "Python3".isalnum()
+    return
 
-    - Experiment with type conversions
 
-    - Try out the math module functions
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## Next steps
 
-    Keep calculating! 🧮✨
-    """)
+        For a full primer on strings, check out the [official documentation](https://docs.python.org/3/library/string.html).
+        """
+    )
+    return
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/003_collections.py

@@ -7,23 +7,17 @@
 
 import marimo
 
-__generated_with = "0.10.14"
-app = marimo.App()
-
-
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
+__generated_with = "0.10.19"
+app = marimo.App(width="medium")
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 📦 Collections in Python
+        # 📦 Collections
 
-        Explore Python's built-in collection types — the essential data structures! 
+        A "collection" is a type of variable that holds multiple values.
 
         ## Lists
         Lists are ordered, mutable sequences. Create them using square brackets:
@@ -31,7 +25,7 @@ def _(mo):
         ```python
         fruits = ["apple", "banana", "orange"]
         numbers = [1, 2, 3, 4, 5]
-        mixed = [1, "hello", 3.14, True]  # Can contain different types
+        mixed = [1, "hello", 3.14, True]
         ```
 
         Below is an example list we'll use to explore operations.
@@ -68,7 +62,7 @@ def _(sample_list):
 
 @app.cell
 def _(sample_list):
-    extended_list = sample_list + [6] # concatenate two lists
+    extended_list = sample_list + [6]  # Concatenate two lists
     extended_list
     return (extended_list,)
 
@@ -122,7 +116,6 @@ def _():
     tuple2 = (4, 5, 6)
 
     tuple3 = tuple1 + tuple2
-
     tuple3
     return tuple1, tuple2, tuple3
 
@@ -141,11 +134,7 @@ def _(mo):
 
 @app.cell
 def _():
-    person = {
-        "name": "John Doe",
-        "age": 25,
-        "city": "New York"
-    }
+    person = {"name": "John Doe", "age": 25, "city": "New York"}
     return (person,)
 
 
@@ -187,17 +176,14 @@ def _():
 
 @app.cell
 def _(numbers_set):
-    numbers_set.add(4)  # Add new element
-    numbers_set
+    numbers_set | {4}  # Add a new element
     return
 
 
 @app.cell
 def _():
-    set1 = {1, 2, 3}
-    set2 = {3, 4, 5}
-    set1.intersection(set2)  # Find common elements
-    return set1, set2
+    {1, 2, 3} & {3, 4, 5}  # Find common elements
+    return
 
 
 @app.cell(hide_code=True)
@@ -234,20 +220,20 @@ def _(mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    callout_text = mo.md("""
-    ## Collection Mastery Awaits!
-
-    Next Steps:
+    mo.md(
+        r"""
+        ## Documentation
 
-    - Practice list and dictionary comprehensions
-    - Experiment with nested collections
-    - Try combining different collection types
+        See the official [Python tutorial on data structures](https://docs.python.org/3/tutorial/datastructures.html) for more in-depth information.
+        """
+    )
+    return
 
-    Keep organizing data! 🗃️✨
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/004_conditional_logic.py

@@ -7,23 +7,18 @@
 
 import marimo
 
-__generated_with = "0.10.14"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
         # 🔄 Conditional Logic in Python
 
-        Learn how to make decisions in your code with Python's conditional statements!
+        This tutorial teaches you how to how to make **decisions** in your code, using
+        Python's conditional statements.
 
         ## If Statements
         The foundation of decision-making in Python:
@@ -41,21 +36,43 @@ def _(mo):
     return
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""**Try it!** Try changing the value of `42` below, and see how the output changes.""")
+    return
+
+
 @app.cell
 def _():
     number = 42
     return (number,)
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        Compare numbers using operators like
+
+        - `>`
+        - `>=`
+        - `<`
+        - `<=`
+        - `==`  (note the two equal signs!)
+        """
+    )
+    return
+
+
 @app.cell
-def _(number):
-    if number > 50:
-        result = "Greater than 50"
+def _(mo, number):
+    if number > 42:
+        result = "Greater than 42"
     elif number == 42:
-        result = "Found the answer!"
+        result = "Equal to 42!"
     else:
-        result = "Less than 50"
-    result
+        result = "Less than 42"
+    mo.md(result)
     return (result,)
 
 
@@ -63,27 +80,27 @@ def _(number):
 def _(mo):
     mo.md(
         r"""
-        ## Interactive Decision Making
-        Try changing the conditions below and see how the results change (powered by marimo's UI elements!):
+        ### Interactive Decision Making
+        **Try it!** Try changing the conditions below and see how the results change:
         """
     )
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo, threshold, value):
-    mo.hstack([value, threshold])
+    mo.hstack([value, threshold], justify="start")
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     value = mo.ui.number(value=25, start=0, stop=100, label="Enter a number")
     threshold = mo.ui.slider(value=50, start=0, stop=100, label="Set threshold")
     return threshold, value
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo, threshold, value):
     if value.value > threshold.value:
         decision = f"{value.value} is greater than {threshold.value}"
@@ -95,9 +112,11 @@ def _(mo, threshold, value):
     mo.hstack(
         [
             mo.md(f"**Decision**: {decision}"),
-            mo.md(f"**Condition Status**: {'✅' if value.value >= threshold.value else '❌'}")
+            mo.md(
+                f"**Threshold cleared?**: {'✅' if value.value >= threshold.value else '❌'}"
+            ),
         ],
-        justify="space-between"
+        justify="space-around",
     )
     return (decision,)
 
@@ -119,20 +138,31 @@ def _(mo):
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
+def _(mo):
+    _text = mo.md("""
+        - Try different combinations of age and ID status
+        - Notice how both conditions must be True to allow voting
+        - Experiment with edge cases (exactly 18, no ID, etc.)
+    """)
+    mo.accordion({"💡 Experiment Tips": _text})
+    return
+
+
+@app.cell(hide_code=True)
 def _(age, has_id, mo):
-    mo.hstack([age, has_id])
+    mo.hstack([age, has_id], justify="start")
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     age = mo.ui.number(value=18, start=0, stop=120, label="Age")
     has_id = mo.ui.switch(value=True, label="Has ID")
     return age, has_id
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(age, has_id, mo):
     can_vote = age.value >= 18 and has_id.value
 
@@ -143,12 +173,15 @@ def _(age, has_id, mo):
 
     - Age: {age.value} years old
 
-    - Has ID: {'Yes' if has_id.value else 'No'}
+    - Has ID: {"Yes" if has_id.value else "No"}
 
-    - Can Vote: {'Yes ✅' if can_vote else 'No ❌'}
+    - Can Vote: {"Yes ✅" if can_vote else "No ❌"}
 
-    Reason: {'Both age and ID requirements met' if can_vote 
-            else 'Missing ' + ('required age' if age.value < 18 else 'valid ID')}
+    Reason: {
+        "Both age and ID requirements met"
+        if can_vote
+        else "Missing " + ("required age" if age.value < 18 else "valid ID")
+    }
     """
 
     mo.md(explanation)
@@ -157,15 +190,22 @@ def _(age, has_id, mo):
 
 @app.cell(hide_code=True)
 def _(mo):
-    _text = mo.md("""
-        - Try different combinations of age and ID status
-        - Notice how both conditions must be True to allow voting
-        - Experiment with edge cases (exactly 18, no ID, etc.)
-    """)
-    mo.accordion({"💡 Experiment Tips": _text})
+    mo.md(r"""**Try it!** Write Python code that computes whether an individual can vote.""")
     return
 
 
+@app.cell
+def _():
+    my_age = 18
+    return (my_age,)
+
+
+@app.cell
+def _():
+    has_an_id = False
+    return (has_an_id,)
+
+
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
@@ -189,13 +229,13 @@ def _(mo):
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(humidity, mo, temp, wind):
     mo.hstack([temp, humidity, wind])
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     temp = mo.ui.number(value=25, start=-20, stop=50, label="Temperature (°C)")
     humidity = mo.ui.slider(value=60, start=0, stop=100, label="Humidity (%)")
@@ -203,28 +243,29 @@ def _(mo):
     return humidity, temp, wind
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(humidity, mo, temp, wind):
     def get_weather_advice():
         conditions = []
-        
+
         if temp.value > 30:
             conditions.append("🌡️ High temperature")
         elif temp.value < 10:
             conditions.append("❄️ Cold temperature")
-                
+
         if humidity.value > 80:
             conditions.append("💧 High humidity")
         elif humidity.value < 30:
             conditions.append("🏜️ Low humidity")
-                
+
         if wind.value > 30:
             conditions.append("💨 Strong winds")
-                
+
         return conditions
-        
+
+
     conditions = get_weather_advice()
-        
+
     message = f"""
     ### Weather Analysis
 
@@ -236,7 +277,7 @@ def _(humidity, mo, temp, wind):
 
     - Wind Speed: {wind.value} km/h
 
-    Alerts: {', '.join(conditions) if conditions else 'No special alerts'}
+    Alerts: {", ".join(conditions) if conditions else "No special alerts"}
     """
 
     mo.md(message)
@@ -245,22 +286,22 @@ def _(humidity, mo, temp, wind):
 
 @app.cell(hide_code=True)
 def _(mo):
-    callout_text = mo.md("""
-    ## Your Logic Journey Continues!
-
-    Next Steps:
+    mo.md("""
+    ## Next steps
 
     - Practice combining multiple conditions
-
     - Explore nested if statements
-
-    - Try creating your own complex decision trees (pun on an ML algorithm!)
+    - Try creating your own complex decision trees
 
     Keep coding! 🎯✨
     """)
+    return
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/005_loops.py

@@ -7,38 +7,32 @@
 
 import marimo
 
-__generated_with = "0.10.14"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
         # 🔄 Loops in Python
 
-        Let's explore how Python helps us repeat tasks efficiently with loops! 
+        Let's learn how Python helps us repeat tasks efficiently with loops.
 
-        ## Types of Loops
-        Python has two main types of loops:
+        A "loop" is a way to execute a block of code multiple times. Python has two 
+        main types of loops:
 
         ```python
-        # For loop - when you know how many times to repeat
+        # For loop: when you know how many times to repeat
         for i in range(5):
             print(i)
 
-        # While loop - when you don't know how many repetitions
+        # While loop: when you don't know how many repetitions
         while condition:
             do_something()
         ```
 
-        Let's start with a simple list to explore loops.
+        Let's start with a simple list to explore loops. Feel free to modify this list and see how the subsequent outputs change.
         """
     )
     return
@@ -54,7 +48,7 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## For Loop Basics
+        ## The for loop
 
         The for loop is perfect for iterating over sequences.
         Try changing the `sample_fruits` list above and see how the output changes.
@@ -65,122 +59,128 @@ def _(mo):
 
 @app.cell
 def _(sample_fruits):
-    def _print_fruits():
-        for _fruit in sample_fruits:
-            print(f"I like {_fruit}s!")
-    _print_fruits()
+    for _fruit in sample_fruits:
+        print(f"I like {_fruit}s!")
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Using enumerate()
+    mo.md(
+        """
+        ### Getting the position of an item
 
-        When you need both the item and its position, use enumerate():
-        """)
+        When you need both the item and its position, use `enumerate()`:
+        """
+    )
     return
 
 
 @app.cell
 def _(sample_fruits):
-    def _print_enumerated():
-        for _idx, _fruit in enumerate(sample_fruits):
-            print(f"{_idx + 1}. {_fruit}")
-    _print_enumerated()
+    for _idx, _fruit in enumerate(sample_fruits):
+        print(f"{_idx + 1}. {_fruit}")
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Range in Loops
+    mo.md(
+        """
+        ### Iterating over a range of numbers
+
+        `range()` is a powerful function for generating sequences of numbers:
+        """
+    )
+    return
 
-        range() is a powerful function for generating sequences of numbers:
-        """)
+
+@app.cell
+def _():
+    print("range(5):", list(range(5)))
+    print("range(2, 5):", list(range(2, 5)))
+    print("range(0, 10, 2):", list(range(0, 10, 2)))
     return
 
 
 @app.cell
 def _():
-    def _demonstrate_range():
-        print("range(5):", list(range(5)))
-        print("range(2, 5):", list(range(2, 5)))
-        print("range(0, 10, 2):", list(range(0, 10, 2)))
-    _demonstrate_range()
+    for _i in range(5):
+        print(_i)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""## While Loop Basics
+    mo.md(
+        """
+        ## The `while` loop
 
-    While loops continue as long as a condition is `True`.""")
+        While loops continue as long as a condition is `True`.
+        """
+    )
     return
 
 
 @app.cell
 def _():
-    def _count_up():
-        _count = 0
-        while _count < 5:
-            print(f"Count is {_count}")
-            _count += 1
-    _count_up()
+    _count = 0
+    while _count < 5:
+        print(f"The count is {_count}")
+        _count += 1
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Loop Control Statements
+    mo.md(
+        """
+        ## Controlling loop execution
 
         Python provides several ways to control loop execution:
 
-        - `break`: Exit the loop immediately
+        - `break`: exit the loop immediately
 
-        - `continue`: Skip to the next iteration
+        - `continue`: skip to the next iteration
 
-        - `else`: Execute when loop completes normally
-        """)
+        These can be used with both `for` and `while` loops.
+        """
+    )
     return
 
 
 @app.cell
 def _():
-    def _demonstrate_break():
-        for _i in range(1, 6):
-            if _i == 4:
-                break
-            print(_i)
-        print("Loop ended early!")
-    _demonstrate_break()
+    for _i in range(1, 6):
+        if _i == 4:
+            print("Breaking out of the loop.")
+            break
+        print(_i)
     return
 
 
 @app.cell
 def _():
-    def _demonstrate_continue():
-        for _i in range(1, 6):
-            if _i == 3:
-                continue
-            print(_i)
-    _demonstrate_continue()
+    for _i in range(1, 6):
+        if _i == 3:
+            continue
+        print(_i)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Practical Loop Patterns
+    mo.md(
+        """
+        ## Practical loop patterns
 
         Here are some common patterns you'll use with loops:
 
         ```python
         # Pattern 1: Accumulator
-        sum = 0
+        value = 0
         for num in [1, 2, 3, 4, 5]:
-            sum += num
+            value += num
 
         # Pattern 2: Search
         found = False
@@ -195,26 +195,27 @@ def _(mo):
             if condition:
                 filtered.append(item)
         ```
-        """)
+        """
+    )
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    callout_text = mo.md("""
-    ## Loop Like a Pro!
-
-    Next Steps:
+    mo.md(
+        r"""
+        ## Next steps
 
-    - Practice using different types of loops
-    - Experiment with loop control statements
-    - Try combining loops with lists and conditions
+        Check out the official [Python docs on loops and control flow](https://docs.python.org/3/tutorial/controlflow.html).
+        """
+    )
+    return
 
-    Keep iterating! 🔄✨
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/006_dictionaries.py

@@ -7,16 +7,10 @@
 
 import marimo
 
-__generated_with = "0.10.14"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
-@app.cell
-def _():
-    import marimo as mo
-    return (mo,)
-
-
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
@@ -47,7 +41,7 @@ def _():
         "type": "programming language",
         "year": 1991,
         "creator": "Guido van Rossum",
-        "is_awesome": True
+        "is_awesome": True,
     }
     return (sample_dict,)
 
@@ -71,6 +65,8 @@ def _(sample_dict):
     def access_dict():
         print(f"Name: {sample_dict['name']}")
         print(f"Year: {sample_dict['year']}")
+
+
     access_dict()
     return (access_dict,)
 
@@ -81,17 +77,21 @@ def _(sample_dict):
     def safe_access():
         print(f"Version: {sample_dict.get('version', 'Not specified')}")
         print(f"Type: {sample_dict.get('type', 'Unknown')}")
+
+
     safe_access()
     return (safe_access,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
+    mo.md(
+        """
         ## Dictionary Methods
 
         Python dictionaries come with powerful built-in methods:
-        """)
+        """
+    )
     return
 
 
@@ -102,6 +102,8 @@ def _(sample_dict):
         print("Keys:", list(sample_dict.keys()))
         print("Values:", list(sample_dict.values()))
         print("Items:", list(sample_dict.items()))
+
+
     view_components()
     return (view_components,)
 
@@ -120,17 +122,21 @@ def _():
         # Removing
         _removed = _dict.pop("b")
         print(f"Removed {_removed}, Now:", _dict)
+
+
     demonstrate_modification()
     return (demonstrate_modification,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
+    mo.md(
+        """
         ## Dictionary Comprehension
 
         Create dictionaries efficiently with dictionary comprehensions:
-        """)
+        """
+    )
     return
 
 
@@ -145,17 +151,21 @@ def _():
         # Filtered dictionary
         _even_squares = {x: x**2 for x in range(5) if x % 2 == 0}
         print("Even squares:", _even_squares)
+
+
     demonstrate_comprehension()
     return (demonstrate_comprehension,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
+    mo.md(
+        """
         ## Nested Dictionaries
 
         Dictionaries can contain other dictionaries, creating complex data structures:
-        """)
+        """
+    )
     return
 
 
@@ -166,13 +176,13 @@ def _():
             "alice": {
                 "age": 25,
                 "email": "alice@example.com",
-                "interests": ["python", "data science"]
+                "interests": ["python", "data science"],
             },
             "bob": {
                 "age": 30,
                 "email": "bob@example.com",
-                "interests": ["web dev", "gaming"]
-            }
+                "interests": ["web dev", "gaming"],
+            },
         }
     }
     return (nested_data,)
@@ -196,14 +206,22 @@ def _(nested_data):
             return _current
 
         print("\nSafe access example:")
-        print("Charlie's age:", _get_nested(nested_data, "users", "charlie", "age", default="Not found"))
+        print(
+            "Charlie's age:",
+            _get_nested(
+                nested_data, "users", "charlie", "age", default="Not found"
+            ),
+        )
+
+
     access_nested()
     return (access_nested,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
+    mo.md(
+        """
         ## Common Dictionary Patterns
 
         Here are some useful patterns when working with dictionaries:
@@ -227,7 +245,8 @@ def _(mo):
                 cache[arg] = compute_result(arg)
             return cache[arg]
         ```
-        """)
+        """
+    )
     return
 
 
@@ -250,5 +269,11 @@ def _(mo):
     return (callout_text,)
 
 
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
 if __name__ == "__main__":
     app.run()