1-Hands-on_Python3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hands-on Python 3\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/paolodeangelis/Energy_Storage/blob/main/1-Hands-on_Python3.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables and basic mathematics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comments begin with a hash mark `#`\n",
    "\n",
    "\"\"\"\n",
    "Open and close the code section with 3 `\"` for comments longer than one line.\n",
    "Usually, this kind of comment is used at the beginning of a script or a\n",
    "function/class as documentation. (see docstring).\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_variable = \"store string\"  # strings\n",
    "an_integer = 5  # integers\n",
    "a_float = 2.0  # real numbers (numbers with decimal part)\n",
    "a_boolean = True  # booleans (can have only two values `True` or `False`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has no problem doing operations with variables of mixed type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_var = an_integer + a_float\n",
    "type(new_var)  # function `type` returns what type of variable (or object) is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_var = int(new_var)  # the functions `int`, `float`, `bool` and `str`\n",
    "# convert the variable to the respective type\n",
    "type(new_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"Array-like\" Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List (`list`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = [\"can contain anything\", 5, 2.0, True]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[0]  # returns the first (0) element of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[-2]  # returns the second element from the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[1:4]  # portion of list (list slice):\n",
    "# returns portion of list from second (1) to fourth (3) element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "Compared to MATLAB, element numbering starts at `0`, and negative integers (`-1`, `-2`, `...`) are used to access the end of an array instead of `end`, `end-1`, `...`.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list.append(\"append a new item\")\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list.pop(2)  # return and remove the third (2) item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list[0] = \"change the first element\"\n",
    "a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(a_list)  # function `len` returns the length of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionaries `dict`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict = {\n",
    "    \"key\": \"value\",\n",
    "    \"integer\": 5,\n",
    "    \"float\": 2.0,\n",
    "    \"boolean\": True,\n",
    "}  # Exactly like a dictionary we have -> word: definition\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[\"key\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[\"integer\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_dict[\"key\"] = \"modifying an 'entry' in the dictionary\"\n",
    "a_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematical operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 + 2  # Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 - 2  # Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 * 2  # Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 / 2  # Division, WARNING: division in older versions of python can only return the integer part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5.0 / 2.0  # The division between float numbers returns the correct value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "In versioni di python precedenti alla 3.6 la divisione tra interi restituisce un intero corrispondete alla parte intera del quoziente\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5.0 // 2.0  # Division 'integer part' returns only the integer part of the division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5**2  # Esponenziale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 % 2  # Modulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(5 + 2) * 5 + 2  # Order of operations (PEMDAS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Logical operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False  # N.B. python is case sensitive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and not False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "Python is case sensitive\n",
    "\n",
    "`True ≠ true`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 != 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 != 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 >= 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Program flow in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional statements: `if` `elif` `then`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10  # try to change the value of the variable\n",
    "if x > 10:\n",
    "    print(\"x is greater than 10.\")\n",
    "elif x < 10:\n",
    "    print(\"x is less than 10.\")\n",
    "else:\n",
    "    print(\"x is equal to 10.\")\n",
    "# `elif` and `else` are optional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "Unlike other languages, **python simplifies the syntax a lot**. When you write a *statement* you don't need to open and close parentheses (in C you use the bracket `{...}`), but tabulation is IMPORTANT. This means that at the end of a statement, you always put the colon (`:`) and immediately after the instructions to be executed, have an indentation.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ungaretti = [\"M'\" \"illumino\\n\" \"d'\" \"immenso\"]\n",
    "poem = \"\"\n",
    "for word in ungaretti:\n",
    "    poem += word\n",
    "print(poem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "The `+=` (similarly `*=`, `/=`, `...`) \"auto\"-operator adds a value to the variable.\n",
    "\n",
    "The addition operator for strings is equivalent to concatenating them\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    print(i)\n",
    "# range() starts at 0 and counts up to 3 (excluding 3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_list = []\n",
    "for i in range(4, 10, 2):\n",
    "    a_list.append(i)\n",
    "# range() starts at 4 and counts every 2 up to 10 (excluding 10).\n",
    "print(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0\n",
    "while x < 3:\n",
    "    print(f\"{x:d} is less than 3.\")  # String formatting with the `.format` method.\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 16\n",
    "while True:\n",
    "    x //= 2\n",
    "    if x > 1:\n",
    "        print(x)\n",
    "    else:\n",
    "        print(x, \"-> end\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>WARNING: </b> \n",
    "\n",
    "The `while` loop is the main cause of \"infinite loops\" if not used correctly. To stop a loop in advance use the `break` statement\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code nesting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prime = []\n",
    "for i in range(1, 100):\n",
    "    is_prime = True\n",
    "    for p in prime:\n",
    "        if i % p == 0 and p != 1:\n",
    "            is_prime = False\n",
    "            break\n",
    "    if is_prime:\n",
    "        prime.append(i)\n",
    "# NOTE: Pay attention to the indentation of each code block.\n",
    "print(prime)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_primes(n_max: int, display: bool = True) -> list:\n",
    "    \"\"\"Get the prime numbers from 1 to ``n_max``\n",
    "\n",
    "    Args:\n",
    "        n_max (int): the function search for all primes < ``n_max``.\n",
    "        display (bool, optional): if True, print a message with the found prime numbers. Defaults to True.\n",
    "\n",
    "    Raises:\n",
    "        AssertionError: if ``n_max`` is not an integer.\n",
    "        ValueError: if ``n_max`` is greater that 100000.\n",
    "\n",
    "    Returns:\n",
    "        list: the list with the found prime numbers\n",
    "    \"\"\"\n",
    "    # It is a good practice to check that the function receives correct input\n",
    "    if not isinstance(n_max, int):\n",
    "        raise AssertionError(\n",
    "            f\"First argument must be an integer, instead we recive a {type(n_max)}\"\n",
    "        )\n",
    "    if n_max > 100000:\n",
    "        raise ValueError(f\"The first argument is too big ({n_max} > 100000)\")\n",
    "    prime = []\n",
    "    for i in range(1, n_max):\n",
    "        is_prime = True\n",
    "        for p in prime:\n",
    "            if i % p == 0 and p != 1:\n",
    "                is_prime = False\n",
    "                break\n",
    "        if is_prime:\n",
    "            prime.append(i)\n",
    "    if display:\n",
    "        print(f\"prime numbers < {n_max}:\")\n",
    "        print(\n",
    "            \" \".join([f\"{p}\" for p in prime])\n",
    "        )  # other python cool magic:  `for`` loops inside a list (used here to convert numbers to strings)\n",
    "    return prime  # without the `return` instance the function returns `None` (i.e. nothing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the function `help` we print the function documentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(get_primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_primes = get_primes(150, display=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if we pass a number `float` to the function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_primes(1e3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we pass too large a number?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_primes(999999)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Break\n",
    "\n",
    "<img src=\"https://github.com/paolodeangelis/AEM/raw/main/img/coffe_break.jpg\" width=\"400\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes (a.k.a. Objects)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "In python **everything is an object**, in fact even the variables seen before (int, float,...) or functions, are objects.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example let's define the `Student` object which is a sub-class of the `Person` object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TODAY = \"20/05/2024\"\n",
    "\n",
    "\n",
    "class Person:\n",
    "    \"\"\"Person class define virtually a person.\n",
    "\n",
    "    We are not here to answer the philosophical question, \"What is a person?\".\n",
    "    Here a person is defined by the following attributes.\n",
    "\n",
    "    Attributes:\n",
    "        name (str): Name of the person\n",
    "        family name (str): Family name of the person\n",
    "        age (int, optional): How old is the person\n",
    "        birthday (str, optional): The person's birthday\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, name: str, familyname: str, age: int = None, birthday: str = None\n",
    "    ):\n",
    "        \"\"\"Initialize the Person object.\n",
    "\n",
    "        The ``__init__`` method \"initialize\" the object, i.e., allocates a portion\n",
    "        of the memory (object construction). The ``__init__`` function is called every\n",
    "        time an object is created from a class.\n",
    "\n",
    "        Args:\n",
    "            name (str): Name of the person\n",
    "            family name (str): Family name of the person\n",
    "            age (int, optional): How old is the person. Defaults to None.\n",
    "            birthday (str, optional): The person's birthday. Defaults to None.\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.familyname = familyname\n",
    "        self.age = age\n",
    "        self.birthday = birthday\n",
    "\n",
    "    def _convert_date(self, date: str):  # When a method starts with \"_\" it is private\n",
    "        for sep in [\" \", \"-\", \"\\\\\"]:\n",
    "            date = date.replace(sep, \"/\")\n",
    "        day, month, year = (int(s) for s in date.split(\"/\"))\n",
    "        return day + month * 30 + year * 30 * 12\n",
    "\n",
    "    def get_age(self):\n",
    "        if self.age is None:\n",
    "            age = round(\n",
    "                (self._convert_date(TODAY) - self._convert_date(self.birthday))\n",
    "                / (30 * 12)\n",
    "            )\n",
    "        else:\n",
    "            age = self.age\n",
    "        return age\n",
    "\n",
    "\n",
    "class Student(Person):\n",
    "    \"\"\"Student class defines virtually a student.\n",
    "\n",
    "    A student is a person with a \"matricola\".\n",
    "\n",
    "    Attributes:\n",
    "        name (str): Name of the person\n",
    "        family name (str): Family name of the person\n",
    "        matricola (int): Student identification number\n",
    "        age (int, optional): How old is the person\n",
    "        birthday (str, optional): The person's birthday\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        name: str,\n",
    "        familyname: str,\n",
    "        matricola: int,\n",
    "        age: int = None,\n",
    "        birthday: str = None,\n",
    "    ):\n",
    "        \"\"\"Initialize the Person object.\n",
    "\n",
    "        The ``__init__`` method \"initialize\" the object, i.e., allocates a portion\n",
    "        of the memory (object construction). The ``__init__`` function is called every\n",
    "        time an object is created from a class.\n",
    "\n",
    "        Args:\n",
    "            name (str): Name of the person\n",
    "            family name (str): Family name of the person\n",
    "            matricola (int): Student identification number\n",
    "            age (int, optional): How old is the person. Defaults to None.\n",
    "            birthday (str, optional): The person's birthday. Defaults to None.\n",
    "        \"\"\"\n",
    "        super().__init__(\n",
    "            name, familyname, age=age, birthday=birthday\n",
    "        )  # with `super()` calls `__init__` of class Person\n",
    "        self.matricola = matricola\n",
    "        self.grade = None\n",
    "\n",
    "    def set_exam_grade(self, grade: int):\n",
    "        self.grade = grade\n",
    "\n",
    "    def exam_passed(self):\n",
    "        if self.grade is None:\n",
    "            print(f\"{self.name} {self.familyname} do the written exam first.\")\n",
    "        elif self.grade < 15:\n",
    "            print(\n",
    "                f\"{self.name} {self.familyname}, sorry but you fail the exam.\\nTry it again the next date.\"\n",
    "            )\n",
    "        elif self.grade < 18:\n",
    "            print(f\"Dear {self.name} {self.familyname}, you need to do the oral exam.\")\n",
    "        elif self.grade <= 30:\n",
    "            print(f\"Good job {self.name} {self.familyname}! you passed the exam!\")\n",
    "        else:\n",
    "            print(\n",
    "                f\"Good job {self.name} {self.familyname}! you passed the exam CUM LAUDE!\"\n",
    "            )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>NOTE: </b> \n",
    "\n",
    "Name convention:\n",
    "- `CONSTANT` (all caps)\n",
    "- `variables` (all lowercase)\n",
    "- `functions` (all lowercase usually starts with a verb in imperative form ex: get_something, do_something )\n",
    "- `Objects` (first letter capitalized)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Student)  # notice how the `_convert_date` method is not shown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the stundete *Mario Rossi*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario = Student(\"Mario\", \"Rossi\", 271828, birthday=\"01/06/2000\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(mario)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario.get_age()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario.set_exam_grade(28)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mario.exam_passed()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inputs/Outputs (I/O) in python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's open a file to save the data of a trajectory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time = [i / 10 for i in range(5)]\n",
    "height = [-(t**2) + t for t in time]\n",
    "\n",
    "file = open(\"a_file.txt\", \"w\")  # w: write, r: read, a:append\n",
    "file.write(\n",
    "    \"time[s]\".ljust(12, \" \") + \" \" + \"height[m]\".ljust(12, \" \") + \"\\n\"\n",
    ")  # File header\n",
    "for t, y in zip(time, height):\n",
    "    file.write(f\"{t:<12.4e} {y:<12.4e}\" + \"\\n\")\n",
    "file.close()  # once opened, a file must ALWAYS be closed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also a more compact way to write a file, namely using a *context* block that you define with `with`.\n",
    "\n",
    "We open and *append* (`\"a\"`) new trajectory data on the already created file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time = [i / 10 for i in range(5, 11)]\n",
    "height = [-(t**2) + t for t in time]\n",
    "\n",
    "with open(\"a_file.txt\", \"a\") as file:\n",
    "    for t, y in zip(time, height):\n",
    "        file.write(f\"{t:<12.4e} {y:<12.4e}\" + \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try to open and read the newly created file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_r = []\n",
    "height_r = []\n",
    "\n",
    "with open(\"a_file.txt\") as file:\n",
    "    for i, line in enumerate(file):  # `enumerate` simply counts the array items\n",
    "        if i == 0:\n",
    "            # the first line is the header that should be ignored\n",
    "            continue\n",
    "        line_splitted = line.split()\n",
    "        time_r.append(float(line_splitted[0]))\n",
    "        height_r.append(float(line_splitted[1]))\n",
    "\n",
    "print(time_r)\n",
    "print(height_r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages and Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are going to install (from [PiPy](https://pypi.org/) via [`pip`](https://pip.pypa.io/en/stable/)) the 4 most useful libraries in science/engineering."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating `pip` to the latest version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python -m pip install --upgrade pip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Numpy](https://numpy.org/) \n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/NumPy_logo_2020.svg/1200px-NumPy_logo_2020.svg.png\" width=\"150\"/>\n",
    "\n",
    "NumPy is a library useful for handling large multidimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [SciPy](https://scipy.org/)\n",
    "<img src=\"https://scipy.org/images/logo.svg\" width=\"70\"/>\n",
    "\n",
    "SciPy is a free fundamental for scientific and technical computing. It contains modules for optimization, linear algebra, integration, interpolation, special functions, FFT, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install scipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [pandas](https://pandas.pydata.org/)\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/e/ed/Pandas_logo.svg/1200px-Pandas_logo.svg.png\" width=\"150\"/>\n",
    "\n",
    "pandas is a library for data manipulation and analysis. In particular, it offers data structures (`DataFrame`) and operations to manipulate numeric tables and time series."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [matplotlib](https://matplotlib.org/)\n",
    "<img src=\"https://matplotlib.org/_static/images/logo2.svg\" width=\"170\"/>\n",
    "\n",
    "Matplotlib is a plotting library and its NumPy numerical math extension, SciPy. It provides an object-oriented API for embedding plots in applications using general-purpose GUI tools such as Tkinter, wxPython, Qt, or GTK. It also has a pylab module, designed to look like MATLAB, although its use is discouraged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy, SciPy and Matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np  # import numpy\n",
    "from matplotlib import pyplot as plt  # import the plotting library\n",
    "from scipy.fft import fft, fftfreq  # import the FFT methods\n",
    "from scipy.signal import butter, freqz, lfilter  # import methods for signal analysis\n",
    "\n",
    "plt.style.use(\"default\")\n",
    "\n",
    "SAMPLE_FREQ = 50e3  # [Hz] Sampling frequency\n",
    "WAVE_FREQ = 1e3  # [Hz] Signal frequency\n",
    "NOISE_FREQ_1 = 8e3  # [Hz] Noise frequency 1\n",
    "NOISE_FREQ_2 = 10e3  # [Hz] Noise frequency 2\n",
    "\n",
    "\n",
    "t = np.arange(0, 8 / WAVE_FREQ, 1 / SAMPLE_FREQ)  # [s] sampling interval\n",
    "wave = 2.0 * np.sin(2 * np.pi * WAVE_FREQ * t)  # wave defined as A*sin(2*pi*f*t)\n",
    "noise = 1.0 * np.sin(2 * np.pi * NOISE_FREQ_1 * t) + 0.5 * np.sin(\n",
    "    2 * np.pi * NOISE_FREQ_2 * t\n",
    ")\n",
    "\n",
    "signal = wave + noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 5))\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.plot(t, signal, alpha=0.5, label=\"signal with noise\")\n",
    "    ax.plot(t, noise, label=\"noise\")\n",
    "    ax.plot(t, wave, linewidth=2, label=\"signal\")\n",
    "    ax.legend()\n",
    "    ax.set_xlabel(\"Time [s]\")\n",
    "    ax.set_ylabel(\"Amplitude [-]\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Signal analysis in frequency space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "signal_fft = fft(signal)\n",
    "freq_fft = fftfreq(len(signal), 1.0 / SAMPLE_FREQ)\n",
    "\n",
    "# Low-pass filter (numeric)\n",
    "order = 10  # filter order\n",
    "cutoff = (\n",
    "    5e3  # cutoff frequency (i.e. the frequency at which the signal is reduced by 3 dB)\n",
    ")\n",
    "nyq = 0.5 * SAMPLE_FREQ  # Nyquist frequency\n",
    "b, a = butter(order, cutoff / nyq, btype=\"low\", analog=False)\n",
    "# apply the filter\n",
    "signal_filtred = lfilter(b, a, signal)  # time space\n",
    "signal_filtred_fft = fft(signal_filtred)  # frequency space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize the result (frequency space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 8))\n",
    "\n",
    "# data for the plot\n",
    "filter_freq, filter_amplitude = freqz(b, a, worN=8000)\n",
    "N = len(t)\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax1 = fig.add_subplot(211)\n",
    "    ax2 = fig.add_subplot(212)\n",
    "    ax1.plot(\n",
    "        0.5 * SAMPLE_FREQ * filter_freq / np.pi,\n",
    "        np.abs(filter_amplitude),\n",
    "        label=\"cutoff\",\n",
    "    )\n",
    "    ax1.axvline(cutoff, color=\"k\", linewidth=0.5, label=\"cutoff\")\n",
    "    # plot half of the trransform which is symmetrical\n",
    "    ax2.plot(\n",
    "        freq_fft[: N // 2],\n",
    "        2.0 / N * np.abs(signal_fft)[: N // 2],\n",
    "        label=\"signal with noise\",\n",
    "    )\n",
    "    ax2.plot(\n",
    "        freq_fft[: N // 2],\n",
    "        2.0 / N * np.abs(signal_filtred_fft)[: N // 2],\n",
    "        label=\"signal flitred\",\n",
    "    )\n",
    "    ax2.set_xlabel(\"Frequency [Hz]\")\n",
    "    for ax in [ax1, ax2]:\n",
    "        ax.legend()\n",
    "        ax.set_ylabel(\"Intesity [-]\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize the result (time space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(9, 5))\n",
    "\n",
    "\n",
    "with plt.style.context(\"seaborn\"):\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.plot(t, signal, alpha=0.5, label=\"signal with noise\")\n",
    "    ax.plot(t, wave, label=\"source signal\")\n",
    "    ax.plot(t, signal_filtred, label=\"filtred signal\")\n",
    "    ax.legend()\n",
    "    ax.set_xlabel(\"Time [s]\")\n",
    "    ax.set_ylabel(\"Amplitude [-]\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f56a962d3a7bb3c24c28e660b878abc8ea07b38e319e22d8208006d09eddbc70"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}