flatten python structure

Python/{phase_1/string_manipulation.py → 002_strings.py}

@@ -7,7 +7,7 @@
 
 import marimo
 
-__generated_with = "0.10.12"
+__generated_with = "0.10.14"
 app = marimo.App()
 
 
@@ -21,20 +21,20 @@ def _():
 def _(mo):
     mo.md(
         """
-        # 🎭 Strings
+        # 🔢 Numbers in Python
 
-        Dive into the world of Python strings — where text comes to life! 
+        Let's explore how Python handles numbers and mathematical operations! 
 
-        ## Creating strings
-        In Python, strings are containers for text. You can create them in two simple
-        ways:
+        ## Number Types
+        Python has several types of numbers:
 
         ```python
-        greeting = "Hello, Python!"  # using double quotes
-        name = 'Alice'               # using single quotes
+        integer = 42          # whole numbers (int)
+        decimal = 3.14        # floating-point numbers (float)
+        complex_num = 2 + 3j  # complex numbers
         ```
 
-        Below is an example string.
+        Below is an example number we'll use to explore operations.
         """
     )
     return
@@ -42,70 +42,69 @@ def _(mo):
 
 @app.cell
 def _():
-    text = "Python is amazing"
-    return (text,)
+    number = 42
+    return (number,)
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Essential string operations
+        ## Basic Mathematical Operations
 
-        Here are some methods for working with strings.
+        Python supports all standard mathematical operations.
 
-        Tip: Try changing the value of `text` above, and watch how the
-        computed values below change.
+        Try changing the value of `number` above and watch how the results change.
         """
     )
     return
 
 
 @app.cell
-def _(text):
-    len(text)
+def _(number):
+    number + 10  # Addition
     return
 
 
 @app.cell
-def _(text):
-    text.upper()
+def _(number):
+    number - 5  # Subtraction
     return
 
 
 @app.cell
-def _(text):
-    text.lower()
+def _(number):
+    number * 3  # Multiplication
     return
 
 
 @app.cell
-def _(text):
-    text.title()
+def _(number):
+    number / 2  # Division (always returns float)
     return
 
 
 @app.cell(hide_code=True)
 def _(mo):
-    mo.md("""Use string methods and the `in` operator to find things in strings.""")
+    mo.md("""Python also has special division operators and power operations.""")
     return
 
 
 @app.cell
-def _(text):
-    text.find('is')
+def _(number):
+    number // 5  # Floor division (rounds down)
     return
 
 
 @app.cell
-def _(text):
-    "Python" in text
+def _(number):
+    number % 5  # Modulus (remainder)
     return
 
 
 @app.cell
-def _(text):
-    "Javascript" in text
+def _(number):
+    number ** 2  # Exponentiation
     return
 
 
@@ -113,12 +112,9 @@ def _(text):
 def _(mo):
     mo.md(
         """
-        ## Inserting values in strings
+        ## Type Conversion
 
-        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.
+        You can convert between different number types. Try changing these values!
         """
     )
     return
@@ -126,13 +122,19 @@ def _(mo):
 
 @app.cell
 def _():
-    my_name = ''
-    return (my_name,)
+    decimal_number = 3.14
+    return (decimal_number,)
+
+
+@app.cell
+def _(decimal_number):
+    int(decimal_number)  # Convert to integer (truncates decimal part)
+    return
 
 
 @app.cell
-def _(my_name):
-    f"Hello, {my_name}!"
+def _(number):
+    float(number)  # Convert to float
     return
 
 
@@ -140,65 +142,62 @@ def _(my_name):
 def _(mo):
     mo.md(
         """
-        ## Working with Parts of Strings
-        You can access any part of a string using its position (index):
+        ## Built-in Math Functions
+        Python provides many useful built-in functions for working with numbers:
         """
     )
     return
 
 
 @app.cell
-def _(text):
-    first_letter = text[0]
-    first_letter
-    return (first_letter,)
+def _(number):
+    abs(-number)  # Absolute value
+    return
 
 
 @app.cell
-def _(text):
-    last_letter = text[-1]
-    last_letter
-    return (last_letter,)
+def _():
+    round(3.14159, 2)  # Round to 2 decimal places
+    return
 
 
 @app.cell
-def _(text):
-    first_three = text[0:3]
-    first_three
-    return (first_three,)
+def _():
+    max(1, 5, 3, 7, 2)  # Find maximum value
+    return
 
 
 @app.cell
-def _(text):
-    last_two = text[-2:]
-    last_two
-    return (last_two,)
+def _():
+    min(1, 5, 3, 7, 2)  # Find minimum value
+    return
 
 
 @app.cell(hide_code=True)
 def _(mo):
     mo.md(
         """
-        ## Other helpful string methods
+        ## Advanced Math Operations
 
-        Finally, here are some other helpful string methods. Feel free to try them out on your own strings!
+        For more complex mathematical operations, Python's `math` module is your friend:
 
         ```python
-        sentence = "  python is fun  "
+        import math
 
-        # Remove extra spaces
-        print(sentence.strip())        # "python is fun"
+        # Square root
+        math.sqrt(16)    # 4.0
 
-        # Split into a list of words
-        print(sentence.split())        # ['python', 'is', 'fun']
+        # Trigonometry
+        math.sin(math.pi/2)  # 1.0
+        math.cos(0)      # 1.0
 
-        # Replace words
-        print(sentence.replace('fun', 'awesome'))
+        # Constants
+        math.pi          # 3.141592653589793
+        math.e           # 2.718281828459045
 
-        # 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?
+        # Logarithms
+        math.log10(100)  # 2.0
+        math.log(math.e) # 1.0
         ```
         """
     )
@@ -208,17 +207,17 @@ def _(mo):
 @app.cell(hide_code=True)
 def _(mo):
     callout_text = mo.md("""
-    ## Your String Journey Begins!
+    ## Master the Numbers!
 
     Next Steps:
 
-    - Try combining different string methods
+    - Practice different mathematical operations
 
-    - Practice with f-strings
+    - Experiment with type conversions
 
-    - Experiment with string slicing
+    - Try out the math module functions
 
-    You're doing great! 🐍✨
+    Keep calculating! 🧮✨
     """)
 
     mo.callout(callout_text, kind="success")