Python_Generator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_Generator.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMxfUcw4W+LqhxY6XCPyJWB",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wenxuan0923/My-notes/blob/master/Python_Generator.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KaqHMzlbAff9"
      },
      "source": [
        "## Generators in Python\n",
        "\n",
        "The most convenient technique for **creating iterators** in Python\n",
        "is through the use of generators. **Generator functions** are a special kind of function that return a **lazy iterator**, which does not store their contents in memory. \n",
        "\n",
        "A generator is implemented with a syntax that is very similar to a function, but instead of returning values, a **yield** statement is executed to indicate each element of the series. The use of the keyword **yield** rather than **return** to indicate a result indicates to Python that we are defining a generator, rather than a traditional function. \n",
        "\n",
        "It is illegal to combine yield and return statements in the same implementation, other than a zero-argument return statement to cause a generator to end its execution.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "silJrPLB_yTG"
      },
      "source": [
        "def factors(n):\n",
        "  for k in range(1, n+1):\n",
        "    if n % k == 0:\n",
        "      yield k"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xqE51MTaAF1m",
        "outputId": "651fcfe8-0e22-4586-c370-6ebfda6fcedf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "gen = factors(12)\n",
        "gen"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<generator object factors at 0x7fa029520c50>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nuGLBbktBdVI"
      },
      "source": [
        "As an example, consider the goal\n",
        "of determining all factors of a positive integer. For example, the number 12 has factors 1, 2, 3, 4, 6, 12."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uL5NccR1AVEo",
        "outputId": "2ec2e4be-81f0-42fe-b21d-c7c21aa6f318",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "6\n",
            "12\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-vfmSOO1C4SE"
      },
      "source": [
        "When the flow of control naturally reaches the end of our procedure (or a zero-argument return statement), a **StopIteration** exception is automatically raised."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0alpNYKhBD1z",
        "outputId": "48031b1f-5ad3-4b93-9205-c78c8e3ef33c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 163
        }
      },
      "source": [
        "print(next(gen))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "StopIteration",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-12-be0d7584d73f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mStopIteration\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dBJ3HiTAC64H"
      },
      "source": [
        "The benefits of **lazy evaluation** when using a\n",
        "generator rather than a traditional function. The results are only computed if requested, and the entire series need not reside in memory at one time. In fact, a generator can effectively produce an infinite series of values. As an example, the Fibonacci numbers form a classic mathematical sequence, starting with value 0, then value 1, and then each subsequent value being the sum of the two preceding values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5gM7QfgWDave"
      },
      "source": [
        "def fibonacci():\n",
        "  a = 0; \n",
        "  b = 1;\n",
        "  while True:\n",
        "    yield a\n",
        "    next = a + b\n",
        "    a = b\n",
        "    b = next"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lKglXHOYEArw",
        "outputId": "f828b583-283c-4d14-fe30-98d5f73c4908",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 136
        }
      },
      "source": [
        "# Create the iterator\n",
        "fib = fibonacci()\n",
        "\n",
        "# Iterate through the iterator\n",
        "print(next(fib))\n",
        "print(next(fib))\n",
        "print(next(fib))\n",
        "print(next(fib))\n",
        "print(next(fib))\n",
        "print(next(fib))\n",
        "print(next(fib))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EL6V3pF3H9DQ"
      },
      "source": [
        "**Generator comprehension**: similar to the list comprehension \n",
        "```[k*k for k in range(n)]```, we can produce generator using generator comprehension syntax like below. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jAUzdzCrH8Vc"
      },
      "source": [
        "gen = (k*k for k in range(1, 100))"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G9t8i0yvH8X-",
        "outputId": "4966080c-dc02-416f-921a-545d67da0257",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))\n",
        "print(next(gen))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "4\n",
            "9\n",
            "16\n",
            "25\n",
            "36\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aaTxpzUgJOD_"
      },
      "source": [
        "It is particularly attractive when results do not need to be stored in memory."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qB8apltFH8aT",
        "outputId": "debb665c-b3bf-4c14-b462-0585bce200c6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "sum(k*k for k in range(1, 10))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "285"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    }
  ]
}