Day_13_Generators_in_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_13_Generators_in_Python.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZqDtEKTlvPnG"
      },
      "source": [
        "# **Generator Expressions:**\n",
        "\n",
        "Welcome to this lesson on Generators and Iterators!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oAjDh2xYqQVt"
      },
      "source": [
        "If you recall from the previous Lessons **Iterables** are objects that can return one of their elements at a time, such as a list. Many of the built-in functions we’ve used so far, like 'enumerate,' return an iterator.\n",
        "\n",
        "An **iterator** is an object that represents a stream of data. This is different from a list, which is also an iterable, but is not an iterator because it is not a stream of data.\n",
        "\n",
        "Mostly in diffrent situations you will see via the upcoming examples that iterables are preferred over iterators.\n",
        "\n",
        "Here we will learn to create iterators using generators.\n",
        "\n",
        "**Generators** are a simple way to create iterators using functions. However its not the only way to create a iteraore. You can also define iterators using **classes**, which you can read more about [here](https://docs.python.org/3/tutorial/classes.html#iterators).\n",
        "\n",
        "\n",
        "Here is an example of a generator function called ```my_range```, which produces an iterator that is a stream of numbers from 0 to (x - 1)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wor7g-pSqFPK"
      },
      "source": [
        "def my_range(x):\n",
        "    i = 0\n",
        "    while i < x:\n",
        "        yield i\n",
        "        i += 1"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vfLD27q4ryK_"
      },
      "source": [
        "Notice that instead of using the return keyword, it uses ``yield``. This allows the function to return values one at a time, and start where it left off each time it’s called. This ``yield`` keyword is what differentiates a generator from a typical function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m51RQD5trxTo",
        "outputId": "85a5126a-2544-46b5-cb1f-bd9bfdb789e7"
      },
      "source": [
        "print(my_range(4))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<generator object my_range at 0x7fdf30ce5f50>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6G6BdnlxsIsx"
      },
      "source": [
        "As you can see here calling `my_range(4)` returns an iterator that we can then iterate through.\n",
        "\n",
        "Remember, since this returns an iterator, we can convert it to a list or iterate through it in a loop to view its contents. For example, this code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jrGdr5pjsH68",
        "outputId": "b74679ee-3444-4924-bf0f-443146f7b79c"
      },
      "source": [
        "for x in my_range(5):\n",
        "    print(x)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XA4M_BQEtEE4"
      },
      "source": [
        "### **Why Generators when there are lists??**\n",
        "\n",
        "Generators are a lazy way to build iterables. They are useful when the fully realized list would not fit in memory, or when the cost to calculate each list element is high and you want to do it as late as possible. But they can only be iterated over once.\n",
        "\n",
        "I invite you to go through [this](https://docs.python.org/3.9/howto/functional.html#generator-expressions-and-list-comprehensions)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOwyxdurtgKx"
      },
      "source": [
        "## **Question:**\n",
        "\n",
        "Write your own generator function that works like the built-in function enumerate.\n",
        "\n",
        "Calling the function like this:\n",
        "\n",
        "```\n",
        "lessons = [\"Why Python Programming\", \"Data Types and Operators\", \"Control Flow\", \"Functions\", \"Scripting\"]\n",
        "\n",
        "for i, lesson in my_enumerate(lessons, 1):\n",
        "    print(\"Lesson {}: {}\".format(i, lesson))\n",
        "  ```\n",
        "\n",
        "  Should Output:\n",
        "\n",
        "  ```\n",
        "  Lesson 1: Why Python Programming\n",
        "  Lesson 2: Data Types and Operators\n",
        "  Lesson 3: Control Flow\n",
        "  Lesson 4: Functions\n",
        "  Lesson 5: Scripting\n",
        "  ```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QK40Um23sfLg"
      },
      "source": [
        "lessons = [\"Why Python Programming\", \"Data Types and Operators\", \"Control Flow\", \"Functions\", \"Scripting\"]\n",
        "\n",
        "def my_enumerate(iterable, start=0):\n",
        "    # Implement your generator function here\n",
        "\n",
        "\n",
        "for i, lesson in my_enumerate(lessons, 1):\n",
        "    print(\"Lesson {}: {}\".format(i, lesson))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OBVyoJMDuiqX"
      },
      "source": [
        "## **Question:**\n",
        "\n",
        "If you have an iterable that is too large to fit in memory in full (e.g., when dealing with large files), being able to take and use chunks of it at a time can be very valuable.\n",
        "\n",
        "Implement a generator function, `chunker`, that takes in an iterable and yields a chunk of a specified size at a time.\n",
        "\n",
        "Calling the function like this:\n",
        "\n",
        "```\n",
        "for chunk in chunker(range(25), 4):\n",
        "    print(list(chunk))\n",
        "  ```\n",
        "\n",
        "  Should Output:\n",
        "\n",
        "  ```\n",
        "  [0, 1, 2, 3]\n",
        "  [4, 5, 6, 7]\n",
        "  [8, 9, 10, 11]\n",
        "  [12, 13, 14, 15]\n",
        "  [16, 17, 18, 19]\n",
        "  [20, 21, 22, 23]\n",
        "  [24]\n",
        "  ```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AE9pRbsQuxef"
      },
      "source": [
        "def chunker(iterable, size):\n",
        "    # Implement function here\n",
        "\n",
        "\n",
        "for chunk in chunker(range(25), 4):\n",
        "    print(list(chunk))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KpVEohS1u4AL"
      },
      "source": [
        "## **Generator Expressions:**\n",
        "\n",
        "Here's a cool concept that combines generators and list comprehensions! You can actually create a generator in the same way you'd normally write a list comprehension, except with parentheses instead of square brackets.This can help you save time and create efficient code! \n",
        "\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pNmnqh0KvBOg"
      },
      "source": [
        "sq_list = [x**2 for x in range(10)]  # this produces a list of squares\n",
        "\n",
        "sq_iterator = (x**2 for x in range(10))  # this produces an iterator of squares"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vKRBjOt6vC_C",
        "outputId": "80173536-a739-4be1-c220-7a96c3ef5f70"
      },
      "source": [
        "print(sq_list)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2xQIV_2YvFxj",
        "outputId": "9ed41b14-5eeb-408c-a327-74b93044b014"
      },
      "source": [
        "print(sq_iterator)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<generator object <genexpr> at 0x7fdf2d1d08d0>\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}