cleanup of the output

community-contributions/dkisselev-zz/week1/week1 EXERCISE.ipynb

@@ -13,7 +13,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "c1070317-3ed9-4659-abe3-828943230e03",
    "metadata": {},
    "outputs": [],
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "4a456906-915a-4bfd-bb9d-57e505c5093f",
    "metadata": {},
    "outputs": [],
@@ -42,18 +42,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "a8d7923c-5f28-4c30-8556-342d7c8497c1",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "API key looks good so far\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# set up environment\n",
     "\n",
@@ -71,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "3f0d0137-52b0-47a8-81a8-11a90a010798",
    "metadata": {},
    "outputs": [],
@@ -86,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "df0d958f",
    "metadata": {},
    "outputs": [],
@@ -104,7 +96,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "13506dd4",
    "metadata": {},
    "outputs": [],
@@ -117,55 +109,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "60ce7000-a4a5-4cce-a261-e75ef45063b4",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "Certainly! Let's break down the code you've provided:\n",
-       "\n",
-       "### Code Explanation\n",
-       "\n",
-       "```python\n",
-       "yield from {book.get(\"author\") for book in books if book.get(\"author\")}\n",
-       "```\n",
-       "\n",
-       "#### Components of the Code:\n",
-       "\n",
-       "1. **Set Comprehension**:\n",
-       "   - `{book.get(\"author\") for book in books if book.get(\"author\")}`: This part of the code is a **set comprehension**. It creates a set of authors by iterating through a collection called `books`.\n",
-       "   - `book.get(\"author\")`: This method retrieves the value associated with the key `\"author\"` from each `book` dictionary. If the specified key does not exist, `None` is returned.\n",
-       "   - `if book.get(\"author\")`: This condition filters out any authors that are `None` or any falsy value, ensuring that only valid authors are included in the set.\n",
-       "\n",
-       "2. **Yielding Values**:\n",
-       "   - `yield from`: This keyword is used in Python to yield values from a generator or an iterable. In this context, it takes the set created from the set comprehension and yields each author one at a time.\n",
-       "\n",
-       "### What the Code Does\n",
-       "\n",
-       "- The code iterates over a collection of `books`, each of which is expected to be a dictionary. For each book, it checks if the `\"author\"` key exists and has a valid value (not `None` or falsy).\n",
-       "- It collects all unique authors into a set to ensure no duplicates are included. The use of a set here also makes looking up authors efficient.\n",
-       "- Finally, it yields each author one at a time, allowing the consuming code to process each author individually.\n",
-       "\n",
-       "### Why Use This Code?\n",
-       "\n",
-       "- **Unique Values**: Using a set guarantees that each author is only yielded once, even if multiple books have the same author.\n",
-       "- **Memory Efficiency**: Using `yield from` allows handling potentially large collections of authors efficiently without having to store them all in memory at once.\n",
-       "- **Ease of Use**: This pattern is useful for generating a stream of results where the number of authors is not known in advance, and the consumer can process each author as it arrives.\n",
-       "\n",
-       "### Summary\n",
-       "\n",
-       "This code is effective for extracting unique authors from a list of book dictionaries, yielding each author for further processing without duplicates and in an efficient manner."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get gpt-4o-mini to answer, with streaming\n",
     "\n",
@@ -177,62 +124,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "8f7c8ea8-4082-4ad0-8751-3301adcf6538",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/markdown": [
-       "**Understanding Recursive Yield**\n",
-       "\n",
-       "```python\n",
-       "yield from {book.get(\"author\") for book in books if book.get(\"author\")}\n",
-       "```\n",
-       "is a piece of Python code that utilizes the `yield from` syntax to delegate iterations over a sub-generators. This allows us to generate an iterable sequence one step at a time, avoiding memory overhead.\n",
-       "\n",
-       "### Breakdown\n",
-       "\n",
-       "*   `{book.get(\"author\") for book in books if book.get(\"author\")}` is a generator expression:\n",
-       "    *   It defines a small, anonymous function (lambda-like) that takes `books` as input.\n",
-       "    *   For each item `book` in `books`, it calls another function (`get`) to retrieve the `\"author\"` attribute from an object.\n",
-       "    *   The resulting values are generated on-the-fly and sent through the generator expression.\n",
-       "*   `yield from …`: The outer expression uses `yield from` to delegate control over iterations to the inner nested generator.\n",
-       "    *   Instead of dealing with each iterable individually, `yield from` sends its arguments down into the first argument, which it executes and yields values on.\n",
-       "\n",
-       "**Equivalent Code**\n",
-       "\n",
-       "Here is an equivalent version of this code using traditional loops:\n",
-       "\n",
-       "```python\n",
-       "def book_authors(books):\n",
-       "    authors = []\n",
-       "    for book in books:\n",
-       "        if \"author\" in book:\n",
-       "            author_name = book[\"author\"]\n",
-       "            yield from (author_name,)\n",
-       "            authors.append(author_name)\n",
-       "\n",
-       "# To use this function with our recursive yield version \n",
-       "# you can use it like so\n",
-       "for author_name in book_authors(books):\n",
-       "    # Use this here\n",
-       "```\n",
-       "\n",
-       "### Why is Yield From useful?\n",
-       "\n",
-       "In programming languages that natively don't support nested generator iterations (like CPython), using `yield from` allows for elegant implementation of cooperative multitasking. It also simplifies the logic of writing generators.\n",
-       "\n",
-       "Note: However, all such recursive-yield constructions rely on Python’s behavior towards generator expressions in its specific use-case."
-      ],
-      "text/plain": [
-       "<IPython.core.display.Markdown object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Get Llama 3.2 to answer\n",
     "\n",