lab_materials/lab1_python/intro_solution.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "intro_solution.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VY48mAXCuRa-",
        "colab_type": "text"
      },
      "source": [
        "# Introduction to Python\n",
        "\n",
        "Python is a powerful high-level interpreted language."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qgtLgu0-uplS",
        "colab_type": "text"
      },
      "source": [
        "## Variables"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aJ0yODE9dpV6",
        "colab_type": "text"
      },
      "source": [
        "Integers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EJ4tZ5gYdrOv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 1\n",
        "b = 2\n",
        "print(\"Sum, difference, division:\", a + b, a - b, a // b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPpnUzuudus2",
        "colab_type": "text"
      },
      "source": [
        "Floting point numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRM7cXildxrf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"Floating point division:\", 1.0 / 2.0)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q6IzYW72d2Na",
        "colab_type": "text"
      },
      "source": [
        "Complex numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ooBQ-HAd4R-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"Complex numbers:\", 1.0 + 1.0j)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aRtsNkxLd7AB",
        "colab_type": "text"
      },
      "source": [
        "Booleans"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mzvtZ2RceARU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = True\n",
        "b = False\n",
        "print(\"Boolean operations:\", a or b, a and b, not a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uVzLWAp7eCch",
        "colab_type": "text"
      },
      "source": [
        "Strings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jx9zZkzSeHH1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s = \"This is a string in Python\"\n",
        "print(\"String:\", a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kgTGxeOFeLd1",
        "colab_type": "text"
      },
      "source": [
        "Single quotes can also be used"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EkSoAMuJeIlX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 'This is a string too'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IvlWLUGLePla",
        "colab_type": "text"
      },
      "source": [
        "We can split long strings like this"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kv_M49fpeS0E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = (\"Very very very \"\n",
        "     \"long long long \"\n",
        "     \"string in Python\"\n",
        "    )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-_UfrpwQeXi4",
        "colab_type": "text"
      },
      "source": [
        "Or use multiline string"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uAMadNw5eZQ7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = \"\"\"this\n",
        "is\n",
        "multiline \n",
        "string\"\"\"\n",
        "a"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OJXyqzJ_ehNm",
        "colab_type": "text"
      },
      "source": [
        "String concatenation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wxNX3yCOejzb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\"str\" + \"ing\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyJYt_dJepTs",
        "colab_type": "text"
      },
      "source": [
        "Some of useful string methods:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TfkggKXletFA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"string\".startswith(\"str\"))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vtQDPYB-fY7x",
        "colab_type": "text"
      },
      "source": [
        "Try following methods: `.endswith`, `.join`, `.capitalize`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rWnykIjkfhly",
        "colab_type": "text"
      },
      "source": [
        "String formatting"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PToq0omNflP2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\"This is a number {}, this is another number{}!\".format(10, 20)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WgYzAHHSf00K",
        "colab_type": "text"
      },
      "source": [
        "You can specify how number is formatted"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zGGlXdZQuKnG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\"This is pi {:0.2f}!\".format(3.1415)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2UqKCEDf4n9",
        "colab_type": "text"
      },
      "source": [
        "Format strings look like this"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vao_Xk17f_BP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f\"This is sum of 2 and 3: {2 + 3}\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "swwHe1pLeVn0",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yDBje-obvc9B",
        "colab_type": "text"
      },
      "source": [
        "## Simple data structures: lists, maps, sets, tuples\n",
        "\n",
        "Lists are designed to store a number of ordered values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qZp9Hx-9hIRC",
        "colab_type": "text"
      },
      "source": [
        "### List"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iEO10YjSgEiP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array = [1, 4, 2, 3, 8, 7, 6, 5]\n",
        "array"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OafZcfQLgIik",
        "colab_type": "text"
      },
      "source": [
        "Addressing list by index"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vTBtlmzlgQUN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[0]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sc-anm1NgS25",
        "colab_type": "text"
      },
      "source": [
        "Slice is a sub-sequence of a list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tBZ0HPHLgeDc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[1:5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dgp-CaJigiXM",
        "colab_type": "text"
      },
      "source": [
        "End-less slices take either prefix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0FU3YcmKgmWG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[:5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L3LzQHZugpJh",
        "colab_type": "text"
      },
      "source": [
        "or suffix"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ND4QRgggqbV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[5:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJUoxAf5gugb",
        "colab_type": "text"
      },
      "source": [
        "Third argument to the slice is the step size"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8AU5C2aZgxs-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[2:7:2]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UFoYM9Vtg33H",
        "colab_type": "text"
      },
      "source": [
        "Lists may contain values of different types"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sgHBH0SAvcYB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "[1, 1e-8, \"Hello\"]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SPP1Cyajwpfa",
        "colab_type": "text"
      },
      "source": [
        "### Maps\n",
        "Maps (dictionaries) can store relations between pairs of values"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E9B-8IZ2hVJo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m = {\"height\": 100., \n",
        "     \"width\": 20.,\n",
        "     \"depth\": 10.}\n",
        "m"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_sJCy0_chf3h",
        "colab_type": "text"
      },
      "source": [
        "Retrieving value by key"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RyqblTcihk4i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m[\"width\"]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GaRxKo1qhmca",
        "colab_type": "text"
      },
      "source": [
        "Checking that a map contains a key"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WqOa9VOZh1OA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\"name\" in m"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5Zeyapsh6Go",
        "colab_type": "text"
      },
      "source": [
        "Add a new key-value pair"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O7iSJmrah-C1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m[\"name\"] = \"rectangle\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ILJJI_GFiBOy",
        "colab_type": "text"
      },
      "source": [
        "Or change existing value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PMGZPVR3iDcN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m[\"name\"] = \"RECTANGLE\""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0R5Wm0sFiFlp",
        "colab_type": "text"
      },
      "source": [
        "Remove key/value"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-cMBVYYEiHNT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m.pop(\"name\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kdYzR2X0zWNE",
        "colab_type": "text"
      },
      "source": [
        "### Tuples\n",
        "Tuples are similar to lists but are immutable -- they cannot be altered."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yJSXyvBqzBnc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_array = [1, 2, 3]\n",
        "my_tuple = (1, 2, 3)\n",
        "\n",
        "# This is OK\n",
        "my_array[0] = 100\n",
        "\n",
        "# This will raise an exception\n",
        "my_tuple[0] = 100"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IBeeqq6u1EP9",
        "colab_type": "text"
      },
      "source": [
        "### Sets\n",
        "Sets are unordered collections that support fast search, insertion, deletion and union."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I1aeG-bFzuL1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "animals = {\"cat\", \"dog\", \"elephant\"}\n",
        "animals"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IKTFuoVCiU4U",
        "colab_type": "text"
      },
      "source": [
        "Check that element is in set"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M2SRdoJ9iZkt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\"cat\" in a"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IMPig3GCidQP",
        "colab_type": "text"
      },
      "source": [
        "Perform set operations: union, intersection, etc"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zX06oDPPihJY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "animals.union({\"zebra\", \"llama\"})"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "do27WDEZ1rKc",
        "colab_type": "text"
      },
      "source": [
        "## Control flow"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZRLfl1pTkw8w",
        "colab_type": "text"
      },
      "source": [
        "Branching"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6RNIP5pmk0a9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = int(input())\n",
        "if a > 6:\n",
        "    print(\"a is greater than 6\")\n",
        "elif a < 3:\n",
        "    print(\"a is less than 3\")\n",
        "else:\n",
        "    print(\"a is between 3 and 6\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iF11czrvk9Ve",
        "colab_type": "text"
      },
      "source": [
        "Loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0FKPTPIklBuR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in [1, 2, 3, 4]:\n",
        "    print(i)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WC3CQ6LOlE2K",
        "colab_type": "text"
      },
      "source": [
        "Useful functions for looping:\n",
        "- `range`\n",
        "- `enumerate`\n",
        "- `zip`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DEXi6o3KlSTw",
        "colab_type": "text"
      },
      "source": [
        "Iterating a dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l4j34y5klVQD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for k, v in m.items():\n",
        "    print(k, v)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_82guvm2lb4Y",
        "colab_type": "text"
      },
      "source": [
        "While loop\n",
        "\n",
        "*It is very rare that you need to use while loop. Following example is very not pythonic!*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_xAlRHDNlcsV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "stop = False\n",
        "i = 10\n",
        "while not stop:\n",
        "    i += 1\n",
        "    if i % 10 == 0:\n",
        "        stop = True\n",
        "        \n",
        "print(i)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1XOUcES3U_7g",
        "colab_type": "text"
      },
      "source": [
        "## List comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ii1YsF1VFQt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "[i + 1 for i in [1, 2, 3]]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sP1oejrKVUIo",
        "colab_type": "text"
      },
      "source": [
        "It works with dictionaries too"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "adCDsD7CVOXi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "{i: i + 1 for i in [1, 2, 3]}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hr1sBDl6NBCt",
        "colab_type": "text"
      },
      "source": [
        "## Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GnLRc_CKxFsf",
        "colab_type": "text"
      },
      "source": [
        "Defining functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TZJF3UL2M7fg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def is_odd(a):\n",
        "    return a % 2 == 0\n",
        "\n",
        "is_odd(2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lPhb-mFxxNNp",
        "colab_type": "text"
      },
      "source": [
        "Functions can be defined inside functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VYbAIDuBxRne",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def is_odd(a):\n",
        "    \n",
        "    def is_divisible(number, base):\n",
        "        return number % base == 0\n",
        "    \n",
        "    return is_divisible(a, 2)\n",
        "\n",
        "is_odd(2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hoh9vryhxckA",
        "colab_type": "text"
      },
      "source": [
        "You can provide default arguments."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SbjDzfrVfmF6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def add_or_subtract(first, second, operation=\"sum\"):\n",
        "    if operation == \"sum\":\n",
        "        return first + second\n",
        "    elif operation == \"sub\":\n",
        "        return first - second\n",
        "    else:\n",
        "        print(\"Operation not permitted\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Lp6YB6fxqpP",
        "colab_type": "text"
      },
      "source": [
        "Varargs: variable size arguments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "181garp6xsKA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sum_all(*args):\n",
        "    # args is a list of arguments\n",
        "    result = 0\n",
        "    for arg in args:\n",
        "        result += arg\n",
        "    return result\n",
        "\n",
        "# Call vararg function\n",
        "print(\"Sum of all integers up to 10 =\", sum_all(1, 2, 3, 4, 5, 6, 7, 8, 9))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dmKKnwyox7Ai",
        "colab_type": "text"
      },
      "source": [
        "Keyword arguments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WJPliTlnx92u",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_pairs(**kwargs):\n",
        "    # kwargs is a map\n",
        "    for k, v in kwargs.items():\n",
        "        print(k, v)\n",
        "        \n",
        "print_pairs(a=1, b=2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "51bg23Fmx-6b",
        "colab_type": "text"
      },
      "source": [
        "Keyword only arguments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RqZwL6WHyHPN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_car(*, speed, size):\n",
        "    print(\"Car created with speed\", speed, \"and size\", size)\n",
        "    \n",
        "create_car(speed=9, size=3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3Y-h7EAyYhS",
        "colab_type": "text"
      },
      "source": [
        "Functions as parameters\n",
        "\n",
        "It is possible to pass a function as an argument, operation here is assumed to be a function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b_JDJT_6mrqu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def reduce(array, operation):\n",
        "    result = 0\n",
        "    for k, v in enumerate(array):\n",
        "        if k == 0:\n",
        "            result = v\n",
        "        else:\n",
        "            result = operation(v, result)\n",
        "  \n",
        "    return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X43dSGaQzHye",
        "colab_type": "text"
      },
      "source": [
        "Apply the function with another function `add_or_subtract`\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6rE5TSZRzFWW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "one_to_nine = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
        "print(one_to_nine)\n",
        "\n",
        "print(\"Sum of the array\")\n",
        "#The operation is infered from the default parameter of add_or_subtract\n",
        "reduce(one_to_nine, add_or_subtract)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8tiErQ4PzdFH",
        "colab_type": "text"
      },
      "source": [
        "Lambdas\n",
        "\n",
        "A function can also be defined anonymously"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a8bWni3hzadd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"Product of the array\")\n",
        "reduce(one_to_nine, lambda x, y : x * y)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8rBsR8TgzkhS",
        "colab_type": "text"
      },
      "source": [
        "Closures\n",
        "\n",
        "A function can return another function with specific behaviours depending on the arguments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQ9l5wxZm4SV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def get_loss(op_reduce, op_foreach):\n",
        "  \n",
        "    def loss(a, b):\n",
        "        c = []\n",
        "        for av, bv in zip(a, b):\n",
        "            c.append(op_foreach(av, bv))\n",
        "        return op_reduce(c)\n",
        "  \n",
        "    return loss"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-L5B35yEz4Ic",
        "colab_type": "text"
      },
      "source": [
        "This function can help to define mean squared error"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w4a2_Al4z4qW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mse_loss = get_loss(lambda x : sum(x)/len(x), lambda a, b : (a - b) ** 2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jXVJNuY40ARh",
        "colab_type": "text"
      },
      "source": [
        "Or mean absolute error"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MYcFxRq70A4K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mae_loss = get_loss(lambda x : sum(x)/len(x), lambda a, b : abs(a - b))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDKP5V-c0GY8",
        "colab_type": "text"
      },
      "source": [
        "We can check that it works as intended"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oYIyTRmN0G6r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list1 = [0, 1, 1, 3, 0, 2, 3]\n",
        "list2 = [1, 1, 2, 0, 0, 2, 3]\n",
        "\n",
        "list_mse = mse_loss(list1, list2)\n",
        "list_mae = mae_loss(list1, list2)\n",
        "\n",
        "print(\"Two lists:\\n\", list1, \"\\n\", list2)\n",
        "print(\"MSE Loss: {}\\nMAE Loss: {}\".format(list_mse, list_mae))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LoPGG5zNAjoU",
        "colab_type": "text"
      },
      "source": [
        "## Exceptions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eYsGH9tQAlHr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Throw exception\n",
        "raise Exception\n",
        "\n",
        "raise Exception(\"Something went wrong\")\n",
        "raise ValueError\n",
        "raise IndexError\n",
        "raise StopIteration"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IwpCXA3nA3Ap",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Catch exceptions\n",
        "try:\n",
        "    raise ValueError\n",
        "except ValueError:\n",
        "    print(\"Do something else\")\n",
        "finally:\n",
        "    print(\"This part runs always. It is useful for closing files or \"\n",
        "          \"releasing other resources\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p1cOGDXHCR-O",
        "colab_type": "text"
      },
      "source": [
        "## Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r-PruhWd02K0",
        "colab_type": "text"
      },
      "source": [
        "Class definition"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IRXa51OfCPEk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Shape:\n",
        "    pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y93ArCva06GI",
        "colab_type": "text"
      },
      "source": [
        "`shape` is an object of class `Shape`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0m2SgTiS06tB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "shape = Shape()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F6zvhV8H1BVA",
        "colab_type": "text"
      },
      "source": [
        "In legacy python we used to write\n",
        "```python\n",
        "class Shape(object):\n",
        "```\n",
        "This is not needed anymore \n",
        "unless you expect someone to run you code in legacy environment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C-Kvdhg41Ju3",
        "colab_type": "text"
      },
      "source": [
        "More on class definitions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1tCXVcPAB4YQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Shape:\n",
        "    class_field = 9\n",
        "    \n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "        self.value = 42\n",
        "    \n",
        "    def method(self, a):\n",
        "        return a * 2 + self.value"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dKU0asYuazOF",
        "colab_type": "text"
      },
      "source": [
        "## Imports\n",
        "\n",
        "Adding new packages in python is very easy and many packages are available from the box. If you want some library, there is a good chance that someone else wrote it already.\n",
        "\n",
        "Generally, import statement looks like"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VFeYVIqocjsm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import time\n",
        "\n",
        "time.time()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0pNMsOuJctzb",
        "colab_type": "text"
      },
      "source": [
        "You can specify what parts of the package you want to import"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfy8OQqwcr0A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from time import time, sleep\n",
        "\n",
        "print(time())\n",
        "sleep(2)\n",
        "print(time())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mSBeBMM-Vi-z",
        "colab_type": "text"
      },
      "source": [
        "## Other useful features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LrQ4hw8KVliz",
        "colab_type": "text"
      },
      "source": [
        "Multiple assignment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xq5p8zc9VqW8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a, b = 10, 11"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8M8zrRNkVuHM",
        "colab_type": "text"
      },
      "source": [
        "It works with any kind of list-like objects!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bKPgc-E2Vxfp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a, b = [10, 11]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rXH3h0TVVz8r",
        "colab_type": "text"
      },
      "source": [
        "Starred assignment expressions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ydvlwtxOV819",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a, *b = [1, 2, 3, 4]\n",
        "print(b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZ4l0DS_WB5-",
        "colab_type": "text"
      },
      "source": [
        "This works for prefixes and sufixes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eX2_V2CRWHLh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "*a, b, c = [1, 2, 3, 4]\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XHmrP9ayaG6X",
        "colab_type": "text"
      },
      "source": [
        "# Exercises"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cUE9SvlVdc4_",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 1\n",
        "\n",
        "Write a function that samples a uniform random number from `a` to `b`.\n",
        "\n",
        "Use function `random.random` from package `random`. Documentation is available [here](https://docs.python.org/3.7/library/random.html)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jy7ND3SRkeCj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import random\n",
        "\n",
        "def sample_one(*, start, end):\n",
        "    if end <= start:\n",
        "        raise ValueError(f\"`end` should be greater than `start`, \"\n",
        "                         f\"received start={start}, end={end}\")\n",
        "    return start + (end - start) * random.random()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p7CIN4iWr3tx",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 2\n",
        "\n",
        "Write a function that creates a list of length `n` of samples like in Excercise 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_UFZLC4ssAm1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def sample_many(*, start, end, n):\n",
        "    if n <= 0:\n",
        "        raise ValueError(f\"the number of samples should be greater than 0, \"\n",
        "                         f\"received {n}\")\n",
        "    return [sample_one(start=start, end=end) for _ in range(n)]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bDNxuKNHsI-L",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 3\n",
        "\n",
        "Write a function that computes an average of a list of numbers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vhsHU8qXsH50",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def average(array):\n",
        "    return sum(array) / len(array)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4RS0grGJsUsK",
        "colab_type": "text"
      },
      "source": [
        "## Exercise 4\n",
        "\n",
        "Write a function that creates `m` lists like in Exercise 2 and computes average of each list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CCl07aGwsTqY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def create_population(*, start, end, n, size):\n",
        "    if size <= 0:\n",
        "        raise ValueError(f\"the population size should be greater than zero, \"\n",
        "                         f\"received {size}\")\n",
        "    return [average(sample_many(start=start, end=end, n=n))\n",
        "            for _ in range(size)]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u1pZtZ18tr--",
        "colab_type": "text"
      },
      "source": [
        "Create a list of averages of numbers between 1.0 and 2.0. Make each list of size 10. Vary number of averages from 100 to 10000. Adjust number of bins in the histogram for the best visualization.\n",
        "\n",
        "Use `matplotlib` library as follows:\n",
        "```python\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "plt.figure()\n",
        "plt.hist(array, bins=50)\n",
        "plt.show()\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3p1R9T9YtprZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from matplotlib import pyplot as plt\n",
        "\n",
        "plt.figure()\n",
        "plt.hist(create_population(start=1, end=2, n=10, size=10000), bins=70)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WTRc2vViutTR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}