EX_17/ex_17_generators_in_python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "ex_17_generators_in_python.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gymnA5qCSd2e"
      },
      "source": [
        "#GENERATORS IN PYTHON\n",
        "\n",
        "Generators in Python allows us to write a function that can send back a value and then later resume to pick up where it left off.\n",
        "Let's start with a fibonacci function: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k5Q0F07BDpZ9",
        "outputId": "fd513749-c894-4dba-dc53-08e0779d864f"
      },
      "source": [
        "# Program to display the Fibonacci sequence up to n-th term\n",
        "\n",
        "nterms = int(input(\"How many terms? \"))\n",
        "\n",
        "# first two terms\n",
        "n1, n2 = 0, 1\n",
        "count = 0\n",
        "\n",
        "# check if the number of terms is valid\n",
        "if nterms <= 0:\n",
        "   print(\"Please enter a positive integer\")\n",
        "elif nterms == 1:\n",
        "   print(\"Fibonacci sequence up to\",nterms,\":\")\n",
        "   print(n1)\n",
        "else:\n",
        "   print(\"Fibonacci sequence:\")\n",
        "   while count < nterms:\n",
        "       print(n1)\n",
        "       nth = n1 + n2\n",
        "       # update values\n",
        "       n1 = n2\n",
        "       n2 = nth\n",
        "       count += 1"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "How many terms? 10\n",
            "Fibonacci sequence:\n",
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3cLHAYvLSSW7"
      },
      "source": [
        "YET A SIMPLE FUNCTION FOR FIBONACCI ALGORITHM:\n",
        "\n",
        "Let's simplify the code for this lesson, consider this piece of code:\n",
        "(Zero out:)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TGITNwlQSQc0"
      },
      "source": [
        "def gen_fibo(n):\n",
        "  a = 1\n",
        "  b = 1\n",
        "  output = []\n",
        "  for i in range(n):\n",
        "    output.append(a)\n",
        "    a,b = b, a + b\n",
        "  return output"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mn6saG-yT4XG",
        "outputId": "6fcbdf16-3274-4789-8e52-7b87bdde9880"
      },
      "source": [
        "gen_fibo(10)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "63pa7VH10uFa"
      },
      "source": [
        "This function is not a Generator:/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SyFYeLKGXpWc"
      },
      "source": [
        "Now using **yield** keyword in the original fibo function to turn it more memory efficient :-)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FlWsJi-xUDUk"
      },
      "source": [
        "def gen_fibo(n):\n",
        "  a = 1\n",
        "  b = 1\n",
        "  for i in range(n - 1):\n",
        "    yield a\n",
        "    a, b = a, a + b"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zjx0NNB9Uj0X",
        "outputId": "8f14b2b7-d44c-46cb-a134-b0c076241ac2"
      },
      "source": [
        " g = gen_fibo(10)\n",
        " g"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<generator object gen_fibo at 0x7f5ae6120350>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L_rQ3sCe09eU"
      },
      "source": [
        "Now, it is a Generator!\n",
        "\n",
        "Do you see the difference? No? So keep reading ..."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pHGhcY9ExaFg"
      },
      "source": [
        "This last function is a Generator. What is a Generator after all?\n",
        "\n",
        "A Generators it is much more efficient in relation to the use of memory; we are not loading the data completely, in memory, as in the code with append (); \n",
        "\n",
        "We only work in streams, that is, we save the only the data that immediately preceding it, and thus we are saving memory; the object is much more simpler:)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a4f6yR-7zgfi"
      },
      "source": [
        "###Another interactable function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TaNSvKr3UleO"
      },
      "source": [
        "# Let's see another generator:\n",
        "def simple_gen():\n",
        "  for x in range (4):\n",
        "    yield x"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r3ZfH_8mU2uA",
        "outputId": "5ac02dd6-a981-417e-e582-fd1cbc62339d"
      },
      "source": [
        "g = simple_gen()\n",
        "g"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<generator object simple_gen at 0x7f5ae6120750>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Tg7Ow0xWVOz0",
        "outputId": "94bc9789-d9a9-4e20-e5a1-300b2e8f1c2d"
      },
      "source": [
        "# See that the Generator object can be readily interacted with; it is built to be :)\n",
        "next(g)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y1EuK6nUVghZ",
        "outputId": "de525593-96d0-4b57-f856-fa171cc2c528"
      },
      "source": [
        "next(g)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xh4Vvnq9WdIw",
        "outputId": "e9a9995e-b023-4066-c2ad-872a9de254a3"
      },
      "source": [
        "next(g)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o11E04TXWmbp",
        "outputId": "e8fa6e98-a264-45f2-a99a-df2684e56c69"
      },
      "source": [
        "next(g)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "igIxMZUpzXBr"
      },
      "source": [
        "###*Strings* Are interactables?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LG0vNjLwzNXh"
      },
      "source": [
        "Now, let's see if a string object is interactable..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kfa9fwKvWpNu"
      },
      "source": [
        "s = 'hello'"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M6RtnNrVWy6M",
        "outputId": "f69081a6-4e7d-41c4-ea32-eb02b12b958a"
      },
      "source": [
        "for letter in s:\n",
        "  print(letter)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "h\n",
            "e\n",
            "l\n",
            "l\n",
            "o\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "id": "FC6EY0cPW6AB",
        "outputId": "98753602-859c-44b5-e736-058d861cf787"
      },
      "source": [
        "# String is not interactable:/\n",
        "next(s)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-14-46f008985a16>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# String is not interactable:/\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'str' object is not an iterator"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "F3MMVsaRXKP2",
        "outputId": "187597ca-d2e9-4b19-918c-d607371f94ea"
      },
      "source": [
        "# For transforming Strings into an interactable object use iter() function:\n",
        "s_iter = iter(s)\n",
        "next(s_iter)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'h'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "9Ne29bT2Xc1B",
        "outputId": "dcb19489-9c98-461d-e414-d7658e0f0e1c"
      },
      "source": [
        "next(s_iter)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'e'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TrCXvaBH3j31"
      },
      "source": [
        "So, here is the final generator code for our fibonacci function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UC5HhX2UXgR9"
      },
      "source": [
        "def prog_fibo_2(n):\n",
        "  a = 1\n",
        "  b = 1\n",
        "  for i in range(n):\n",
        "    yield a\n",
        "    a, b = b, a + b"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MytYH_7pYNSm",
        "outputId": "7565ed91-50c4-4908-e971-1407a09d4d17"
      },
      "source": [
        "g = prog_fibo_2(10)\n",
        "g "
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<generator object prog_fibo_2 at 0x7f5ae605ded0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YtyjxP3XYT17",
        "outputId": "4f7df1da-9f3a-4666-cb72-284ef780607f"
      },
      "source": [
        "next(g)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "omVxBvMXYa5s",
        "outputId": "33c97370-1f8f-484c-bcd6-2d22f6edbba6"
      },
      "source": [
        "next(g)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mnCkVgSbYeXL",
        "outputId": "1e870404-eeb4-4139-980c-bcae0e281c81"
      },
      "source": [
        "next(g)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uWKM6O04YnBC",
        "outputId": "7308ecec-6af1-4893-f1de-ecac49fc6f5e"
      },
      "source": [
        "for number in prog_fibo_2(10):\n",
        "  print(number)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vyLl-nvVvuak"
      },
      "source": [
        "##Profiling and Timing Code"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LWP-pvmhv-As"
      },
      "source": [
        "<!--BOOK_INFORMATION-->\n",
        "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n",
        "\n",
        "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FMrpWCiwcNH8",
        "outputId": "9cb19358-c523-4480-a00f-6528726006ca"
      },
      "source": [
        "pip install memory_profiler"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: memory_profiler in /usr/local/lib/python3.7/dist-packages (0.58.0)\n",
            "Requirement already satisfied: psutil in /usr/local/lib/python3.7/dist-packages (from memory_profiler) (5.4.8)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vm6j8kYrdDLo"
      },
      "source": [
        "%load_ext memory_profiler"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e4QqwFAQ4XcC"
      },
      "source": [
        "def gen_fibo(n):\n",
        "  a = 1\n",
        "  b = 1\n",
        "  output = []\n",
        "  for i in range(n):\n",
        "    output.append(a)\n",
        "    a,b = b, a + b\n",
        "  return output"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NMTtNkcrY-C6",
        "outputId": "0af4efa8-c661-4ffb-e4d5-dddc2d6e4ebd"
      },
      "source": [
        "%timeit gen_fibo(10)"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The slowest run took 4.87 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 5: 1.3 µs per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GSEuETdZ4jna"
      },
      "source": [
        "def prog_fibo_2(n):\n",
        "  a = 1\n",
        "  b = 1\n",
        "  for i in range(n):\n",
        "    yield a\n",
        "    a, b = b, a + b"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ILU_bhP7bp4l",
        "outputId": "54f21037-d756-4399-b59e-9110f5bf33a6"
      },
      "source": [
        "%timeit prog_fibo_2(10)"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The slowest run took 13.22 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
            "1000000 loops, best of 5: 235 ns per loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8v5UX2s1TZJT"
      },
      "source": [
        "As you can see, the code using the python generator is running in the **nanoseconds**, instead of microseconds (1000x faster!)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vb8P18-UTf0j"
      },
      "source": [
        "If you find this post helpful, please consider to subscribe to the Jungletronics for more posts like this.\n",
        "Until next time!\n",
        "I wish you excellent day!\n",
        "Be safe!\n",
        "Cheers!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rchCSuxK43xa",
        "outputId": "4537ca6b-04aa-402c-d7cf-4c58c03ddd8a"
      },
      "source": [
        "print(\"That's it! thank you for reading his episode about the wonders of Python:) \")"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "That's it! thank you for reading his episode about the wonders of Python:) \n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}