intro_exercises2_solutions_2020.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "intro_exercises2_solutions_2020.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EiEOVsZx7XTs",
        "colab_type": "text"
      },
      "source": [
        "# Exercises to Lecture 2: Introduction to Python 3.6 \n",
        "By Dr. Anders S. Christensen\n",
        "`anders.christensen @ unibas.ch`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yW74EMch6FwS",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 2.1: define a function"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6DRXgy9n8Ewl",
        "colab_type": "text"
      },
      "source": [
        "One of the fundamental things we learned was how to define functions.\n",
        "\n",
        "For example, the function defined below `square(x)` calculates the square, $x^2$:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1oWA4omv6F1e",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "319311d5-2d4e-4c70-9b93-d86d488715ce"
      },
      "source": [
        "def square(x):\n",
        "  y = 2 * x**2\n",
        "  return y\n",
        "\n",
        "print(square(2))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvKbienrXKiJ",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.1.1:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RRdc88VAXlBG",
        "colab_type": "text"
      },
      "source": [
        "Similarly to the above code, make a function called. for example, `poly(x)` to calculate the following polynomial:\n",
        "\\begin{equation}\n",
        "p\\left( x \\right) = 5 x^2 - 4x + 1\n",
        "\\end{equation}\n",
        "\n",
        "Lastly, print the value of $p\\left( 5 \\right)$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "djDTi6hOXKx8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0298b80a-216b-4b61-bd5c-078eb622a1ee"
      },
      "source": [
        "def poly(x):\n",
        "\n",
        "  # Fill out the rest of the function yourself!\n",
        "  p = 5* x**2  - 4*x + 1\n",
        "\n",
        "  return p\n",
        "  \n",
        "\n",
        "# Print the value for x=5\n",
        "print(poly(5))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "106\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QXZdW0QO6F5p",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 2.2: Loop within function"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AXZCtaiWRnQe",
        "colab_type": "text"
      },
      "source": [
        "The code below implements the product of all numbers up to n, i.e. the factorial function \"$!$\"\n",
        "\n",
        "\\begin{equation}\n",
        "f(n) = n! = \\prod_{i=1}^n i = 1 \\cdot 2 \\cdot \\quad  ... \\quad \\cdot (n -1) \\cdot n\n",
        "\\end{equation}\n",
        "\n",
        "As an example, the code to calculate $5!$ is shown here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pBd8GDNI6F-I",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d5b555e8-20d0-4e5d-f20b-3857fe7d5b2f"
      },
      "source": [
        "n = 5\n",
        "\n",
        "f = 1\n",
        "for i in range(1,n+1):\n",
        "  f =  f * i\n",
        "\n",
        "print(\"Factorial\", n, \"is\", f)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Factorial 5 is 120\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x9ZzRsEOVjr1",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.2.1\n",
        "\n",
        "Unfortunately the above code is not very practical and re-usable, and will only work for $n=5$. Instead we would like a function named `factorial(n)`. In this Exercise, write your own function which calculates the factorial.\n",
        "\n",
        "As output print `factorial(10)`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fq1sCN9qVilM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a0c5ca50-22d0-4d9e-a25b-e6c38bf090bb"
      },
      "source": [
        "def factorial(n):\n",
        "  \n",
        "  # Write the rest of the function yourself\n",
        "  f = 1\n",
        "  for i in range(1,n+1):\n",
        "    f =  f * i\n",
        "  \n",
        "  return f\n",
        "\n",
        "print(factorial(10))"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3628800\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lTGp53FFXsBZ",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.2.2:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LLs8GRg2XtRk",
        "colab_type": "text"
      },
      "source": [
        "Using the `factorial(n)` function you wrote in the previous question, print all $n!$ for all n from 1 to 20. \n",
        "\n",
        "Hint: Use another for loop!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TyUdxK-HXsZg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 364
        },
        "outputId": "3dbd33ef-8a7b-49e3-c176-b881a26289bf"
      },
      "source": [
        "# Below, write the code to print all n! from n=1 to n=20\n",
        "\n",
        "for n in range(1, 21):\n",
        "\n",
        "  print(n, factorial(n))\n",
        "\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 1\n",
            "2 2\n",
            "3 6\n",
            "4 24\n",
            "5 120\n",
            "6 720\n",
            "7 5040\n",
            "8 40320\n",
            "9 362880\n",
            "10 3628800\n",
            "11 39916800\n",
            "12 479001600\n",
            "13 6227020800\n",
            "14 87178291200\n",
            "15 1307674368000\n",
            "16 20922789888000\n",
            "17 355687428096000\n",
            "18 6402373705728000\n",
            "19 121645100408832000\n",
            "20 2432902008176640000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xDDiLMgb6GBY",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 2.3: `if` / `else` statements"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lWEDLeQ4epuZ",
        "colab_type": "text"
      },
      "source": [
        "`if` and `else` statments can are used to make decisions based on defined criteria."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BtvSeIhv6GFq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n = 10\n",
        "\n",
        "if n < 10: \n",
        "  print(\"n is less than 10\")\n",
        "else:\n",
        "  print(\"n is greater than 10\")\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y1yMeHK6f5B_",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.3.1:\n",
        "\n",
        "One example of mathematical functions that contain such statements are the so-called \"rectifier linear unit\" (ReLU) functions which are often used in Neural Networks.\n",
        "\n",
        "An example is given here:\n",
        "\\begin{equation}\n",
        "f\\left(x\\right) =\n",
        "\\begin{cases} \n",
        "      0 & x\\leq 0 \\\\\n",
        "      x & x \\gt 0 \n",
        "   \\end{cases}\n",
        "\\end{equation}\n",
        "\n",
        "In this question, write the above ReLU function, which returns $0$ if $x \\leq 0$ and returns $x$ otherwise.\n",
        "\n",
        "Lastly, verify the correctness of your code your code using the 5 print statments in the code block below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zE2Rnq-O6GOM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "6eeb5a60-37c4-42c1-b2c8-ec0c7c6661b8"
      },
      "source": [
        "def relu(x):\n",
        "\n",
        "  # Implement the content of the ReLU function yourself!\n",
        "  if x <= 0.0:\n",
        "    return 0.0\n",
        "  else:\n",
        "    return x\n",
        "\n",
        "\n",
        "print(relu(-10))  # should return 0\n",
        "print(relu(-0.1)) # should return 0\n",
        "print(relu(0))    # should return 0\n",
        "print(relu(0.1))  # should return 0.1\n",
        "print(relu(10))   # should return 10"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.0\n",
            "0.0\n",
            "0.0\n",
            "0.1\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qiQ5PrhQ6GTb",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 2.4: Plotting"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yQt9h4xFzv7K",
        "colab_type": "text"
      },
      "source": [
        "In the below example, the value of\n",
        " $$y= x^2$$ \n",
        " is calculated for six values of $x$, and appended to a list.\n",
        "\n",
        "Next, the points are plottet using the `plt.plot()` function from the `pyplot` library.\n",
        "\n",
        "The function `plt.plot()` tells matplotlib to draw a lineplot that connects all the pairs of points in two lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vunkZuR26GX6",
        "colab_type": "code",
        "outputId": "7a846ec9-7ec0-411d-d4a9-ae395039574e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        }
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Some x-values\n",
        "x = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]\n",
        "\n",
        "# Initialize an empty list for the y-values we wish to plot\n",
        "y = []\n",
        "\n",
        "for i in range(len(x)):\n",
        "\n",
        "  # Calculate the square of each x in the list\n",
        "  value = x[i]**2\n",
        "\n",
        "  # Add the calculated value to the list \"y\"\n",
        "  y.append(value)\n",
        "\n",
        "# Print the two lists\n",
        "print(x)\n",
        "print(y)\n",
        "\n",
        "# Make a line plot/figure\n",
        "plt.plot(x, y)\n",
        "\n",
        "# Actually draw the figure below\n",
        "plt.show()"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]\n",
            "[0.0, 1.0, 4.0, 9.0, 16.0, 25.0]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TkRlZYbi0Wlv",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.4.1:\n",
        "\n",
        "Instead of plotting a line through all points, it is also possible to plot datapoints using a so-called [scatterplot](https://en.wikipedia.org/wiki/Scatter_plot).\n",
        "\n",
        "For this behavior, you can replace the function `plt.plot()` in the above example with the function `plt.scatter()`.\n",
        "\n",
        "In this question you are given two lists of numbers below, `a` and `b`.\n",
        "\n",
        "Use pyplot to draw a *scatterplot* of the two lists."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1nv6m4AR0Wv8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "1176ad71-0f70-4442-da23-b6803cc08b5e"
      },
      "source": [
        "a = [10.0, 8.0, 13.0, 9.0, 11.0, 14.0, 6.0, 4.0, 12.0, 7.0, 5.0]\n",
        "b = [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]\n",
        "\n",
        "# Here, write the code to show a scatterplot for the lists a, b\n",
        "plt.scatter(a, b)\n",
        "plt.show()"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cU8lkPD0hTPr",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.4.2:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RGOTwuLShY6T",
        "colab_type": "text"
      },
      "source": [
        "In order to give the plot a title and label the axes, insert the three functions in the code in Question 2.4.1:\n",
        "\n",
        "*    `plt.xlabel()`\n",
        "*    `plt.ylabel()`\n",
        "*    `plt.title()`\n",
        "\n",
        "Make the plot title \"Python 2020\", label the x-axis \"Apples\" and the y-axis \"Oranges\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7qqm_3QHhTXu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "3f3f98ef-3d56-4aae-c530-ab614b7e2985"
      },
      "source": [
        "plt.scatter(a, b)\n",
        "plt.xlabel(\"Apples\")\n",
        "plt.ylabel(\"Oranges\")\n",
        "plt.title(\"Python 2020\")\n",
        "plt.show()"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VwI0BijP6GdX",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 2.5: More plotting (harder) \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qQeQGfz3xG0w",
        "colab_type": "text"
      },
      "source": [
        "### Question 2.5.1:\n",
        "In the example in Problem 2.4, the code for a line plot for $y = x^2$ is shown.\n",
        "\n",
        "Write your own code to plot $y = \\cos(x)$ from 0 to 10.\n",
        "\n",
        "**Hints:**\n",
        "\n",
        "\n",
        "*   Import the `np.cos()` function using `import numpy as np`\n",
        "*   If the figure does not look smooth, how can you make the points on the x-axis closer than 1.0?\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bRpOBE836Gid",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "outputId": "5b516464-104a-4ba6-821f-821370794c48"
      },
      "source": [
        "# First try:\n",
        "# Note that there are many ways to solve this exercise!\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "x = []\n",
        "y = []\n",
        "\n",
        "for i in range(11):\n",
        "  x.append(i)\n",
        "  y.append(np.cos(i))\n",
        "\n",
        "# Print the two lists to verify that you have the right numbers\n",
        "print(x)\n",
        "print(y)\n",
        "\n",
        "# Make the figure\n",
        "plt.plot(x, y)\n",
        "\n",
        "# Actually draw the figure below\n",
        "plt.show()"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
            "[1.0, 0.5403023058681398, -0.4161468365471424, -0.9899924966004454, -0.6536436208636119, 0.28366218546322625, 0.960170286650366, 0.7539022543433046, -0.14550003380861354, -0.9111302618846769, -0.8390715290764524]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G_eng__KbBTk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 320
        },
        "outputId": "2d245e10-5598-4162-d16c-2071242ad035"
      },
      "source": [
        "# Smooth, with more x-values:\n",
        "# Note that there are many ways to solve this exercise!\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "x = []\n",
        "y = []\n",
        "\n",
        "for i in range(100):\n",
        "\n",
        "  # Now there are 100 points between 0 and 10 with 0.1 spacing\n",
        "  # => smoother curve\n",
        "  xval = i/10.0\n",
        "  x.append(xval)\n",
        "\n",
        "  yval = np.cos(xval)\n",
        "  y.append(yval)\n",
        "\n",
        "\n",
        "# Print the two lists to verify that you have the right numbers\n",
        "print(x)\n",
        "print(y)\n",
        "\n",
        "# Make the figure\n",
        "plt.plot(x, y)\n",
        "\n",
        "# Actually draw the figure below\n",
        "plt.show()"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.7, 5.8, 5.9, 6.0, 6.1, 6.2, 6.3, 6.4, 6.5, 6.6, 6.7, 6.8, 6.9, 7.0, 7.1, 7.2, 7.3, 7.4, 7.5, 7.6, 7.7, 7.8, 7.9, 8.0, 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9, 9.0, 9.1, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 9.9]\n",
            "[1.0, 0.9950041652780258, 0.9800665778412416, 0.955336489125606, 0.9210609940028851, 0.8775825618903728, 0.8253356149096783, 0.7648421872844885, 0.6967067093471654, 0.6216099682706644, 0.5403023058681398, 0.4535961214255773, 0.3623577544766736, 0.26749882862458735, 0.16996714290024104, 0.0707372016677029, -0.029199522301288815, -0.12884449429552464, -0.2272020946930871, -0.32328956686350335, -0.4161468365471424, -0.5048461045998576, -0.5885011172553458, -0.6662760212798241, -0.7373937155412454, -0.8011436155469337, -0.8568887533689473, -0.9040721420170612, -0.9422223406686581, -0.9709581651495905, -0.9899924966004454, -0.9991351502732795, -0.9982947757947531, -0.9874797699088649, -0.9667981925794611, -0.9364566872907963, -0.896758416334147, -0.848100031710408, -0.7909677119144168, -0.7259323042001402, -0.6536436208636119, -0.5748239465332692, -0.4902608213406994, -0.40079917207997545, -0.30733286997841935, -0.2107957994307797, -0.11215252693505487, -0.01238866346289056, 0.0874989834394464, 0.18651236942257576, 0.28366218546322625, 0.37797774271298024, 0.4685166713003771, 0.5543743361791608, 0.6346928759426347, 0.70866977429126, 0.7755658785102496, 0.8347127848391598, 0.8855195169413189, 0.9274784307440359, 0.960170286650366, 0.9832684384425845, 0.9965420970232175, 0.9998586363834151, 0.9931849187581926, 0.9765876257280235, 0.9502325919585296, 0.9143831482353194, 0.8693974903498253, 0.8157251001253568, 0.7539022543433046, 0.6845466664428066, 0.6083513145322546, 0.5260775173811053, 0.43854732757439036, 0.3466353178350258, 0.2512598425822557, 0.15337386203786435, 0.05395542056264975, -0.04600212563953695, -0.14550003380861354, -0.2435441537357911, -0.3391548609838345, -0.4313768449706208, -0.5192886541166856, -0.6020119026848236, -0.6787200473200125, -0.7486466455973987, -0.811093014061656, -0.8654352092411123, -0.9111302618846769, -0.9477216021311119, -0.9748436214041636, -0.9922253254526034, -0.9996930420352065, -0.9971721561963784, -0.984687855794127, -0.9623648798313102, -0.9304262721047533, -0.8891911526253609]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}