Add interactive Python collections tutorial

Python/phase_1/collections.py

@@ -0,0 +1,337 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#     "marimo",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.10.14"
+app = marimo.App()
+
+
+@app.cell
+def _():
+    import marimo as mo
+    return (mo,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        # 📦 Collections in Python
+
+        Explore Python's built-in collection types — the essential data structures! 
+
+        ## Lists
+        Lists are ordered, mutable sequences. Create them using square brackets:
+
+        ```python
+        fruits = ["apple", "banana", "orange"]
+        numbers = [1, 2, 3, 4, 5]
+        mixed = [1, "hello", 3.14, True]  # Can contain different types
+        ```
+
+        Below is an example list we'll use to explore operations.
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    sample_list = [1, 2, 3, 4, 5]
+    return (sample_list,)
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ## List Operations
+
+        Here are common operations you can perform on lists.
+
+        Try changing the values in `sample_list` above and watch the results change.
+        """
+    )
+    return
+
+
+@app.cell
+def _(sample_list):
+    len(sample_list)  # List length
+    return
+
+
+@app.cell
+def _(sample_list):
+    sample_list.append(6)  # Add item to end
+    sample_list
+    return
+
+
+@app.cell
+def _(sample_list):
+    sample_list[0]  # Access first element
+    return
+
+
+@app.cell
+def _(sample_list):
+    sample_list[-1]  # Access last element
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ### Try marimo's Array Interface!
+
+        Explore how marimo handles arrays with this interactive element:
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    item = mo.ui.text(placeholder="Enter list item")
+    items = mo.ui.array([item] * 3, label="Create a list of 3 items")
+    return item, items
+
+
+@app.cell
+def _(items, mo):
+    mo.hstack(
+        [
+            items,
+            mo.md(f"Your list: {items.value}")
+        ],
+        justify="space-between"
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    _text = mo.md("""
+        - Try entering different types of items
+        - Watch how the list updates in real-time
+
+        This is a great way to experiment with list creation!
+    """)
+    mo.accordion({"💡 Interactive List Builder Tips": _text})
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ## Tuples
+
+        Tuples are immutable sequences. They're like lists that can't be changed after creation:
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    coordinates = (10, 20)
+    return (coordinates,)
+
+
+@app.cell
+def _(coordinates):
+    x, y = coordinates  # Tuple unpacking
+    x
+    return x, y
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ## Dictionaries
+
+        Dictionaries store key-value pairs. They're perfect for mapping relationships:
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    person = {
+        "name": "John Doe",
+        "age": 25,
+        "city": "New York"
+    }
+    return (person,)
+
+
+@app.cell
+def _(person):
+    person["name"]  # Access value by key
+    return
+
+
+@app.cell
+def _(person):
+    person.keys()  # Get all keys
+    return
+
+
+@app.cell
+def _(person):
+    person.values()  # Get all values
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ### Try marimo's Dictionary Interface!
+
+        Create your own dictionary using marimo's interactive elements:
+        """
+    )
+    return
+
+
+@app.cell
+def _(mo):
+    key1 = mo.ui.text(placeholder="Key 1")
+    value1 = mo.ui.text(placeholder="Value 1")
+    key2 = mo.ui.text(placeholder="Key 2")
+    value2 = mo.ui.text(placeholder="Value 2")
+
+    dictionary = mo.ui.dictionary(
+        {
+            "First key": key1,
+            "First value": value1,
+            "Second key": key2,
+            "Second value": value2,
+        }
+    )
+
+    return dictionary, key1, key2, value1, value2
+
+
+@app.cell
+def _(dictionary, mo):
+    mo.hstack(
+        [
+            dictionary,
+            mo.md(f"Your dictionary: {dictionary.value}")
+        ],
+        justify="space-between"
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    _text = mo.md("""Enter key-value pairs to build your dictionary
+        
+        - Watch how the dictionary updates as you type
+        
+        - Try different types of values
+
+        This interactive builder helps understand dictionary structure!
+    """)
+    mo.accordion({"💡 Dictionary Builder Tips": _text})
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ## Sets
+
+        Sets are unordered collections of unique elements:
+        """
+    )
+    return
+
+
+@app.cell
+def _():
+    numbers_set = {1, 2, 3, 3, 2, 1}  # Duplicates are removed
+    return (numbers_set,)
+
+
+@app.cell
+def _(numbers_set):
+    numbers_set.add(4)  # Add new element
+    numbers_set
+    return
+
+
+@app.cell
+def _():
+    set1 = {1, 2, 3}
+    set2 = {3, 4, 5}
+    set1.intersection(set2)  # Find common elements
+    return set1, set2
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    mo.md(
+        """
+        ## Collection Methods and Operations
+
+        Here are some common operations across collections:
+
+        ```python
+        # Lists
+        my_list = [1, 2, 3]
+        my_list.insert(0, 0)     # Insert at position
+        my_list.remove(2)        # Remove first occurrence
+        my_list.sort()           # Sort in place
+        sorted_list = sorted(my_list)  # Return new sorted list
+
+        # Dictionaries
+        my_dict = {"a": 1}
+        my_dict.update({"b": 2})  # Add new key-value pairs
+        my_dict.get("c", "Not found")  # Safe access with default
+
+        # Sets
+        set_a = {1, 2, 3}
+        set_b = {3, 4, 5}
+        set_a.union(set_b)       # Combine sets
+        set_a.difference(set_b)  # Elements in A but not in B
+        ```
+        """
+    )
+    return
+
+
+@app.cell(hide_code=True)
+def _(mo):
+    callout_text = mo.md("""
+    ## Collection Mastery Awaits!
+
+    Next Steps:
+
+    - Practice list and dictionary comprehensions
+    - Experiment with nested collections
+    - Try combining different collection types
+
+    Keep organizing data! 🗃️✨
+    """)
+
+    mo.callout(callout_text, kind="success")
+    return (callout_text,)
+
+
+if __name__ == "__main__":
+    app.run()