diff --git a/community-contributions/dkisselev-zz/week1/week1 EXERCISE.ipynb b/community-contributions/dkisselev-zz/week1/week1 EXERCISE.ipynb index ef18461..5b4df5d 100644 --- a/community-contributions/dkisselev-zz/week1/week1 EXERCISE.ipynb +++ b/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": [ - "" - ] - }, - "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": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Get Llama 3.2 to answer\n", "\n",