01_part1_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "01_part1_Python.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MatchLab-Imperial/deep-learning-course/blob/master/01_part1_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nw3aSqi7FUjB"
      },
      "source": [
        "# **Python Basics**\n",
        "\n",
        "In this tutorial, we introduce some basic concepts about Python (we use Python 3 by default), the programming language that we will use for the Deep Learning course.\n",
        "\n",
        "In contrast with compiled languages, *e.g.*, C or Java, where instructions in the source code are translated to a lower-level language before being run, Python is an interpreted language and instructions are directly executed without any intermediate steps.\n",
        "\n",
        "*   **Pro**: platform independence, ease debugging, fast prototyping\n",
        "*   **Cons**: lower execution speed\n",
        "\n",
        "In this course, we will use Jupyter Notebooks, like this one. A Jupyter Notebook merges both text and code in the same file. Colab notebooks are Jupyter Notebooks that also give you access to cloud computing, including GPUs, which will be quite helpful for our Deep Learning course. In Jupyter/Colab Notebooks, you can create a new code cell and use it to write a piece of code. Then, you can run this code cell, and after running it, the notebook will show the output below the corresponding code cell, like in this example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a1neDMAqFjn_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5448e5ff-998d-44c2-dcf7-e8f6ea619801"
      },
      "source": [
        "print('Hello world!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello world!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dQOPcJp8ytAF"
      },
      "source": [
        "A characteristic of a Jupyter Notebook is that the variables persist between cells, meaning that the order in which you run the cells is important. After running a piece of code in a cell, you can use subsequent cells to modify or visualize the variables. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VY2s_Ct1z0Fl"
      },
      "source": [
        "a = 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "px1OTBKIz5VC"
      },
      "source": [
        "And now we can print the value of the variable `a` in a new cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6hkhSOm7z1BM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ad6fd53b-8ae0-42e7-a21c-c3a58746a9f3"
      },
      "source": [
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JctnCNL5KOXE"
      },
      "source": [
        "We will use Jupyter Notebooks for the tutorials as we can integrate code and visualisations in the same document, but you can use Python in a more standard way, *i.e.*, you can write instructions on a `.py` file by using your favourite text editor and then you can run your file. For example, you could write `hello_world.py` and execute it from the terminal with `python hello_world.py`. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_I3mQqVIKFeN"
      },
      "source": [
        "## Data type\n",
        "\n",
        "Every variable in Python is an object with a type and correspondent data. Some types are:\n",
        "\n",
        "* **Numeric type:** `float (64 bit), int, long`\n",
        "* **String**\n",
        "* **Boolean:** `True, False`\n",
        "\n",
        "However, Python is dynamically typed, hence you don't need to specify the type of the variable when you initialize it, as the type of the variable depends on the value you store into it. That also means that \"Unlike C or C++ variables, you could have a variable which, right now, holds a number, and later assign a string to it if you need it to change\" as described in the [Python wiki](https://wiki.python.org/moin/Why%20is%20Python%20a%20dynamic%20language%20and%20also%20a%20strongly%20typed%20language)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RnWzAQ7TMbrG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25c342f0-92d4-40d1-8879-a2c01870d1a0"
      },
      "source": [
        "a = 10\n",
        "print(type(a))\n",
        "a = 'Test'\n",
        "print(type(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DIQKixM50zAQ"
      },
      "source": [
        "Python is also strongly typed. In a strongly typed language you cannot perform operations not compatible with the data type, *e.g.*:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xCKF_BvINBXF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 198
        },
        "outputId": "1a18e18f-8ab7-426d-8b7b-a39ba7f657f7"
      },
      "source": [
        "a = 10\n",
        "b = '3'\n",
        "print(a + b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-5-996ce71e8773>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'3'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OmN3-1haKirK"
      },
      "source": [
        " ## Indentation\n",
        "\n",
        "Instead of using braces or other characters, Python uses the indentation level of the line to determine the grouping of statements.\n",
        "For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R7A_MqasLBtJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9cba0366-15bd-409f-89f5-e117267fd070"
      },
      "source": [
        "# This piece of code is correct\n",
        "if True:\n",
        "  if True:\n",
        "    print('Indentation is correct')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Indentation correct\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FmL_ONnOLQCK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "bbed684d-7a49-44e7-ce2b-f25c5453bc69"
      },
      "source": [
        "# This piece of code will fail due to bad indentation\n",
        "# because the print statement is in the same indentation\n",
        "# level as if True\n",
        "if True:\n",
        "  if True:\n",
        "  print('Indentation is correct')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-7-5a107759333b>\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m    print('Indentation correct')\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NI1mrDmOLhR4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "outputId": "bdb7892c-d3b7-4304-85a5-2cad8cdbd2bf"
      },
      "source": [
        "# This piece of code will also fail due to not using any indentation\n",
        "if True:\n",
        "if True:\n",
        "print('Indentation is correct')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-8-29820197763b>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    if True:\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d9dOYDpmFk6I"
      },
      "source": [
        "## Control instructions\n",
        "\n",
        "To manage the flow of your program control instructions are essential. The main types of control instructions you can use are:\n",
        "\n",
        "* `If / elif / else`\n",
        "* Loops\n",
        "* Ternary expression\n",
        "\n",
        "Some examples of how they can be used are:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5hzTezdaFvBn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bdc8b515-aafb-441e-e1e5-c48b06445565"
      },
      "source": [
        "# if/elif/else\n",
        "# Check if the input number is odd or even\n",
        "num = 8\n",
        "if (num%2) == 0:\n",
        "  print(str(num)+\" is an even number.\")\n",
        "else:\n",
        "  print(str(num)+\" is an odd number.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8 is an even number.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XfnbYvyPFxVG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17f5dda0-9d86-41ca-95ee-784e97557439"
      },
      "source": [
        "# if/elif/else\n",
        "# Check if the input number is positive, negative or zero\n",
        "num = 8\n",
        "if num == 0:\n",
        "  print(str(num) + \" is neither negative nor positive.\")\n",
        "elif num < 0:\n",
        "  print(str(num) + \" is a negative number.\")\n",
        "else:\n",
        "  print(str(num) + \" is a positive number.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8 is a positive number.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_java7EMFyoH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b1d4b7a-c1f2-4286-b9e3-4e86fa321590"
      },
      "source": [
        "# Loops\n",
        "# Let's display all the numbers within an interval\n",
        "# 1,10 that are separated by 2\n",
        "left_bound = 1\n",
        "right_bound = 10\n",
        "step = 2\n",
        "# range generates a list of numbers generally used to iterate over\n",
        "# it is defined as range([start], stop[, step]), where start and step are\n",
        "# optional arguments\n",
        "for i in range(left_bound, right_bound, step):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o-GC7aGzQIWm"
      },
      "source": [
        "A ternary expression is defined as:\n",
        "\n",
        "``` variable = expression1 if condition else expression2 ```\n",
        "\n",
        "where `variable` takes value `expression1` if `condition` is `True`, or `expression2` if it is `False`. An example is:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Je_7uoTNF0F-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd3fd0ce-ba25-478a-a7ee-674864ca3a90"
      },
      "source": [
        "# Ternary expression\n",
        "# We check if the input number is odd or even\n",
        "num = 10\n",
        "message = \"{:d} is an even number.\".format(num) if (num%2) == 0  else \"{:d} is an odd number.\".format(num)\n",
        "print(message)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10 is an even number.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yZyxlr1RF1Um"
      },
      "source": [
        "\n",
        "## Functions\n",
        "\n",
        "[Official Documentation](https://docs.python.org/3/reference/compound_stmts.html#function-definitions)\n",
        "\n",
        "Functions are useful for organizing and reusing blocks of code. Functions can be defined with two keywords: `def` and `return`. `def` defines the function, followed by name and input parameters, and `return`, which is followed by output arguments, is used to come back to the call function. \n",
        "\n",
        "In a function, we can set any number of input/output arguments. Besides, there are two types of input arguments: positional (without a name, order matters) and keyword (with a name). Note that keyword arguments need to be defined after positional arguments, and they have a default value.\n",
        "\n",
        "Examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6zo52YpQF8vW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d96b779-7f6d-482d-8856-3fcd3c0c7f51"
      },
      "source": [
        "# Function, one positional argument\n",
        "# Check if the input number is odd or even\n",
        "def isOdd(num):\n",
        "  if (num%2) == 0:\n",
        "    return False\n",
        "  else:\n",
        "    return True\n",
        "\n",
        "\n",
        "def main():\n",
        "\tnum = 10\n",
        "\tanswer = isOdd(num)\n",
        "\tif answer == True:\n",
        "\t\tprint(\"The number is odd\")\n",
        "\telse:\n",
        "\t\tprint(\"The number is even\")\n",
        "    \n",
        "main()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The number is even\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dz8KGrYjF-6W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7f97c1fb-0f39-4384-d492-88f5b510626e"
      },
      "source": [
        "# Function, one positional argument and two keyword arguments\n",
        "# Find the maximum among three values\n",
        "def max_of_three(num1, num2=15, num3=100):\n",
        "  if (num1 >= num2 and num1 >= num3):\n",
        "    return num1\n",
        "  elif (num2 >= num1 and num2 >= num3):\n",
        "    return num2\n",
        "  elif (num3 >= num1 and num3 >= num2):\n",
        "    return num3\n",
        "\n",
        "def main():\n",
        "  var1 = 10\n",
        "  var2 = 30\n",
        "  var3 = 20\n",
        "  # As no keywords are used, only position matters, so num1 = var1,\n",
        "  # num2 = var2 and num3 takes the default value of 100\n",
        "  max_num = max_of_three(var1, var2)\n",
        "  print(\"Max among \" + str(var1) + \", \"+str(var2) + \" and 100 is:\")\n",
        "  print(max_num)\n",
        "  \n",
        "  # As we use the keyword num3, then num2 takes the default value 15\n",
        "  # and num3 = var3\n",
        "  max_num = max_of_three(var1, num3=var3)\n",
        "  print(\"Max among \" + str(var1) + \", \"+str(var3) + \" and 15 is:\")\n",
        "  print(max_num)\n",
        "  \n",
        "\n",
        "main()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Max among 10, 30 and 100 is:\n",
            "100\n",
            "Max among 10, 20 and 15 is:\n",
            "20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CfMrZSOmGBUW"
      },
      "source": [
        "## Exceptions \n",
        "\n",
        "[Official Documentation](https://docs.python.org/2/tutorial/errors.html)\n",
        "\n",
        "Handling errors and exceptions is crucial to have robust programs that do not crash in the middle of an execution, and it can be done by using `try / except / else / finally`.\n",
        "\n",
        "First, the statements in the `try` clause are executed. If an exception (error) is found, the rest of the `try` clause is skipped and the `except` clause is executed. If the `try` clause does not raise an exception, the `else` clause is then executed. And then, the `finally` clause is executed in all cases. \n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwXPNXsiGAtl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a359d717-3155-4980-fee9-88c3ee18b357"
      },
      "source": [
        "# Converts a given input to float\n",
        "def string_to_float(string):\n",
        "  try:\n",
        "    string = float(string)\n",
        "  except:\n",
        "    print(\"Error\")\n",
        "  else:\n",
        "    print(\"Successfully converted\")\n",
        "  finally:\n",
        "    print(\"This line is always executed\")\n",
        "\n",
        "\n",
        "def main():\n",
        "  # '7' can be casted to 7, so this works\n",
        "  num = string_to_float('7')\n",
        "  # float('hello') will raise an exception\n",
        "  num = string_to_float('hello')\n",
        "  \n",
        "main()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Successfully converted\n",
            "This line is always executed\n",
            "Error\n",
            "This line is always executed\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usn74xZaGGpF"
      },
      "source": [
        "## Data structures\n",
        "[Official Documentation](https://docs.python.org/3.7/tutorial/datastructures.html)\n",
        "\n",
        "A data structure provides a way to organize the data in your code. Some basic data structures are:\n",
        "\n",
        "* `tuple`: fixed-length, immutable sequence of python object\n",
        "* `list`: variable length, mutable\n",
        "* `dict`: hash map or associative array with key-values\n",
        "\n",
        "**Tuple examples**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YJSkbnewGMzt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c020708f-9fdc-4356-f856-25d2f94eaf1f"
      },
      "source": [
        "# Declaration\n",
        "warm_colours = ('red', 'orange', 'yellow')\n",
        "warm_colours[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'orange'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QS9axfv5GNUt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f1ff0b2-4796-4401-845b-e342dc7ca324"
      },
      "source": [
        "# Concatenation\n",
        "cool_colours = ('blue', 'green')\n",
        "colours = cool_colours + warm_colours\n",
        "# As tuples are immutable, concatenation creates a new tuple with\n",
        "# elements from cool_colours and warm_colours\n",
        "print(colours)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "('blue', 'green', 'red', 'orange', 'yellow')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5rQ4sxeCGMFW"
      },
      "source": [
        "**List examples**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3IZnZbk2GWYe",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "3ab215a5-452e-4fdb-d1bc-6fb5c071313e"
      },
      "source": [
        "# Declaration\n",
        "warm_colour=['red', 'orange']\n",
        "# Zero-indexing, first index is 0\n",
        "warm_colours[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'red'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "za2rHcPHGXlE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17a21f3e-6301-4d39-a3b0-eb974e4abc39"
      },
      "source": [
        "# Adding elements at the end\n",
        "warm_colour.append('yellow')\n",
        "print(warm_colour)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['red', 'orange', 'yellow']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3CuQ42XRGYg0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d5fcdf1e-96f6-483d-b097-13c5018069e9"
      },
      "source": [
        "# Removing elements\n",
        "# pop without arguments removes the last element\n",
        "warm_colour.pop(1)\n",
        "print(warm_colour)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['red', 'yellow']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "alI6HUtyGZys",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c4ba22a9-12a1-4726-ff69-93d8e583a732"
      },
      "source": [
        "# Concatenating\n",
        "cool_colours = ['blue', 'green']\n",
        "colours = cool_colours + warm_colour\n",
        "print(colours)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['blue', 'green', 'red', 'yellow']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-BkMpOL5Gawt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "21421289-9a4f-4238-b6ca-764a356d026d"
      },
      "source": [
        "# Concatenating with extend method\n",
        "new_warm_colour = ['orange']\n",
        "warm_colour.extend(new_warm_colour)\n",
        "print(warm_colour)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['red', 'yellow', 'orange']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oldPj_pnGb39",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b925278e-7de4-43f5-ef51-2f1474c628dd"
      },
      "source": [
        "# Slicing\n",
        "warm_colour[1:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['yellow', 'orange']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YbPhM3vCGc2l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fc57f2e0-23b0-4a2b-ecfa-2fac271a03bd"
      },
      "source": [
        "# Negative index is used to index starting from the last element \n",
        "warm_colour[1:-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['yellow']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pNHGvn9-GeUl"
      },
      "source": [
        "**Dictionary examples**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fjERyjtQGikf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "874ca9c7-7963-44bd-894e-d16d78182797"
      },
      "source": [
        "# Declaration\n",
        "population = {'UK': 66740000, 'Italy': 59290000, 'France': 65230000}\n",
        "print(population)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'UK': 66740000, 'Italy': 59290000, 'France': 65230000}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DKbHg8fXGjYs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d03263bd-e697-4f2e-bece-7aa47d432a84"
      },
      "source": [
        "# Access\n",
        "population['France']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "65230000"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A3QglIhQGkx1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a354c6f6-6266-44f6-8036-96274727c288"
      },
      "source": [
        "# Removing with pop\n",
        "elem = population.pop('Italy')\n",
        "print(elem)\n",
        "print(population)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "59290000\n",
            "{'UK': 66740000, 'France': 65230000}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aQ4lhs1_Gl3c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39298650-6cf6-4ae2-f0e2-c33afee6d23d"
      },
      "source": [
        "# Merge two dictionaries\n",
        "population_other_countries = {'China': 1386000000, 'Spain': 46570000}\n",
        "population.update(population_other_countries)\n",
        "print(population)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'UK': 66740000, 'France': 65230000, 'China': 1386000000, 'Spain': 46570000}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2hFufbvgHBV"
      },
      "source": [
        "## Classes\n",
        "[Official Documentation](https://docs.python.org/3.7/tutorial/classes.html)\n",
        "\n",
        "A class is a collection of variables and functions (called methods of the class). To define a class, you need to use the `class` keyword."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-k6-9rHqlz8p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "966f4fc9-ae42-4bf3-efe6-b4570b61da72"
      },
      "source": [
        "class CoordinatesClass:\n",
        "  def __init__(self, x=10, y=2):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "   \n",
        "  def printVar(self):\n",
        "    # Here is a guide to format strings! https://pyformat.info/\n",
        "    print(\"Coordinates: ({}, {})\".format(self.x, self.y))\n",
        "    \n",
        "coor = CoordinatesClass(19, 23.3)\n",
        "print(coor.x)\n",
        "coor.printVar()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "19\n",
            "Coordinates: (19, 23.3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GhDBmB7AmJ2Q"
      },
      "source": [
        "The `__init__` method will be called when the object is initialized. The `self` variable in the class refers to the current instance of the object, used to access its variables and methods. A more detailed explanation can be found [here](https://pythontips.com/2013/08/07/the-self-variable-in-python-explained/).  The object will save the variables x and y, which can be accessed using `coor.x` or `coor.y`. We also can use the defined method `printVar` with `coor.printVar()`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mz1FDbYnfdzC"
      },
      "source": [
        "## Modules\n",
        "\n",
        "[Official Documentation](https://docs.python.org/3.7/tutorial/modules.html)\n",
        "\n",
        "If you want to build longer programs, it will be necessary to define functions or classes in different files for easier maintenance. The file with the different Python definitions is what is called a module. Additionally, a collection of modules is called a package.\n",
        "\n",
        "Several packages are used frequently for scientific computation in Python, such as Numpy, as we will see in the second part of this tutorial.\n",
        "\n",
        "To use the modules or packages in your current Python script, you need to use `import`. For example, if we want to import the `math` package, we use:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EYjzx8tKgGYx"
      },
      "source": [
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7JVXXKTujNZR"
      },
      "source": [
        "Now we have access to the functions from the `math` package by doing `math.definition`, for example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B2Mh7hdrjfs9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "74a7ea88-553b-48e8-9e78-2ca863369403"
      },
      "source": [
        "# This function returns the smallest integer not less than x\n",
        "math.ceil(3.7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xmah3sygjtRh"
      },
      "source": [
        "We may want to import the package using another name, then we use `as`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YD-HXtaWj0pz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "feb5fe38-d91a-404b-b196-ee3923e36458"
      },
      "source": [
        "import math as m\n",
        "m.ceil(3.7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c4LRTQ-6j_uo"
      },
      "source": [
        "You can also import definitions from the package to your local symbol table (i.e. without needing to use the `package.definition` format to call it) using `from`: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y9XgjVYWj_P_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "04a1acb8-9eaf-45ca-a03a-c48592587a15"
      },
      "source": [
        "from math import ceil\n",
        "ceil(3.7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zqcBpErvkc81",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "af31bec3-efdc-4433-bacc-92313f4e3013"
      },
      "source": [
        "# You can also combine from and as\n",
        "from math import ceil as c\n",
        "c(5.7)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    }
  ]
}