english/2_Functions.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "collapsed": true
      },
      "source": [
        "# Introduction to Programming with Python\n",
        "\n",
        "# Unit 2: Functions\n",
        "\n",
        "Let us start with doing the exercise given in the previous lesson: drawing a house. First of all, let's take care of importing the Turtle module:"
      ]
    },
    {
      "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": 1,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "import jturtle as turtle"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To simplify writing, let us use a variable `size` to represent the size of the house. First thing we need to do is to draw a square:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "scrolled": true,
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD4CAYAAADsBlOYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAAyxJREFUeJzt3cEJwzAQAEFfcP8tX5qIEfHOFCAOgVbopdndC+j6nB4AOEsEIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIO4+PcAvzYxPFHil3Z2n1n5VBK7r2c2CE56+3DwHIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIO4+PcCvzcyengH+yew6M1DmOQBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxX5PAEPHBIswIAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "size=120\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now, after drawing the main square, let us draw the roof. After the code above, the turtle is in the low left corner of the square, so we need to move up, and then draw a triangle:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "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": [
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "\n",
        "turtle.forward(size)\n",
        "turtle.right(30)\n",
        "turtle.forward(size)\n",
        "turtle.right(120)\n",
        "turtle.forward(size)\n",
        "turtle.right(120)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Finally, to draw a window, we need to put the pen up to stop drawing, move 2/3 of the `size` down and 1/3 left, and draw a smaller square:"
      ]
    },
    {
      "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": [
        "# Draw a square\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "turtle.forward(size)\n",
        "turtle.right(90)\n",
        "\n",
        "# Draw the roof\n",
        "turtle.forward(size)\n",
        "turtle.right(30)\n",
        "turtle.forward(size)\n",
        "turtle.right(120)\n",
        "turtle.forward(size)\n",
        "turtle.right(30)\n",
        "\n",
        "# Position pen inside\n",
        "turtle.penup()\n",
        "turtle.forward(2*size/3)\n",
        "turtle.right(90)\n",
        "turtle.forward(size/3)\n",
        "turtle.pendown()\n",
        "\n",
        "# Draw a window\n",
        "turtle.forward(size/3)\n",
        "turtle.right(90)\n",
        "turtle.forward(size/3)\n",
        "turtle.right(90)\n",
        "turtle.forward(size/3)\n",
        "turtle.right(90)\n",
        "turtle.forward(size/3)\n",
        "turtle.right(90)\n",
        "\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can notice that as the program becomes rather big, it is also getting more difficult to understand. One thing to simplify understanding a program is by using **comments**. Comments are pieces of text that can be embedded into the program, and which are ignored by Python. Anything that starts with `#` sign and until the end of line is considered a comment, and is discarded.\n",
        "\n",
        "You can use comments to provide some description of what is going on, to help other programmers to understand your code better. Also, if you want for some reason to temporarily exclude a piece of code from your program, you can use comments to *comment it out*.\n",
        "\n",
        "In the program above, we have provided a few comments to help us understand what each part of the program is doing. Also, we have used empty lines to create some logical grouping of code. This also helps to understand the program. Please remember that you can use any number of empty lines anywhere in between your program lines.\n",
        "\n",
        "However, just comments would not help us to fight complexity. Another extremely useful technique is called **functions**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Introducing Functions\n",
        "\n",
        "In this example, we need to draw squares twice --- first, to make the outline of the house, and then to draw the window inside. In fact, drawing a square (as well as other geometric figures, such as triangles, or circles) can be considered quite a common task, from which more complex drawings can be made. You can argue that is would make sense to include `square` as one of the turtle's built-in commands, but it is not possible to include everything... it would make more sense to allow creating your own commands from simpler ones.\n",
        "\n",
        "In our case, we can **define our own command** to draw a square. In fact, any piece of Python code that has some logical meaning can be grouped together into a **function**. Functions are defined using special `def` keyword. Have a look at the definition of a function to draw a square:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "def square(x):\n",
        "    turtle.forward(x)\n",
        "    turtle.right(90)\n",
        "    turtle.forward(x)\n",
        "    turtle.right(90)\n",
        "    turtle.forward(x)\n",
        "    turtle.right(90)\n",
        "    turtle.forward(x)\n",
        "    turtle.right(90)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "When we run this code, nothing is drawn on the screen --- we just specify the list of commands that comprise a function. However, once the cell above has been executed, Python gets to know a new command `square`. To actually draw a square we need to **call** this function:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD4CAYAAADsBlOYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAAy1JREFUeJzt3dEJAyEQQMHbcP23vGkiieTeTAGyCD7xy9ndC+h6nR4AOEsEIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIO4+PcAnzYxPFHic3Z1vrv+oCFzX9zcMfukXF5vnAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMSJAMTdpwf4tJnZ0zPAP5ldZwbKPAcgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQgTgQg7g2jwBDx4wvyuAAAAABJRU5ErkJggg==",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "square(100)\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Because we need to draw squares of different sizes, this function has one **argument**, or **parameter**. It is denoted by `(x)` after the function's name, and it is in fact a kind of variable, which takes the value that is passed to the function during the call. In the case above, we have called the function `square(100)`, so in the functions's body variable `x` will be equal to 100. We can use any expression in place of a parameter, for example `square(size/2+10)` would be a perfectly valid call. Expression `size/2+10` would be computed, and the result associated with parameter `x`. When defining a function you always use some names in place of parameters, which will act as \"placeholders\" - you cannot use expressions. \n",
        "\n",
        "Now that we have defined the `square` function, we can simplify drawing a house, calling a function each time we need to draw a square:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "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": [
        "square(size)\n",
        "\n",
        "turtle.forward(size)\n",
        "turtle.right(30)\n",
        "turtle.forward(size)\n",
        "turtle.right(120)\n",
        "turtle.forward(size)\n",
        "turtle.right(30)\n",
        "\n",
        "turtle.penup()\n",
        "turtle.forward(2*size/3)\n",
        "turtle.right(90)\n",
        "turtle.forward(size/3)\n",
        "turtle.pendown()\n",
        "\n",
        "square(size/3)\n",
        "\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Inside functions we can of course call other functions. As a simple exercise, please take the code that draws a house above, and turn it into a function with one parameter -- the size of the house. Put your code in the cell below, and test it:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you did not succeed, or if you are getting some syntax errors, take a note of the following:\n",
        "\n",
        "* Make sure you have indented all the lines inside function's body by a few spaces. More on indentation - in the next section.\n",
        "* Make sure you put colon `:` after the function definition\n",
        "* Make sure to call the function in order to actually draw a house. Function call should follow the function definition, and should not be indented - to indicate that it is not part of a function definition, but a separate piece of code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Blocks and Line Indentation\n",
        "\n",
        "You may have noticed that when defining `square` function we have indented all the lines inside a function by a few spaces, like that:\n",
        "\n",
        "```python\n",
        "def square(x):\n",
        "    turtle.forward(x)\n",
        "    turtle.right(90)\n",
        "    ...\n",
        "```\n",
        "This indentation is important, because it tells Python where the function body begins and ends, and where the next part of the program begins. For example, if we want to define two functions, we will indent the code as follows:\n",
        "\n",
        "```python\n",
        "def square(x):\n",
        "    turtle.forward(x)\n",
        "    turtle.right(90)\n",
        "    ...\n",
        "\n",
        "def triangle(x):\n",
        "    turtle.forward(x)\n",
        "    turtle.right(120)\n",
        "    ...\n",
        "    \n",
        "square(50)\n",
        "triangle(50)\n",
        "```\n",
        "\n",
        "The indented piece of code is called a **block**, so you can say that a function definition consists of a `def` statement, followed by a code block. We will see this concept later on as well, when dealing with loops and conditional statements."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Functions that Return a Value\n",
        "\n",
        "In some cases, functions just do something, like drawing a square. However, sometimes we want functions that calculate something and give back the result. We say that those functions **return** a value.\n",
        "\n",
        "Consider the first exercise from the previous lesson, where you had to calculate the amount of money on a bank deposit given an interest rate of 2.5%. We can write a function that will calculate how much money we will get after one year: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "def interest(amount, rate):\n",
        "    x = amount * (1+rate/100)\n",
        "    return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In this function, `amount` is the amount of money we currently have, and `rate` is the yearly interest rate in percents. We calculate the amount after one year and denote it by `x`, and then return this value using the `return` statement.\n",
        "\n",
        "To call this function, we can use the following syntax:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "102.49999999999999\n"
          ]
        }
      ],
      "source": [
        "result = interest(100, 2.5)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We can also directly use `interest` in any expression, for example, just to print the amount in one year, we can write"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "102.49999999999999"
            ]
          },
          "execution_count": 27,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "interest(100, 2.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "And to calculate the resulting amount in two years:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "105.06249999999997"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "interest(interest(100, 2.5),2.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Local and Global Variables\n",
        "\n",
        "In our function, we were using the variable `x` to perform the calculation. Such variables that are used only inside functions are called **local variables**, and they only exist inside the function. If we try to print the value of `x` after calling the function `interest` we will get an error that such a variable does not exist. \n",
        "\n",
        "A variable defined outside a function is called **global variable**, and all such variables are also accessible from inside the function. For example, if the interest rate is more or less the same in all our computations, we may chose to define it as a global variable, in order not to pass it around each time: "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "107.68906249999996\n"
          ]
        }
      ],
      "source": [
        "interest_rate = 2.5\n",
        "\n",
        "def interest(x):\n",
        "    return x * (1+interest_rate/100)\n",
        "\n",
        "print(interest(interest(interest(100))))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Tuples\n",
        "\n",
        "Suppose we want to return several values from our function, for example, total amount on our bank account as well as accumulated interest. However, functions are designed in such a way that they can only return a single value. Luckily, a single value in Python can consist of multiple other values. Such combinations of 2, 3 or any other number of values are called **tuples**.\n",
        "\n",
        "Tuples are very useful way of storing structured values. For example, a coordinate in a 2D-space is given by two values, $x$ and $y$. So, instead of storing them in two different variables, and saying `x=0` and `y=10`, we can store them in a tuple:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "point = (0,10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To access individual coordinates of a point, we can use the notation `point[0]` and `point[1]`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Our coordinates are: x= 0 , y= 10\n"
          ]
        }
      ],
      "source": [
        "print(\"Our coordinates are: x=\",point[0],', y=',point[1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Another way to decompose a tuple into parts is assigning it to a pair of variables. You can write:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Our coordinates are: x= 0 , y= 10\n"
          ]
        }
      ],
      "source": [
        "x,y = point\n",
        "print(\"Our coordinates are: x=\",x,', y=',y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "By the way, using tuples you can write nice assignments for several variables at once, for example"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x,y = 0,10\n",
        "x+y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Coming back to the interest rate example, we can return total amount and accumulated interest using a tuple:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "102.5 2.5\n"
          ]
        }
      ],
      "source": [
        "def interest(x,rate):\n",
        "    acc = x*rate/100\n",
        "    return (x+acc, acc)\n",
        "\n",
        "total, acc = interest(100,2.5)\n",
        "print(total,acc)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Another Style of Drawing\n",
        "\n",
        "Drawing a house using turtle commands seems a good idea, but you can also think of this problem in a slightly different way. Suppose you have a squared paper, and you have drawn a house on this paper. In this case it would be easy for you to calculate the *coordinates* of all points, and then you would know the coordinates of start and end point of each line in the drawing. So, instead of giving turtle-style commands to move and turn, you can directly specify coordinates of lines to draw.\n",
        "\n",
        "There are two turtle commands that can be used with coordinates:\n",
        "* turtle.line((x1,y1),(x2,y2)) --- draw a line between specified points\n",
        "* turtle.point((x,y)) -- draw a point\n",
        "\n",
        "Note how we use tuples to pass point coordinates to the function!\n",
        "\n",
        "So, when drawing a house using coordinates, we will also define a function to drawing a square, given two opposite points:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "def square(x1,y1,x2,y2):\n",
        "    turtle.line((x1,y1),(x1,y2))\n",
        "    turtle.line((x1,y1),(x2,y1))\n",
        "    turtle.line((x2,y2),(x1,y2))\n",
        "    turtle.line((x2,y2),(x2,y1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Using this function, we can draw a house:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAAD4CAYAAADsBlOYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAABMBJREFUeJzt2K2OpFUYRtFzyBCCIUFiEdwEnqsAMQ7PpZCgUQiCwnAtaBwBLAnmoEhmPjrQ01Nd389eS5d4k6pnJ6fmWmsAXe/sfQCwLxGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBGAOBEImXN+Mud8b+87OBYRCJhzfjjn/GGM8fMY448555d738RxiMCFvTL+38YYn44xXo4xvh9jfD3n/F0MGEMELumB8X+x1vporfXtWuvlGOODMcaPQwwYInAp/zH+71793FrrTzHgHyJwAY8d/5YYMIYInNpTx78lBm0icEK3Gv+WGDSJwIk81/i3xKBFBE7gXuPfEoMGETiwvca/JQbXJgIHdJTxb4nBNYnAgRx1/FticC0icABnGf+WGFyDCOzorOPfEoNzE4EdXGX8W2JwTiJwR1cd/5YYnIsI3EFl/FticA4i8Iyq498Sg2MTgWdg/A8Tg2MSgRsy/scRg2MRgRsw/qcRg2MQgbdg/LchBvsSgScw/uchBvsQgTdg/PchBvclAo9g/PsQg/sQgf9g/McgBs9LBB5g/MckBs9DBF5h/OcgBrclAsP4z0oMbiMdAeO/BjF4O8kIGP81icHTpCJg/A1i8GYSETD+JjF4nEtHwPgZQwz+zyUjYPw8RAwedqkIGD+PIQavm2utvW+4iTnnZ2OMn8YYv44xvjJ8HmvO+f4Y45sxxudjjF/WWh/vfNJdXSkC744x/tr7Ds5vrTX3vuGeLhOBMcaYc67aF8htFX9Dl/pPAHhzIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxIgBxL/Y+gNfNOdfeN7yttdbc+wYeTwQO6MwjukLEajwHIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIE4EIO7F3gfwb3POtfcNdIjAway15t430OI5AHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEiAHEv9j7g1uaca+8b4EzmWjYDZZ4DECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCECcCEPc33Gm/GI8qlCkAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "square(0,0,120,120)\n",
        "square(40,40,80,80)\n",
        "turtle.line((0,120),(60,150))\n",
        "turtle.line((60,150),(120,120))\n",
        "turtle.done()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## An Exercise\n",
        "\n",
        "As always, we would like to ask you to do a little homework before going for the next unit. You probably know from your math classes what is a quadratic equation. It is an equation of the following form:\n",
        "$$\n",
        "ax^2+bx+c=0\n",
        "$$\n",
        "\n",
        "This equation can have two roots, which are calculated using the formula:\n",
        "$$\n",
        "x_{1,2} = \\frac{-b\\pm\\sqrt{D}}{2a}\n",
        "$$\n",
        "where\n",
        "$$\n",
        "D=b^2-4ac\n",
        "$$\n",
        "\n",
        "If $D<0$, the equation has no roots. If $D=0$, two roots are the same (which follows from the formula).\n",
        "\n",
        "Try to:\n",
        "* Define a function to solve quadratic equation. To calculate square root, use `math.sqrt` function, as shown below\n",
        "* Use it to solve the equation with $a=1, b=2, c=-3$. It should have two roots.\n",
        "* See what happens if you try to solve an equation which has no roots, eg. $a=1, b=2, c=3$.\n",
        "\n",
        "If you do not know or do not remember what quadratic equations are -- do not worry and skip this exercise. Or [have a look in the wikipedia](https://en.wikipedia.org/wiki/Quadratic_equation)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "trusted": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4.0"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import math\n",
        "math.sqrt(16)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "trusted": true
      },
      "outputs": [],
      "source": [
        "# Write your solution here"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3.6",
      "language": "python",
      "name": "python36"
    },
    "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.6.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}