english/3_Conditional.ipynb

{
  "cells": [
    {
      "metadata": {
        "collapsed": true
      },
      "cell_type": "markdown",
      "source": [
        "# Introduction to Programming with Python\n",
        "\n",
        "# Unit 3: Conditional Operator\n",
        "\n",
        "In the last unit, you were asked to solve a quadratic equation of the form\n",
        "$$ax^2+bx+c=0$$.\n",
        "\n",
        "To solve this equation, we can write the following function (based on the well-known [quadratic formula](https://en.wikipedia.org/wiki/Quadratic_formula)):"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "def solve(a,b,c):\n",
        "    d = b*b-4*a*c\n",
        "    x1 = (-b+math.sqrt(d))/(2*a)\n",
        "    x2 = (-b-math.sqrt(d))/(2*a)\n",
        "    return (x1,x2)\n",
        "\n",
        "solve (1,2,-3)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 1,
          "data": {
            "text/plain": "(1.0, -3.0)"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "However, some of the quadratic equations do not have solutions, for example, $x^2+2x+3=0$. Let's see what happens if we try to solve such an equation:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "solve(1,2,3)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "math domain error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-2-ab39b5a14b05>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-1-e88b999578f9>\u001b[0m in \u001b[0;36msolve\u001b[0;34m(a, b, c)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mx2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: math domain error"
          ]
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "It gives us *math domin error*, because our program tries to take a square root of a negative number! To get rid of this error, we need to check if the value of `d` is not negative, before computing `x1` and `x2`. This can be done using **conditional operator**"
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "## Conditional Operator\n",
        "\n",
        "Sometimes we need to execute some part of the program only when some condition occurs. To do that, we use **conditional operator**, also called **if-then-else** operator. In our case, we can improve our function like this:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def solve(a,b,c):\n",
        "    d = b*b-4*a*c\n",
        "    if d>=0:\n",
        "        x1 = (-b+math.sqrt(d))/(2*a)\n",
        "        x2 = (-b-math.sqrt(d))/(2*a)\n",
        "        return (x1,x2)\n",
        "    else:\n",
        "        print(\"No solution\")\n",
        "\n",
        "solve (1,2,3)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": "No solution\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "Conditional operator has the following form:\n",
        "\n",
        "```\n",
        "if condition:\n",
        "   block of code that executes if condition is met\n",
        "else:\n",
        "   block of code that executes if condition is not met\n",
        "```\n",
        "\n",
        "Note how all blocks of code are aligned together, in the same manner as function bodies were aligned previously to indicate where function code begins and ends.\n",
        "\n",
        "Conditions include the following comparison operators:\n",
        "\n",
        "| Operator | Meaning |\n",
        "| ------- | ----- |\n",
        "| == | equal |\n",
        "| != | not equal |\n",
        "| < | less than |\n",
        "| <= | less or equal to |\n",
        "| > | more than |\n",
        "| >= | more than or equal to |"
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "In our example, the function returns the result if the equation can be solved, and prints an error if it cannot. However, this is not considered to be a good design of a function, because if behaves rather differently depending on the circumstances. It would be much better if the function always returned a value, either the solution, or some indication that solution does not exist.\n",
        "\n",
        "In fact, there is a special value called `None`, which is often used in such cases to indicate a missing or non-existent value. So, our function can be further improved like this:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def solve(a,b,c):\n",
        "    d = b*b-4*a*c\n",
        "    if d>=0:\n",
        "        x1 = (-b+math.sqrt(d))/(2*a)\n",
        "        x2 = (-b-math.sqrt(d))/(2*a)\n",
        "        return (x1,x2)\n",
        "    else:\n",
        "        return None\n",
        "\n",
        "print('Equation with no solution: ',solve(1,2,3))\n",
        "print('Equation with two roots: ',solve(1,2,-3))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Equation with no solution:  None\nEquation with two roots:  (1.0, -3.0)\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "In fact, the value `None` is quite special, because if you do not specify a `return` operator in the function - it is considered to return `None`. So, in our case, we can simplify the function and omit the part of `if` operator:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def solve(a,b,c):\n",
        "    d = b*b-4*a*c\n",
        "    if d>=0:\n",
        "        x1 = (-b+math.sqrt(d))/(2*a)\n",
        "        x2 = (-b-math.sqrt(d))/(2*a)\n",
        "        return (x1,x2)\n",
        "\n",
        "print('Equation with no solution: ',solve(1,2,3))\n",
        "print('Equation with two roots: ',solve(1,2,-3))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Equation with no solution:  None\nEquation with two roots:  (1.0, -3.0)\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "Here, the code that calculates and returns values of $x_1$ and $x_2$ is only executed when $d\\ge0$. If it is not the case, nothing is executed, and thus function returns `None`. "
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "## Adding Some Randomness\n",
        "\n",
        "In all cases we have seen above, the program takes some input values, then does a series of steps, and produces the result. The result depends on the input, but is computed in exactly the same way each time, according to the program.\n",
        "\n",
        "However, sometimes we want to add some randomness to the program behavior. For example, suppose we want to produce a program that will generate a problem book for solving quadratic equations. Problem book should contain a number of example equation to be solved, together with their solutions.\n",
        "\n",
        "To generate such a book, we will need to randomly chose coefficients for the equations. It would be good to have some way to generate **random numbers**.\n",
        "\n",
        "This can in fact be done using functions from the `random` module:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "print('Random number from 0 to 1: ', random.random())\n",
        "print('Random integer from 0 to 10: ',random.randint(1,10))\n",
        "print('Random number from 1 to 3: ',random.choice([\"One\",\"Two\",\"Three\"]))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Random number from 0 to 1:  0.41953723929971876\nRandom integer from 0 to 10:  5\nRandom number from 1 to 3:  Three\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "Try running the cell above several times, and observe how the values change each time the code is executed.\n",
        "\n",
        "To be completely honest, those numbers are not purely random, they are called **pseudo-random**. It means that they are generated sequentially using some algorithm from a first number called **seed**, in such a way, that they resemble random numbers. \n",
        "\n",
        "Let us define a function that generates random equation:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def random_equation():\n",
        "    a = random.randint(1,5)*random.choice([-1,1])\n",
        "    b = random.randint(-10,10)\n",
        "    c = random.randint(-20,20)\n",
        "    print(a,'x^2+',b,'x+',c)\n",
        "    \n",
        "random_equation()"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "-5 x^2+ 5 x+ -1\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "If you run this cell several times, you can see that while generated numbers are good, the final equation does not look nice, because of '+-'. Sometimes when $a=-1$, you will get things like `-1 x^2`... So it would be good to take care of that!\n",
        "\n",
        "To do it, we can define a function that will print the coefficient in front of `x` in a clever way:\n",
        "* if the coefficient is negative (say, $-5$), it will print `-5`\n",
        "* if the coefficient is positive, it will print `+5`\n",
        "* if the coefficient is 0, it will print nothing\n",
        "* if the coefficient is 1 (or -1), it will omit the `1`\n",
        "\n",
        "Let us define a function `equation(a,b,c)` that will return string representation of the equation, taking into account all signs of coefficients. Because printing each coefficient follow the same logic outlined above, we will define one more function, `coef`, which will return the string representation of the coefficient, including the sign (which is either \"+\" or \"-\"). In order to handle the case of coefficient being equal to 0, we will also pass the variable (`x`, `x^2` or empty string) to be printed.\n"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def coef(a,x):\n",
        "    if a==0:\n",
        "        return \"\"\n",
        "    elif a==1:\n",
        "        return \"+\"+x\n",
        "    elif a==-1:\n",
        "        return \"-\"+x\n",
        "    elif a<0:\n",
        "        return \"-\"+str(-a)+x\n",
        "    else:\n",
        "        return \"+\"+str(a)+x\n",
        "    \n",
        "def equation(a,b,c):\n",
        "    return coef(a,\"x^2\")+coef(b,\"x\")+coef(c,\"\")\n",
        "\n",
        "print(equation(1,-2,3))\n",
        "print(equation(-1,-2,-3))"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": "+x^2-2x+3\n-x^2-2x-3\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "In this example, we see two new concepts:\n",
        "\n",
        "* `elif` operator can be used when we have a conditional operator with several conditions. If checks the conditions in the order specified, and once one of the conditions is true - the corresponding code block is executed. You can have many `elif`s. \n",
        "* Function `str` is used to convert integer to string representation. We cannot directly add a number to a string, eg. an expression `\"5\"+1` will result in an error. We need to specify explicity whether we want to add them as strings (`\"5\"+str(1)`), or as numbers (`int(\"5\")+1`)\n",
        "\n",
        "## Type Conversion\n",
        "\n",
        "What `coef` function essentially does - it returns **string representation** of the coefficient. It is important to understand the difference between a variable having *integer* value, and having *string* value. For example, suppose that we have the following code:\n",
        "```python\n",
        "i = 13\n",
        "s = \"13\"\n",
        "```\n",
        "Here, variable `i` contains an integer, and thus we can perform any arithmetic operations on it, for example `print(i+i)` will print the result of addition - 13. On the contrary, if we have string variable `s`, we will get `1313` when we perform `s+s` addition, because `+` will be treated as *string concatenation*. We can use `str` and `int` as functions to convert between string and integer representation, as in the example below:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "26\n1313\n26\n1313\n"
          ]
        }
      ],
      "source": [
        "i = 13\n",
        "s = \"13\"\n",
        "print(i+i)\n",
        "print(s+s)\n",
        "print(int(s)+int(s))\n",
        "print(str(i)+s)"
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "## String Slicing\n",
        "\n",
        "Now, to make the `equation` function completely perfect, we need to get rid of the leading \"+\", in case the first coefficient is positive. We will do it by checking the first element of the string. If the first element is `+`, we will return all but the first element.\n",
        "\n",
        "Accessing different parts of a string is called **slicing**. If we want to select all symbols from position $a$ to position $b-1$ in a string $s$, we will write `s[a:b]`. For example:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "s=\"Hello, my friends!\"\n",
        "s[7:9]"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 21,
          "data": {
            "text/plain": "'my'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "If we want all symbols till the end of the string, we can omit the second number:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "s[10:]"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 23,
          "data": {
            "text/plain": "'friends!'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "If we want to start counting elements from the end of the list and not from the beginning, we can use negative indexing, like this:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "s[10:-1]"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 24,
          "data": {
            "text/plain": "'friends'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "Finally, to get a single characted, we can just provide one index:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "s[0]"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 25,
          "data": {
            "text/plain": "'H'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "Taking all this into account, we can improve our function like this:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def equation(a,b,c):\n",
        "    s = coef(a,\"x^2\")+coef(b,\"x\")+coef(c,\"\")\n",
        "    if s[0] == \"+\":\n",
        "        return s[1:]\n",
        "    else:\n",
        "        return s\n",
        "    \n",
        "print(equation(1,-2,3))\n",
        "print(equation(-1,-2,-3))"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": "x^2-2x+3\n-x^2-2x-3\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "## Putting it all together\n",
        "\n",
        "Finally, to generate and print random equation, we will modify the function `random_equation` to return the string:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "def random_equation():\n",
        "    a = random.randint(1,5)*random.choice([-1,1])\n",
        "    b = random.randint(-10,10)\n",
        "    c = random.randint(-20,20)\n",
        "    return equation(a,b,c)\n",
        "\n",
        "random_equation()"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "execution_count": 27,
          "data": {
            "text/plain": "'4x^2-7x-5'"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "You have probably noticed that Azure Notebooks support typesetting formulas in a nice \"mathematical\" way. This is done using so-called $\\TeX$ notation, and in fact the equation that we have printed out follows this notation quite closely. All we need to do is to use some specific magic to print it out as a formula. You do not need to understand this, just enjoy the result:"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [
        "from IPython.display import display, Math\n",
        "display(Math(random_equation()))"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/latex": "$\\displaystyle -x^2+9x+10$",
            "text/plain": "<IPython.core.display.Math object>"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": [
        "## An Exercise\n",
        "\n",
        "In the next unit, we will continue our task of building the practice book for quadratic equations. Please help us go one step further, and include the solution to the equation together with the original equation. So, the output of your program should look like this:\n",
        "\n",
        "$x^2+2x-3$ ($x_1=1, x_2=-3$)\n",
        "\n",
        "or \n",
        "\n",
        "$x^2+2x+3$ (no solutions)"
      ]
    },
    {
      "metadata": {
        "trusted": true
      },
      "cell_type": "code",
      "source": [],
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python374jvsc74a57bd0c77bccf6af5544921fca6eddbefe5e7c44ddf71c61b63c74bd828ca1d0e389a0",
      "display_name": "Python 3.7.4 64-bit ('base': conda)"
    },
    "language_info": {
      "mimetype": "text/x-python",
      "nbconvert_exporter": "python",
      "name": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4",
      "file_extension": ".py",
      "codemirror_mode": {
        "version": 3,
        "name": "ipython"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}