english/6_WhileLoop.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true
      },
      "source": [
        "# Introduction to Programming with Python\n",
        "\n",
        "# Unit 6: While Loop\n",
        "\n",
        "We ended the previous unit with an excercise to draw three polygons. Let's start with defining a function that will draw one polygon with specified number of sides `n` and length of each side `x`. To do it, we need to repeat drawing a side of length `x` `n` times, turning by a certain angle in between. Since we need to turn 360 degrees after drawing all sides, each individual angle would be $360/n$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Run this cell if you are using the tutorial via Google Colab\n",
        "!pip install jturtle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "import jturtle as turtle\n",
        "\n",
        "def poly(n,x):\n",
        "    angle = 360/n\n",
        "    for _ in range(n):\n",
        "        turtle.forward(x)\n",
        "        turtle.right(angle)\n",
        "\n",
        "poly(6,100)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now, to draw three polygons with $n=3$, $5$ and $7$, we need a loop iterating over those numbers. This can either be accomplished by specifying all numbers in a list (like in the example below), or using clever `range` expression `range(3,8,2)`, or by looping `i` over numbers 0,1,2 with `range(3)`, and then calculating `n=3+2*i`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "for i in [3,5,7]:\n",
        "    poly(i,500/i)\n",
        "    turtle.penup()\n",
        "    turtle.right(90)\n",
        "    turtle.forward(200)\n",
        "    turtle.left(90)\n",
        "    turtle.forward(20)\n",
        "    turtle.pendown()\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Another trick that we do here is to decrease the size `x` as number of sides grows bigger. If we do not do it, each following $n$-gon will look  larger. You can experiment with the code above, putting constant size, or changing an expression on how it depends on $n$. \n",
        "\n",
        "By the way, we can create some nice graphics with `poly` function as well:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "for i in range(10):\n",
        "    poly(6,100)\n",
        "    turtle.right(36)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## While Loop\n",
        "\n",
        "The loop we have learnt about so far is called `for`-loop, and it is useful when we know in advance how many times we need to repeat the process. However, there are some cases when this number is not known. Suppose we want to generate random quadratic equation that has solutions, using our function `random_equation` defined previously. In this case we probably need to generate random coefficients, and if the equation does not have solutions - repeat this process again. This can be achieved using another loop: **while** loop.\n",
        "\n",
        "While loop looks like this:\n",
        "\n",
        "```python\n",
        "while condition:\n",
        "    action\n",
        "```\n",
        "\n",
        "The code is executed in the following way:\n",
        "1. `condition` is checked. If it is `False` - loop ends, execution continues from the code following the loop\n",
        "2. If `condition` was `True` - action is executed\n",
        "3. Evething repeats from step 1\n",
        "\n",
        "It is worth noticing that `condition` should probably change inside the loop, i.e. some variables that are used within condition should change. In our case, we will generate new equation coefficients inside the loop, and check if it has solutions in the loop condition.\n",
        "\n",
        "So, the code to generate \"good\" equation can look like this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(3, 0, 10)\n"
          ]
        }
      ],
      "source": [
        "from pycourse import random_equation,solve\n",
        "\n",
        "def random_good_equation():\n",
        "    a,b,c = random_equation()\n",
        "    while solve(a,b,c)!=None:\n",
        "        a,b,c = random_equation()\n",
        "    return a,b,c\n",
        "\n",
        "print(random_good_equation())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In fact, there is more than one way to write `while`-loop in our case. The solution above has one small drawback - we need to write a call to `random_equation` twice. This can be avoided by using a variable that will contain the flag (`True`/`False` value) to indicate if the solution has been found:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(-1, -10, 12)\n"
          ]
        }
      ],
      "source": [
        "def random_good_equation():\n",
        "    solution_found = False\n",
        "    while not solution_found:\n",
        "        a,b,c = random_equation()\n",
        "        solution_found = (solve(a,b,c)!=None)\n",
        "    return a,b,c\n",
        "\n",
        "print(random_good_equation())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "slideshow": {
          "slide_type": ""
        }
      },
      "source": [
        "Notice how variable `solution_found` contains a true/false value, and how we can assign the result of comparison `solve(a,b,c)!=None` directly to this variable. Such true/false values are called **boolean values**, and it is one more type of values that Python can operate on (in addition to integers, floating point numbers and strings).\n",
        "\n",
        "Yet one more way to think about this task is to write a condition when the loop should end. This can be accomplished by using `break` keyword, which is used to leave the loop. In this case we will write the loop as an **endless loop**, and then specify the exit condition:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(-1, -7, -4)\n"
          ]
        }
      ],
      "source": [
        "def random_good_equation():\n",
        "    while True:\n",
        "        a,b,c = random_equation()\n",
        "        if solve(a,b,c)!=None:\n",
        "            break\n",
        "    return a,b,c\n",
        "\n",
        "print(random_good_equation())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Some Numerology\n",
        "\n",
        "Let us consider one more example of using while loops, related to [numerology](https://en.wikipedia.org/wiki/Numerology) - a set of beliefs that numbers have some magical influence on our lives. Not implying that those beliefs are true, we will write a function that will help numerologists in one of their frequently used tasks: computing the number corresponding to some date. In order to do this, they often add up all individual digits of a number, until they get a single-digit number.\n",
        "\n",
        "First, let us write a function that adds up all digits in a number. Note, that given a number $n$ (say, 123) we can compute its last (right-most) digit by dividing it by 10 and taking the remainder (123 % 10 = 3). Also, we can drop right-most digits by dividing the number by 10, and taking the whole part (this operation, **integer division**, is denoted in Python by `//`, so 123//10 = 12).\n",
        "\n",
        "The function to add all digits will be implemented using while-loop, because we will add up all digits while there is still something to add. At some point, when dividing a number by 10, we will get 0 - and it will indicate the end of the loop:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def sum_digits(x):\n",
        "    acc = 0\n",
        "    while x>0:\n",
        "        acc += x%10\n",
        "        x = x//10\n",
        "    return acc\n",
        "\n",
        "sum_digits(12345)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "However, numberologist will not stop at that, and to get the \"final\" number when would apply the same technique to the result, until it gets to one-digit number. We would need another while-loop to do that:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "def magic_number(x):\n",
        "    while x>10:\n",
        "        x = sum_digits(x)\n",
        "    return x\n",
        "\n",
        "magic_number(12345)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now we can compute the magic number corresponding to the current date. To do that, we will use `datetime` library:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "20022020 -> 8\n"
          ]
        }
      ],
      "source": [
        "import datetime\n",
        "now = datetime.datetime.now()\n",
        "\n",
        "number_date = now.day*1000000+now.month*10000+now.year\n",
        "print(number_date, '->', magic_number(number_date))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Fibonacci Numbers: For loop vs. While loop\n",
        "\n",
        "In mathematics, there is a beautiful sequence of numbers called **[Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number)** - a sequence, that starts with two numbers 1, where each next elements is equal to the sum of two previous ones:\n",
        "$$\n",
        "\\begin{array}{l}\n",
        "f_0 = f_1 = 1 \\\\\n",
        "f_n = f_{n-1} + f_{n-2}, \\quad n>1 \\\\\n",
        "\\end{array}\n",
        "$$\n",
        "\n",
        "Let us compute first 20 numbers in Fibonacci sequence:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 "
          ]
        }
      ],
      "source": [
        "c = p = 1\n",
        "for _ in range(20):\n",
        "    print(p, end=' ')\n",
        "    c,p = c+p, c"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In this algorithm, we use two variables - `c` to denote the *current* number, and `p` - the *previous* one. Initially both numbers are set to 1. During each iteration of the loop, we compute *next current* number as `c+p`, and assign current number `c` to `p`. Please note how we are doing the assignment in one line of code:\n",
        "```\n",
        "c,p = c+p, c\n",
        "```\n",
        "Writing the same code in two lines like that\n",
        "```\n",
        "c = c+p\n",
        "p = c\n",
        "```\n",
        "would be an error, because the value of `c` would change after first line is executed.\n",
        "\n",
        "In this example, we wanted to compute the known number of sequence elements, in our case 20. That is why it was convenient to use `for`-loop. Now suppose we want to compute the first Fibonacci number that exceeds 4000000. Because we do not know the number of iterations required, we can use `while` loop:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5702887\n"
          ]
        }
      ],
      "source": [
        "c = p = 1\n",
        "while c<4000000:\n",
        "    c,p = c+p, c\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Observe how the logic to compute Fibonacci numbers remained the same, while the loop around this logic changed from `for` to `while` depending on the task.\n",
        "\n",
        "Now let us build on this code to solve more difficult problem!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Exercise: Project Euler Problem 2\n",
        "\n",
        "Those who want to learn programming need to practice solving many problems, starting from simple ones, and going towards more and more difficult ones. There is a project called **[Project Euler](http://projecteuler.net)** that contains a lot of problems you can practice solving. Let us consider one of those problems, [problem \\#2](https://projecteuler.net/problem=2):\n",
        "\n",
        "> *By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.*\n",
        "\n",
        "Now that you know how to compute numbers in Fibonacci sequence, please solve this problem before proceeding with the next unit."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.7.3 64-bit",
      "language": "python",
      "name": "python37364bit6a29fc4a18164452b4e57b09a0c467e1"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.3-final"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}