Merge pull request #14 from marimo-team/aka/reorg-python

Python/phase_1/number_operations.py → 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
+        # 🔢 Numbers
 
-        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
@@ -50,7 +45,7 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Basic Mathematical Operations
+        ## Basic mathematical operations
 
         Python supports all standard mathematical operations.
 
@@ -104,15 +99,15 @@ def _(number):
 
 @app.cell
 def _(number):
-    number ** 2  # Exponentiation
+    number**2  # Exponentiation
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Type Conversion
+        ## Type conversion
 
         You can convert between different number types. Try changing these values!
         """
@@ -134,7 +129,7 @@ def _(decimal_number):
 
 @app.cell
 def _(number):
-    float(number)  # Convert to float
+    float(number)  # Convert to "float" or decimal
     return
 
 
@@ -142,7 +137,7 @@ def _(number):
 def _(mo):
     mo.md(
         """
-        ## Built-in Math Functions
+        ## Built-in math functions
         Python provides many useful built-in functions for working with numbers:
         """
     )
@@ -177,51 +172,74 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Advanced Math Operations
+        ## Advanced operations
+
+        For more complex mathematical operations, use Python's [math module](https://docs.python.org/3/library/math.html).
+        """
+    )
+    return
 
-        For more complex mathematical operations, Python's `math` module is your friend:
 
-        ```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/phase_1/string_manipulation.py → python/002_strings.py

@@ -7,14 +7,8 @@
 
 import marimo
 
-__generated_with = "0.10.12"
-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)
@@ -23,15 +17,25 @@ def _(mo):
         """
         # 🎭 Strings
 
-        Dive into the world of Python strings — where text comes to life! 
+        This notebook introduces **strings**, which are containers for text.
 
         ## Creating strings
-        In Python, strings are containers for text. You can create them in two simple
-        ways:
+        Create strings by wrapping text in quotes:
 
         ```python
-        greeting = "Hello, Python!"  # using double quotes
-        name = 'Alice'               # using single quotes
+        # 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 string.
@@ -42,7 +46,8 @@ def _(mo):
 
 @app.cell
 def _():
-    text = "Python is amazing"
+    text = "Python is amazing!"
+    text
     return (text,)
 
 
@@ -63,6 +68,7 @@ def _(mo):
 
 @app.cell
 def _(text):
+    # the `len` method returns the number of characters in the string.
     len(text)
     return
 
@@ -93,7 +99,8 @@ def _(mo):
 
 @app.cell
 def _(text):
-    text.find('is')
+    # Returns the index of "is" in the string
+    text.find("is")
     return
 
 
@@ -109,7 +116,7 @@ def _(text):
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
@@ -118,7 +125,7 @@ def _(mo):
         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 changing the value of `my_name`, and watch how the greeting changes.
+        **Try it!** Enter your name in `my_name` below, then run the cell.
         """
     )
     return
@@ -126,7 +133,7 @@ def _(mo):
 
 @app.cell
 def _():
-    my_name = ''
+    my_name = ""
     return (my_name,)
 
 
@@ -140,7 +147,7 @@ def _(my_name):
 def _(mo):
     mo.md(
         """
-        ## Working with Parts of Strings
+        ## Working with parts of strings
         You can access any part of a string using its position (index):
         """
     )
@@ -181,48 +188,73 @@ def _(mo):
         """
         ## Other helpful string methods
 
-        Finally, here are some other helpful string methods. Feel free to try them out on your own strings!
+        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
-        sentence = "  python is fun  "
 
-        # Remove extra spaces
-        print(sentence.strip())        # "python is fun"
+@app.cell
+def _():
+    sentence = "  python is fun  "
+    sentence
+    return (sentence,)
 
-        # Split into a list of words
-        print(sentence.split())        # ['python', 'is', 'fun']
 
-        # Replace words
-        print(sentence.replace('fun', 'awesome'))
+@app.cell
+def _(sentence):
+    # Remove extra spaces
+    sentence.strip()
+    return
 
-        # Check what kind of text you have
-        print("123".isdigit())        # True - only numbers?
-        print("abc".isalpha())        # True - only letters?
-        print("Python3".isalnum())    # True - letters or numbers?
-        ```
-        """
-    )
+
+@app.cell
+def _(sentence):
+    # Split into a list of words
+    sentence.split()
     return
 
 
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your String Journey Begins!
+@app.cell
+def _(sentence):
+    sentence.replace("fun", "awesome")
+    return
 
-    Next Steps:
 
-    - Try combining different string methods
+@app.cell
+def _():
+    "123".isdigit(), "abc".isdigit()
+    return
+
+
+@app.cell
+def _():
+    "123".isalpha(), "abc".isalpha()
+    return
+
+
+@app.cell
+def _():
+    "Python3".isalnum()
+    return
+
 
-    - Practice with f-strings
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ## Next steps
 
-    - Experiment with string slicing
+        For a full primer on strings, check out the [official documentation](https://docs.python.org/3/library/string.html).
+        """
+    )
+    return
 
-    You're doing great! 🐍✨
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/phase_1/collections.py → 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.
@@ -50,7 +44,7 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## List Operations
+        ## List operations
 
         Here are common operations you can perform on lists.
 
@@ -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,24 +176,21 @@ 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)
 def _(mo):
     mo.md(
         """
-        ## Collection Methods and Operations
+        ## Collection methods and operations
 
         Here are some common operations across collections:
 
@@ -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/phase_2/conditional_logic.py → 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
+        # 🔄 Conditional logic
 
-        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,)
 
@@ -106,7 +125,7 @@ def _(mo, threshold, value):
 def _(mo):
     mo.md(
         r"""
-        ## Boolean Operations
+        ## Boolean operations
         Python uses boolean operators to combine conditions:
 
         - `and`: Both conditions must be True
@@ -119,36 +138,50 @@ 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
 
     explanation = f"""
-    ### Voting Eligibility Check
+    ### Voting eligibility check
 
     Current Status:
 
     - 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,20 +190,27 @@ 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(
         """
-        ## Complex Conditions
+        ## Complex conditions
         Combine multiple conditions for more sophisticated logic:
         ```python
         # Multiple conditions
@@ -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,30 +243,31 @@ 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
+    ### Weather analysis
 
     Current Conditions:
 
@@ -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/phase_2/loop_structures.py → 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
+        # 🔄 Loops
 
-        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/phase_3/dictionaries.py → python/006_dictionaries.py

@@ -7,31 +7,25 @@
 
 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(
         """
-        # 📚 Python Dictionaries
+        # 📚 Dictionaries
 
-        Welcome to the world of Python dictionaries — where data gets organized with keys! 
+        Dictionaries are collections of key-value pairs, with each key associated with a value. The keys are unique, meaning they show up only once.
 
-        ## Creating Dictionaries
-        Dictionaries are collections of key-value pairs. Here's how to create them:
+        ## Creating dictionaries
+        Here are a few ways to create dictionaries:
 
         ```python
-        simple_dict = {"name": "Alice", "age": 25}  # direct creation
-        empty_dict = dict()                         # empty dictionary
-        from_pairs = dict([("a", 1), ("b", 2)])    # from key-value pairs
+        simple_dict = {"name": "Alice", "age": 25}
+        empty_dict = dict()
+        from_pairs = dict([("a", 1), ("b", 2)])
         ```
 
         Below is a sample dictionary we'll use to explore operations.
@@ -47,7 +41,7 @@ def _():
         "type": "programming language",
         "year": 1991,
         "creator": "Guido van Rossum",
-        "is_awesome": True
+        "is_awesome": True,
     }
     return (sample_dict,)
 
@@ -56,10 +50,23 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Basic Dictionary Operations
+        ## Operations
 
         Let's explore how to work with dictionaries.
-        Try modifying the `sample_dict` above and watch how the results change!
+
+        **Try it!** Try modifying the `sample_dict` above and watch how the results change!
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        r"""
+        ### Accessing values by key
+
+        Access values by key using square brackets, like below
         """
     )
     return
@@ -67,48 +74,54 @@ def _(mo):
 
 @app.cell
 def _(sample_dict):
-    # Accessing values of the dictionary
-    def access_dict():
-        print(f"Name: {sample_dict['name']}")
-        print(f"Year: {sample_dict['year']}")
-    access_dict()
-    return (access_dict,)
+    sample_dict['name'], sample_dict['year']
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""If you're not sure if a dictionary has a given key, use `get()`:""")
+    return
 
 
 @app.cell
 def _(sample_dict):
-    # Safe access with get()
-    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,)
+    sample_dict.get("version", "Not specified"), sample_dict.get("type", "Unknown")
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Dictionary Methods
+    mo.md(
+        """
+        ## Enumerating dictionary contents
+
+        Python dictionaries come with helpful methods to enumerate keys, values, and pairs.
+        """
+    )
+    return
+
 
-        Python dictionaries come with powerful built-in methods:
-        """)
+@app.cell
+def _(sample_dict):
+    print(list(sample_dict.keys()))
     return
 
 
 @app.cell
 def _(sample_dict):
-    # Viewing dictionary components
-    def view_components():
-        print("Keys:", list(sample_dict.keys()))
-        print("Values:", list(sample_dict.values()))
-        print("Items:", list(sample_dict.items()))
-    view_components()
-    return (view_components,)
+    print(list(sample_dict.values()))
+    return
+
+
+@app.cell
+def _(sample_dict):
+    print(list(sample_dict.items()))
+    return
 
 
 @app.cell
 def _():
-    # Modifying dictionaries
     def demonstrate_modification():
         _dict = {"a": 1, "b": 2}
         print("Original:", _dict)
@@ -120,42 +133,45 @@ 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("""
-        ## Dictionary Comprehension
+    mo.md(
+        """
+        ## Dictionary comprehension
 
         Create dictionaries efficiently with dictionary comprehensions:
-        """)
+        """
+    )
     return
 
 
 @app.cell
 def _():
-    # Dictionary comprehension examples
-    def demonstrate_comprehension():
-        # Squares dictionary
-        _squares = {x: x**2 for x in range(5)}
-        print("Squares:", _squares)
+    print({x: x**2 for x in range(5)})
+    return
+
 
-        # 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
+def _():
+    print({x: x**2 for x in range(5) if x % 2 == 0})
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Nested Dictionaries
+    mo.md(
+        """
+        ## Nested dictionaries
 
         Dictionaries can contain other dictionaries, creating complex data structures:
-        """)
+        """
+    )
     return
 
 
@@ -166,45 +182,35 @@ def _():
             "alice": {
                 "age": 25,
                 "email": "[email protected]",
-                "interests": ["python", "data science"]
+                "interests": ["python", "data science"],
             },
             "bob": {
                 "age": 30,
                 "email": "[email protected]",
-                "interests": ["web dev", "gaming"]
-            }
+                "interests": ["web dev", "gaming"],
+            },
         }
     }
     return (nested_data,)
 
 
 @app.cell
-def _(nested_data):
-    # Accessing nested data
-    def access_nested():
-        print("Alice's age:", nested_data["users"]["alice"]["age"])
-        print("Bob's interests:", nested_data["users"]["bob"]["interests"])
-
-        # Safe nested access
-        def _get_nested(data, *keys, default=None):
-            _current = data
-            for _key in keys:
-                if isinstance(_current, dict):
-                    _current = _current.get(_key, default)
-                else:
-                    return default
-            return _current
-
-        print("\nSafe access example:")
-        print("Charlie's age:", _get_nested(nested_data, "users", "charlie", "age", default="Not found"))
-    access_nested()
-    return (access_nested,)
+def _(mo, nested_data):
+    mo.md(f"Alice's age: {nested_data["users"]["alice"]["age"]}")
+    return
+
+
+@app.cell
+def _(mo, nested_data):
+    mo.md(f"Bob's interests: {nested_data["users"]["bob"]["interests"]}")
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Common Dictionary Patterns
+    mo.md(
+        """
+        ## Common dictionary patterns
 
         Here are some useful patterns when working with dictionaries:
 
@@ -227,27 +233,15 @@ def _(mo):
                 cache[arg] = compute_result(arg)
             return cache[arg]
         ```
-        """)
+        """
+    )
     return
 
 
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Master the Dictionary!
-
-    Next Steps:
-
-    - Practice different dictionary methods
-    - Try creating nested data structures
-    - Experiment with dictionary comprehensions
-    - Build something using common patterns
-
-    Keep organizing your data! 🗂️✨
-    """)
-
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/phase_3/advanced_collections.py → python/007_advanced_collections.py

@@ -7,27 +7,22 @@
 
 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(
         """
-        # 🔄 Advanced Collections in Python
+        # 🔄 Advanced collections
 
-        Let's dive deep into advanced collection handling in Python! 
+        This tutorials hows advanced patterns for working with collections.
 
-        ## Lists of Dictionaries
-        A common pattern in data handling is working with lists of dictionaries - 
-        perfect for representing structured data like records or entries.
+        ## Lists of dictionaries
+
+        A common pattern in data handling is working with lists of dictionaries:
+        this is helpful for representing structured data like records or entries.
         """
     )
     return
@@ -48,10 +43,10 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Working with Lists of Dictionaries
-
         Let's explore common operations on structured data.
-        Try modifying the `users_data` above and see how the results change!
+
+        **Try it!** Try modifying the `users_data` above and see how the results
+        change!
         """
     )
     return
@@ -60,18 +55,22 @@ def _(mo):
 @app.cell
 def _(users_data):
     # Finding users with specific skills
-    python_users = [user["name"] for user in users_data if "Python" in user["skills"]]
+    python_users = [
+        user["name"] for user in users_data if "Python" in user["skills"]
+    ]
     print("Python developers:", python_users)
     return (python_users,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Nested Data Structures
+    mo.md(
+        """
+        ## Nested data structures
 
         Python collections can be nested in various ways to represent complex data:
-        """)
+        """
+    )
     return
 
 
@@ -110,11 +109,13 @@ def _(project_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Data Transformation
+    mo.md(
+        """
+        ### Example: data transformation
 
         Let's explore how to transform and reshape collection data:
-        """)
+        """
+    )
     return
 
 
@@ -148,10 +149,11 @@ def _(sales_data):
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""
-        ## Collection Utilities
+    mo.md(
+        """
+        ## More collection utilities
 
-        Python's collections module provides specialized container datatypes:
+        Python's `collections` module provides specialized container datatypes:
 
         ```python
         from collections import defaultdict, Counter, deque
@@ -169,7 +171,8 @@ def _(mo):
         history = deque(maxlen=10)  # Only keeps last 10 items
         history.append(item)
         ```
-        """)
+        """
+    )
     return
 
 
@@ -191,20 +194,21 @@ def _():
 
 @app.cell(hide_code=True)
 def _(mo):
-    callout_text = mo.md("""
-    ## Level Up Your Collections!
-
-    Next Steps:
+    mo.md(
+        """
+        ## Next steps
 
-    - Practice transforming complex data structures
-    - Experiment with different collection types
-    - Try combining multiple data structures
+        For a reference on the `collections` module, see [the official Python 
+        docs](https://docs.python.org/3/library/collections.html).
+        """
+    )
+    return
 
-    Keep organizing! 📊✨
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/phase_4/function_design.py → python/008_functions.py

@@ -7,57 +7,69 @@
 
 import marimo
 
-__generated_with = "0.10.16"
+__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(
         """
-        # 🧩 Function Design in Python
+        # 🧩 Functions
 
-        Dive into the world of Python functions — where code becomes modular and powerful!
+        This tutorial is about an important topic: **functions.**
 
-        ## Function Basics
-        Functions help you:
+        A function is a reusable block of code, similar in spirit to a mathematical function. Each function has a **name**, and accepts some number of **arguments**. These arguments are used in the function "body" (its block of code), and each function can **return** values.
 
-        - Break down complex problems
+        **Example.** Below is an example function.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    def greet(your_name):
+        return f"Hello, {your_name}!"
+    return (greet,)
 
-        - Create reusable code blocks
 
-        - Improve code readability (good practice)
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(r"""The keyword `def` starts the function definition. The function's **name** is `greet`. It accepts one **argument** called `your_name`. It then creates a string and **returns** it.""")
+    return
 
-        ```python
-        def function_name(parameters):
-            '''Docstring explaining the function'''
-            # Function body
-            return result
-        ```
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        In the next cell, we **call** the function with a value and assign its return value to a variable.
+
+        **Try it!** Try changing the input to the function.
         """
     )
     return
 
 
 @app.cell
-def _():
-    # Example function with parameter
-    def greet(name):
-        return f"Hello, {name}!"
+def _(greet):
+    greeting = greet(your_name="<your name here>")
+    greeting
+    return (greeting,)
 
-    name = "Python Learner"
-    return greet, name
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        **Why use functions?** Functions help you:
 
-@app.cell
-def _(greet, name):
-    greet(name)
+        - Break down complex problems
+        - Create reusable code blocks
+        - Improve code readability
+        """
+    )
     return
 
 
@@ -65,7 +77,7 @@ def _(greet, name):
 def _(mo):
     mo.md(
         """
-        ## Default Parameters
+        ## Default parameters
         Make your functions more flexible by providing default values.
         """
     )
@@ -74,21 +86,30 @@ def _(mo):
 
 @app.cell
 def _():
-    # Function with default parameter
     def create_profile(name, age=18):
         return f"{name} is {age} years old"
+    return (create_profile,)
+
 
+@app.cell
+def _(create_profile):
     # Example usage
     example_name = "Alex"
     example_profile = create_profile(example_name)
     example_profile
-    return create_profile, example_name, example_profile
+    return example_name, example_profile
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""You can also create functions that reference variables outside the function body. This is called 'closing over' variables""")
+    return
 
 
 @app.cell
 def _():
-    # Show closure over values
     base_multiplier = 2
+
     def multiplier(x):
         """
         Create a function that multiplies input by a base value.
@@ -97,49 +118,12 @@ def _():
         values from their surrounding scope.
         """
         return x * base_multiplier
-
-    # Example of using the closure
-    sample_numbers = [1, 2, 3, 4, 5]
-    multiplied_numbers = [multiplier(num) for num in sample_numbers]
-    print(multiplied_numbers)
-    return base_multiplier, multiplied_numbers, multiplier, sample_numbers
+    return base_multiplier, multiplier
 
 
 @app.cell
-def _():
-    def calculate(a, b):
-        """
-        Perform multiple calculations on two numbers.
-
-        Args:
-            a (int): First number
-            b (int): Second number
-
-        Returns:
-            dict: Results of various calculations
-        """
-        return {
-            "sum": a + b,
-            "product": a * b,
-            "difference": a - b,
-            "max": max(a, b)
-        }
-
-    # Example usage with concrete values
-    first_number = 10
-    second_number = 5
-    result = calculate(first_number, second_number)
-    return calculate, first_number, result, second_number
-
-
-@app.cell(hide_code=True)
-def _(mo, result):
-    mo.md(f"""
-    ## Function Results
-
-    Calculation Results:
-    {result}
-    """)
+def _(multiplier):
+    print([multiplier(num) for num in [1, 2, 3]])
     return
 
 
@@ -147,16 +131,10 @@ def _(mo, result):
 def _(mo):
     mo.md(
         """
-        ## Multiple Return Values
-        Python allows returning multiple values easily:
-
-        ```python
-        def multiple_returns():
-            return value1, value2, value3
+        ## Returning multiple values
 
-        # Unpacking returns
-        x, y, z = multiple_returns()
-        ```
+        Functions can return multiple values: just separate the values to return by
+        commas. Check out the next cell for an example.
         """
     )
     return
@@ -182,47 +160,26 @@ def _():
             return "Mild", "Comfortable clothing", "Low"
         else:
             return "Hot", "Stay hydrated", "High"
+    return (weather_analysis,)
 
-    # Example temperature analysis
-    temperature = 25
-    status, recommendation, warning_level = weather_analysis(temperature)
-    return (
-        recommendation,
-        status,
-        temperature,
-        warning_level,
-        weather_analysis,
-    )
 
+@app.cell
+def _():
+    temperature = 25
+    return (temperature,)
 
-@app.cell(hide_code=True)
-def _(mo, recommendation, status, warning_level):
-    mo.md(f"""
-    ## Function Results
-
-    Calculation Results:
-    {status}, {recommendation}, {warning_level}
-    """)
-    return
-
-
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your Function Design Journey!
-
-    Next Steps:
-
-    - Practice creating functions
-
-    - Experiment with default parameters
 
-    - Explore multiple return values
+@app.cell
+def _(temperature, weather_analysis):
+    status, recommendation, warning_level = weather_analysis(temperature)
+    status, recommendation, warning_level
+    return recommendation, status, warning_level
 
-    """)
 
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/phase_4/modular_programming.py → python/009_modules.py

@@ -7,29 +7,21 @@
 
 import marimo
 
-__generated_with = "0.10.16"
+__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(
         """
-        # 🧩 Modular Programming in Python
+        # 🧩 Using modules
 
-        Unlock the power of organized, reusable, and maintainable code!
+        A `module` in Python is a Python file that defines functions and variables. Modules can be `imported` into other Python files, letting you reuse their
+        functions and variables.
 
-        ## Why Modular Programming?
-        - Break complex problems into smaller, manageable pieces
-        - Improve code readability
-        - Enhance code reusability
-        - Easier debugging and maintenance
+        We have already seen some modules in previous tutorials, including the `math`
+        module. Python comes with many other modules built-in.
         """
     )
     return
@@ -39,8 +31,9 @@ def _(mo):
 def _(mo):
     mo.md(
         """
-        ## Standard Library Imports
-        Python's standard library provides powerful, pre-built modules:
+        ## The Python standard library
+
+        Python's "standard library" provides many modules, for many kinds of tasks.
 
         ```python
         # String manipulation
@@ -56,15 +49,20 @@ def _(mo):
         import math
         ```
 
-        For more details, check the [Python Standard Library Documentation](https://docs.python.org/3/library/)
+        See the [Python standard library documentation](https://docs.python.org/3/library/) for a full reference
         """
     )
     return
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md("""### Example""")
+    return
+
+
 @app.cell
 def _():
-    # importing and using standard library modules
     import string
     import os
     import datetime
@@ -108,8 +106,9 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Import Strategies
-        Multiple ways to import and use modules:
+        ## Import syntax
+
+        You can import entire modules, and access their functions and variables using dot notation (`math.sqrt`). Or you can import specific members:
 
         ```python
         # Import entire module
@@ -160,8 +159,16 @@ def _():
 def _(mo):
     mo.md(
         """
-        ## Code Reusability
-        Create functions that can be used across different parts of your project
+        ## Third-party packages
+
+        In addition to Python's standard library, there are hundreds of thousands of
+        modules available for free on the Python Package index.
+
+        These are distributed as Python "packages", and include packages for
+        manipulating arrays of numbers, creating web applications, and more. `marimo`
+        itself is a third-party package!
+
+        For installing packages on your machine, we recommend using the [`uv` package manager](https://docs.astral.sh/uv/).
         """
     )
     return
@@ -169,64 +176,8 @@ def _(mo):
 
 @app.cell
 def _():
-    def generate_reusable_functions():
-        """
-        Demonstrate different types of reusable functions
-        """
-
-        def process_text(text):
-            '''Reusable text processing function'''
-            return text.strip().lower()
-
-        def normalize_number(value, min_val=0, max_val=100):
-            '''Normalize a number to a specific range'''
-            return max(min_val, min(max_val, value))
-
-        def validate_input(value, type_check=str, min_length=1):
-            '''Validate input based on type and minimum length'''
-            if not isinstance(value, type_check):
-                return False
-            return len(str(value)) >= min_length
-
-        # usage
-        return {
-            "Text Processing": {
-                "Example 1": process_text("  John Doe  "),
-                "Example 2": process_text("  [email protected]  ")
-            },
-            "Number Normalization": {
-                "Oversized Input": normalize_number(150),
-                "Negative Input": normalize_number(-10, min_val=-20, max_val=50)
-            },
-            "Input Validation": {
-                "Username Validation": validate_input("john"),
-                "Age Validation": validate_input(25, type_check=int)
-            }
-        }
-
-    # Run the reusable functions demonstration
-    reusable_function_examples = generate_reusable_functions()
-    reusable_function_examples
-    return generate_reusable_functions, reusable_function_examples
-
-
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your Modular Programming Journey!
-
-    Next Steps:
-
-    - Explore Python's standard library
-
-    - Practice different import strategies
-
-    - Design reusable functions
-
-    """)
-
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":

Python/phase_5/error_management.py → python/010_exceptions.py

@@ -7,44 +7,78 @@
 
 import marimo
 
-__generated_with = "0.10.16"
+__generated_with = "0.10.19"
 app = marimo.App()
 
 
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        # 🛡️ Handling errors
+
+        Sometimes things go wrong in programs. When that happens, Python raises `exceptions` to tell you what went amiss. For example, maybe you divided by 0:
+        """
+    )
+    return
+
+
 @app.cell
 def _():
-    import marimo as mo
-    return (mo,)
+    1 / 0
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        # 🛡️ Error Management in Python
+        That's a lot of red! The outputs above are Python telling you that
+        something went wrong — in this case, we tried dividing a number by 0.
+
+        Python provides tools to catch and handle exceptions: the `try/except`
+        block. This is demonstrated in the next couple cells.
+        """
+    )
+    return
 
-        Welcome to the world of Python error handling - where bugs become learning opportunities! 
 
-        ## Why Error Handling Matters
-        Imagine your code as a superhero navigating through the treacherous landscape of potential problems. 
-        Error handling is like your hero's shield, protecting your program from unexpected challenges.
+@app.cell
+def _():
+    # Try changing the value of divisor below, and see how the output changes.
+    divisor = 0
+    return (divisor,)
 
-        ```python
-        # Without error handling
-        result = 10 / 0  # 💥 Boom! Unhandled ZeroDivisionError
 
-        # With error handling
+@app.cell
+def _(divisor):
+    try:
+        print(1 / divisor)
+    except ZeroDivisionError as e:
+        print("Something went wrong!", e)
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        Python has many types of Exceptions besides `ZeroDivisionError`. If you
+        don't know what kind of exception you're handling, catch the generic
+        `Exception` type:
+
+        ```python
         try:
-            result = 10 / 0
-        except ZeroDivisionError:
-            result = "Oops! Can't divide by zero 🛑"
+            ...
+        except Exception:
+            ...
         ```
         """
     )
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(error_types):
     error_types
     return
@@ -54,6 +88,7 @@ def _(error_types):
 def _(mo):
     # Choose error type
     error_types = mo.ui.dropdown(
+        value="ZeroDivisionError",
         options=[
             "ZeroDivisionError", 
             "TypeError", 
@@ -61,7 +96,7 @@ def _(mo):
             "IndexError", 
             "KeyError"
         ],
-        label="Select an Error Type to Explore"
+        label="Learn about ..."
     )
     return (error_types,)
 
@@ -122,58 +157,12 @@ def _(error_types, mo):
     return (error_explanations,)
 
 
-@app.cell
-def _(division_input, divisor_input, mo):
-    mo.hstack([division_input, divisor_input])
-    return
-
-
 @app.cell(hide_code=True)
 def _(mo):
-    # Try-Except work help
-    division_input = mo.ui.number(
-        value=10, 
-        label="Number to Divide", 
-        start=-100, 
-        stop=100
-    )
-    divisor_input = mo.ui.number(
-        value=0, 
-        label="Divisor", 
-        start=-100, 
-        stop=100
-    )
-    return division_input, divisor_input
-
-
-@app.cell
-def _(division_input, divisor_input, mo):
-    # Safe division function with appropriate error handling
-    def safe_divide(numerator, denominator):
-        try:
-            _result = numerator / denominator
-            return f"Result: {_result}"
-        except ZeroDivisionError:
-            return "🚫 Cannot divide by zero!"
-        except Exception as e:
-            return f"Unexpected error: {e}"
-
-    # Display result with explanation
-    _result = safe_divide(division_input.value, divisor_input.value)
-
-    mo.hstack([
-        mo.md(f"**Division**: {division_input.value} ÷ {divisor_input.value}"),
-        mo.md(f"**Result**: {_result}")
-    ])
-    return (safe_divide,)
-
-
-@app.cell
-def _(mo):
-    # Multiple Exception Handling
     mo.md(
         """
-        ## Multiple Exception Handling
+        ## Handling multiple exception types
+        
         Catch and handle different types of errors specifically:
 
         ```python
@@ -188,64 +177,28 @@ def _(mo):
                 return "No division by zero!"
             except ValueError:
                 return "Conversion error!"
+            finally:
+                # The `finally` block always runs, regardless if there
+                # was an error or not
+                ...
+                
         ```
         """
     )
     return
 
 
-@app.cell
-def _(error_chain_input):
-    error_chain_input
-    return
-
-
-@app.cell
-def _(mo):
-    # Try it out
-    error_chain_input = mo.ui.text(
-        label="Try to break the code",
-        placeholder="Enter something tricky..."
-    )
-    return (error_chain_input,)
-
-
-@app.cell
-def _(error_chain_input, mo):
-    # Error chain demonstration
-    def tricky_function(input_str):
-        try:
-            # Simulating a error scenario
-            number = int(input_str)
-            result = 100 / number
-            return f"Success! Result: {result}"
-        except ValueError:
-            return "❌ Could not convert to number"
-        except ZeroDivisionError:
-            return "❌ Cannot divide by zero"
-        except Exception as e:
-            return f"🤯 Unexpected error: {type(e).__name__}"
-
-    result = tricky_function(error_chain_input.value)
-
-    mo.hstack([
-        mo.md(f"**Input**: {error_chain_input.value}"),
-        mo.md(f"**Result**: {result}")
-    ])
-    return result, tricky_function
-
-
-@app.cell
+@app.cell(hide_code=True)
 def _(finally_input):
     finally_input
     return
 
 
-@app.cell
+@app.cell(hide_code=True)
 def _(mo):
     # Finally Block Demonstration
     finally_input = mo.ui.switch(
-        label="Simulate Resource Management",
+        label="Throw an error?",
         value=True
     )
     return (finally_input,)
@@ -256,7 +209,7 @@ def _(finally_input, mo):
     def simulate_resource_management():
         try:
             # Simulating a resource-intensive operation
-            if finally_input.value:
+            if not finally_input.value:
                 return "🟢 Resource processing successful"
             else:
                 raise Exception("Simulated failure")
@@ -265,12 +218,13 @@ def _(finally_input, mo):
         finally:
             return "📦 Resource cleanup completed"
 
+
     _result = simulate_resource_management()
 
     mo.md(f"""
-    ### Resource Management Simulation
+    ### Example: the finally clause
 
-    **Scenario**: {'Normal operation' if finally_input.value else 'Error scenario'}
+    **Scenario**: {"Normal operation" if not finally_input.value else "An exception was raised"}
 
     **Result**: {_result}
 
@@ -279,22 +233,10 @@ def _(finally_input, mo):
     return (simulate_resource_management,)
 
 
-@app.cell(hide_code=True)
-def _(mo):
-    callout_text = mo.md("""
-    ## Your Error Handling Journey Continues!
-
-    Next Steps:
-
-    - Practice creating custom exceptions
-    - Explore context managers
-    - Build robust error-handling strategies
-
-    You're becoming a Python error-handling ninja! 🥷🐍
-    """)
-
-    mo.callout(callout_text, kind="success")
-    return (callout_text,)
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
 
 
 if __name__ == "__main__":