A - Python Basics Review.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=\"left\">\n",
    "  <td>\n",
    "    <a href=\"https://colab.research.google.com/github/fmottes/unito-neural-networks/blob/master/A%20-%20Python%20Basics%20Review.ipynb\">\n",
    "      <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\" style=\"width:175px;\"/>\n",
    "    </a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> **Neural Networks** (MFN0824) </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lectures: _Dr. Matteo Osella_\n",
    "### Notebooks: _Francesco Mottes_\n",
    "<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The material presented in the following is not meant to be a complete introduction to the Python programming language or to programming in general. The purpose of this notebook is to review some basic functionalities of the Python3 language, as well as some of the libraries that are most often used in Machine Learning and scientific applications in general. In particular, we will try to show many of the functionalities that will be needed for the practicals of the Neural Networks course.\n",
    "\n",
    "Further in-depth information, as well as more comprehensive introductions, can be found online quite easily. Below is a (short and incomplete) list of references that can guide further research into the presented topics. Other relevant references will be given when needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python references:\n",
    "- Python programming introductory book: Think Python (FREE: https://greenteapress.com/wp/think-python-2e/)\n",
    "- Python3 Docs: https://docs.python.org/3/\n",
    "- Python stilistic guide: https://www.python.org/dev/peps/pep-0008/\n",
    "\n",
    "### Python modules references:\n",
    "- Numpy Docs: https://numpy.org/\n",
    "- Matplotlib Docs: https://matplotlib.org/\n",
    "- Scikit-learn Docs: https://scikit-learn.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center> **A - Python Basics Review** </center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From Wikipedia:\n",
    "\n",
    "> <p><b>Python</b> is an <a href=\"https://en.wikipedia.org/wiki/Interpreted_language\" title=\"Interpreted language\">interpreted</a>, <a href=\"https://en.wikipedia.org/wiki/High-level_programming_language\" title=\"High-level programming language\">high-level</a>, <a href=\"https://en.wikipedia.org/wiki/General-purpose_programming_language\" title=\"General-purpose programming language\">general-purpose</a> <a href=\"https://en.wikipedia.org/wiki/Programming_language\" title=\"Programming language\">programming language</a>. Created by <a href=\"https://en.wikipedia.org/wiki/Guido_van_Rossum\" title=\"Guido van Rossum\">Guido van Rossum</a> and first released in 1991, Python's design philosophy emphasizes <a href=\"https://en.wikipedia.org/wiki/Code_readability\" class=\"mw-redirect\" title=\"Code readability\">code readability</a> with its notable use of <a href=\"https://en.wikipedia.org/wiki/Off-side_rule\" title=\"Off-side rule\">significant whitespace</a>. Its <a href=\"https://en.wikipedia.org/wiki/Language_construct\" title=\"Language construct\">language constructs</a> and <a href=\"https://en.wikipedia.org/wiki/Object-oriented_programming\" title=\"Object-oriented programming\">object-oriented</a> approach aim to help programmers write clear, logical code for small and large-scale projects.<sup id=\"cite_ref-AutoNT-7_28-0\" class=\"reference\"><a href=\"#cite_note-AutoNT-7-28\">&#91;28&#93;</a></sup></p>\n",
    ">\n",
    "> <p>Python is <a href=\"https://en.wikipedia.org/wiki/Dynamic_programming_language\" title=\"Dynamic programming language\">dynamically typed</a> and <a href=\"https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)\" title=\"Garbage collection (computer science)\">garbage-collected</a>. It supports multiple <a href=\"https://en.wikipedia.org/wiki/Programming_paradigms\" class=\"mw-redirect\" title=\"Programming paradigms\">programming paradigms</a>, including <a href=\"https://en.wikipedia.org/wiki/Structured_programming\" title=\"Structured programming\">structured</a> (particularly, <a href=\"https://en.wikipedia.org/wiki/Procedural_programming\" title=\"Procedural programming\">procedural</a>,) object-oriented, and  <a href=\"https://en.wikipedia.org/wiki/Functional_programming\" title=\"Functional programming\">functional programming</a>. Python is often described as a \"batteries included\" language due to its comprehensive <a href=\"https://en.wikipedia.org/wiki/Standard_library\" title=\"Standard library\">standard library</a>.<sup id=\"cite_ref-About_29-0\" class=\"reference\"><a href=\"#cite_note-About-29\">&#91;29&#93;</a></sup></p>\n",
    ">    \n",
    "> <p>Python was conceived in the late 1980s as a successor to the <a href=\"https://en.wikipedia.org/wiki/ABC_(programming_language)\" title=\"ABC (programming language)\">ABC language</a>. Python&#160;2.0, released in 2000, introduced features like <a href=\"https://en.wikipedia.org/wiki/List_comprehension\" title=\"List comprehension\">list comprehensions</a> and a <a href=\"https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)\" title=\"Garbage collection (computer science)\">garbage collection</a> system capable of collecting <a href=\"https://en.wikipedia.org/wiki/Reference_cycle\" class=\"mw-redirect\" title=\"Reference cycle\">reference cycles</a>. Python&#160;3.0, released in 2008, was a major revision of the language that is not completely <a href=\"https://en.wikipedia.org/wiki/Backward_compatibility\" title=\"Backward compatibility\">backward-compatible</a>, and much Python&#160;2 code does not run unmodified on Python&#160;3.</p>\n",
    ">\n",
    "> <p>The Python&#160;2 language, i.e. Python 2.7.x, was officially discontinued on 1 January 2020 (first planned for 2015) after which security patches and other improvements will not be released for it.<sup id=\"cite_ref-30\" class=\"reference\"><a href=\"#cite_note-30\">&#91;30&#93;</a></sup><sup id=\"cite_ref-31\" class=\"reference\"><a href=\"#cite_note-31\">&#91;31&#93;</a></sup> With Python 2's <a href=\"https://en.wikipedia.org/wiki/End-of-life_(product)\" title=\"End-of-life (product)\">end-of-life</a>, only  Python&#160;3.5.x<sup id=\"cite_ref-32\" class=\"reference\"><a href=\"#cite_note-32\">&#91;32&#93;</a></sup> and later are supported.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first important thing to know about Python is that it is an **interpreted** language. This means that Python code does not need to be compiled into machine code in order to run, but there is another pre-compiled program (called, without much surprise, the **interpreter**) that directly executes the Python code on the machine, line by line. Such a feature, as always, has pros and cons: absence of the compiling step allows python to be an **interactive** language, but also makes it much slower to run with respect to compiled languages (e.g. C/C++). Another consequence of the interpreted nature of Python code is that many errors that in other languages are caught by the compiler, such as undefined variables, get thrown out by python directly at runtime, when met. Thus debugging in Python is made easier by the interactive neature of the language (we can run the code line-by-line to see what's wrong), but slower (errors show up one at a time and we must re-run the whole code each time we fix them, in order to see if another error pops up).\n",
    "\n",
    "The first bit of Python syntax to be known is that the interpreter will ignore all the lines in the code that start with the `#` symbol. We can than use it to insert **comments** in our code which improve human readability and makes debugging easier, especially in complex projects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Variables and Fundamental Types**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables are, quite like in algebra, placeholders. Like algebraic variables, a pyhton variable can take any of the permitted values values (whatever they may be), but unlike in algebra variables are assigned one specific value at any moment in time. They can be of different types and, unlike in other lower-level languages such as C/C++, they must not be declared before usage. The type of the variable is decded by the Python interpreter based on the value it takes.\n",
    "\n",
    "For more information on Python built-in types: https://docs.python.org/3/library/stdtypes.html.\n",
    "\n",
    "Let's see some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# declare a variable named \"var\" and assign the value 1 to it\n",
    "# NOTE: the = operator always works right to left!\n",
    "# That is, takes whatever value is on the right and assigns it to whatever is on the left!\n",
    "var = 1\n",
    "var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter automatically prints variables found without any operations on the last line of the cell. Things can be explicitely printed on screen also using the ``` print()```  function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check type of variable \"var\":\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#now assign a real value to the same variable and check value and type\n",
    "var = 2.6\n",
    "print(var)\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### int type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = -2\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### float type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 2.1\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### complex type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# YOU WILL NOT USE THIS TYPE IN THE COURSE\n",
    "var = 2 + 3j\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### str type\n",
    "\n",
    "string is actually a somewhat more refined data type, with specific possible operations \"attached\" to it. Will be presented in more detail in the following section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 'hello'\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### bool type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = True # or False\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### type casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 5.7\n",
    "int(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5.7'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, False)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NOTE: all values different from 0 are assigned to the True boolean value\n",
    "bool(var), bool(-3), bool(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Operators**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operators take the values that are given to them (either \"raw\" values or assigned to a named variable) and return the result of the operation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Arithmetic operators: `+`, `-`, `*`, `/`, `//` (integer division), `**` (power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 2\n",
    "5*var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13.2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var2 = 7.2\n",
    "3*var + var2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result of arithmetic operations can be assigned to a (new or old) variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-6.4"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var3 = var2/2-5*var\n",
    "var3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4.4"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# increase var3 by 2\n",
    "var3 = var3 + 2\n",
    "var3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-6.4"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#decrease var3 by 2\n",
    "#NOTE THE USE OF THE MORE COINCISE SYNTAX: this can be done with all operators\n",
    "var3 -= 2\n",
    "var3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.35"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 2.7\n",
    "var/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#INTEGER DIVISION\n",
    "var//2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7000000000000002"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# MODULO operator finds the remainder of the integer division\n",
    "var % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#POWER operator\n",
    "3**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#can be use also to find roots:\n",
    "9**.5\n",
    "\n",
    "#NOTE: there is no out-of-the box implementation of the sqrt function in plain python other than this one!!\n",
    "# (you would need to import the \"math\" module to have one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Boolean operators: `and`, `not`, `or`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = False\n",
    "not var, var or True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Comparison operators: `>`, `<`, `>=` (greater or equal), `<=` (less or equal), `==` equality, `!=` inequality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 2.0, 2 > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False, True)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 3\n",
    "\n",
    "3 == var, var < 3, var <= 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 3\n",
    "var2 = 3.0\n",
    "\n",
    "var == var2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var != 5, var != 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Compound Types**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python does not have a `char` data type to store single characters, all text data in python is represented using strings. Strings (as everything in python, to be precise) are actually objects. The meaning of this statement will become clearer later on, for now it is sufficient to know that objects have special functions (*methods*) attached to them. Such functions act on what is \"inside\" the object in manners that are specific to the object in consideration. To give an example, strings have a method that transforms all the letteres in the string to uppercase, but it wouldn't make sense if also an object representing an integer number had the same method (what is an UPPERCASE INTEGER?).\n",
    "\n",
    "Methods are usually not needed for simple data types, but become more and more important as the ojects to which they are attached grow more and more complex. We will now make some examples of operations that can be done with strings, some of which will use string-specific methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello everyone, I am a string.'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = 'Hello everyone, I am a string.' # equivalently: \"Hello everyone, I am a string\"\n",
    "# 'text' is now a string object!\n",
    "\n",
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#number of chars in the text string\n",
    "len(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello everyone, I am a string. Nice to meet you!'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#strings can be added:\n",
    "text = text + \" Nice to meet you!\"\n",
    "\n",
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO EVERYONE, I AM A STRING. NICE TO MEET YOU!\n",
      "hello everyone, i am a string. nice to meet you!\n"
     ]
    }
   ],
   "source": [
    "# .upper() and .lower() string methods\n",
    "\n",
    "#methods are called by appending a . after the object name\n",
    "print(text.upper())\n",
    "print(text.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 'everyone,', 'I', 'am', 'a', 'string.', 'Nice', 'to', 'meet', 'you!']"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#split strings when a space character is found\n",
    "text.split()\n",
    "#NOTE: this method returns an object of type list (we will see it next)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'llo ', 'v', 'ryon', ', I am a string. Nic', ' to m', '', 't you!']"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#split strings when a \"e\" character is found\n",
    "text.split('e')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* INDEXING:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#string elements can be accessed by INDEXING:\n",
    "\n",
    "text[0]\n",
    "\n",
    "# NOTE: INDEXING IN PYTHON STARTS FROM 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hel'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SLICING\n",
    "\n",
    "text[:3]\n",
    "#access all the letters in the string up to index of value 3 (excluded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "llo \n",
      "yone, I am a string. Nice to meet you!\n"
     ]
    }
   ],
   "source": [
    "# in a similar fashion:\n",
    "print(text[2:6])\n",
    "print(text[10:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "to meet you\n"
     ]
    }
   ],
   "source": [
    "# inexing can also be used backwards:\n",
    "print(text[-12:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hloeeyn,Ia  tig iet etyu\n",
      "l eo,\n"
     ]
    }
   ],
   "source": [
    "# indexing step size:\n",
    "\n",
    "#print from index 0 till the end with step size = 2\n",
    "print(text[::2])\n",
    "\n",
    "#print from index 2 to index 17, with step size = 3\n",
    "print(text[2:17:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* FORMATTING:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, I am Paul.'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Paul'\n",
    "\n",
    "'Hello, I am {}.'.format(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am Paul, this is Jane'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name2 = 'Jane'\n",
    "text = 'I am {}, this is {}'\n",
    "\n",
    "text.format(name,name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am Jane, this is Paul'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text = 'I am {1}, this is {0}'\n",
    "\n",
    "text.format(name,name2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am Paul, this is Jane and she is 20.57 years old.'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age = 20.5674009\n",
    "\n",
    "text = 'I am {}, this is {} and she is {:.2f} years old.'\n",
    "\n",
    "text.format(name,name2,age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are collections of Python objects, pretty much as strings are collectiong of single text characters. They work in the same way for what indexing is concerned, but they have some extra features. Objects inside lists can be of any kind, not just characters, and each object can be of a different kind. Ojects inside the list can also be inserted, removed and changed at will, once the list has been created. Lists can also be nested, meaning that one list can contain one or more other lists, with no limits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'hey', 3.5, (3-9j)]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a list object\n",
    "l = [1, 'hey', 3.5, 3-9j]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hey'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'hey', 3.5, 9.21]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#change last element of the list\n",
    "l[-1] = 9.21\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'hey', 3.5, 9.21, 'hello']"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#add an element at the end of the list\n",
    "l.append('hello')\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'hey', 3.5, 9.21, 'hello', 'a', 7]"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#extend a list with elements of another list\n",
    "l.extend(['a',7])\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'hey', 3.5, 9.21, 'hello', 'a', 7, ['a', 7]]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#What happens if I use .append() method instead?\n",
    "l.append(['a',7])\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#access first element of the nested list:\n",
    "l[-1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples, for all our purposes, can be regarded pretty much as lists that CANNOT BE CHANGED. Once a tuple has been created you cannot add, eliminate or change the ojects inside it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 'hey', 3.5, (3-9j))"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create a tuple\n",
    "t = (1, 'hey', 3.5, 3-9j)\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-129-f2e4c6786082>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#If we tru to assing a value to a member of a tuple, python throws an error (EXCEPTION)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#If we tru to assing a value to a member of a tuple, python throws an error (EXCEPTION)\n",
    "t[2] = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: tuples can be **UNPACKED**, meaning that the object they contain can be assigned quickly to other variables, and it can be done all at once!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'hey', 3.5, (3-9j))\n",
      "1 hey 3.5 (3-9j)\n"
     ]
    }
   ],
   "source": [
    "#tuple unpacking:\n",
    "v1, v2, v3, v4 = t\n",
    "\n",
    "#equivalent to:\n",
    "#v1 = t[0]\n",
    "#v2 = t[1]\n",
    "#...\n",
    "\n",
    "print(t)\n",
    "print(v1, v2, v3, v4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are like lists (the are MUTABLE), except for the fact that the index of an object is not just an integer number anymore. You can store an object (**value**) into a dictionary and specify another (IMMUTABLE) object (**key**) that represents the location where you stored your value. In essence, a dictionary is a collection of key-value pairs, where the values can be accessed specifying their attached key.\n",
    "\n",
    "Dictionaries have pro and cons: they take up more memory to be stored with respect to a list, but accessing an element in a dictionary is faster than accessing a list member by index. Moreover, dictionaries are usually more human-readable if the keys have been chosen in a sensible manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 7.5: ['c', 'd'], (1, 5): 'hello'}"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create a dictionary\n",
    "d = {'a':1, 'b':2, 7.5:['c','d'], (1,5):'hello'}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 7.5: ['c', 'd'], (1, 5): 'hello'}"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#create a dictionary - other way\n",
    "d = dict([['a',1], ['b',2], [7.5,['c','d']], [(1,5),'hello']])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "['c', 'd']\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "#access dict elements\n",
    "print(d['a'])\n",
    "print(d[7.5])\n",
    "print(d[(1,5)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 7.5: ['c', 'd'], (1, 5): 'hello', 5: 3}"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#add dict element\n",
    "d[5] = 3\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 7.5, (1, 5), 5]"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#list of dict keys\n",
    "list(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, ['c', 'd'], 'hello', 3]"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#list of dict values\n",
    "list(d.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 1), ('b', 2), (7.5, ['c', 'd']), ((1, 5), 'hello'), (5, 3)]"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#list of dict (key,value) pairs\n",
    "list(d.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 7.5: ['c', 'd'], (1, 5): 'hello', 5: 3, 's': 3, 'ggg': 9}"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#add elements of one dict to another\n",
    "d1 = dict([('s',3),('ggg',9)])\n",
    "\n",
    "d.update(d1)\n",
    "\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Flow Control**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### if ... elif ... else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "statement1 and statement2 are False\n"
     ]
    }
   ],
   "source": [
    "statement1 = False\n",
    "statement2 = False\n",
    "\n",
    "if statement1:\n",
    "    print(\"statement1 is True\")\n",
    "    \n",
    "elif statement2:\n",
    "    print(\"statement2 is True\")\n",
    "    \n",
    "else:\n",
    "    print(\"statement1 and statement2 are False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**NOTE**: program blocks are defined based on their **indentation level**! This is not only for visualization purposes, in Python it is **compulsory** to indent different blocks of code by multiples of the same amount of white spaces (usually one *tab* or *4 blanks*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#remember that comparison operator will return a boolean value:\n",
    "2 == 5, 3 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var = 5 > 0\n"
     ]
    }
   ],
   "source": [
    "#check if var is >, < or = 0\n",
    "var = 5\n",
    "\n",
    "if var < 0:\n",
    "    print('var = {} < 0'.format(var))\n",
    "\n",
    "elif 0 == var: #good practice, in order to avoid bugs given by writing = instead of ==\n",
    "    print('var = 0')\n",
    "    \n",
    "else: # var > 0\n",
    "    print('var = {} > 0'.format(var))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try different values of var!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Looping**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops allow us to run the same portion of code for a number of times (that can be known *a priori* or specified at runtime)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `for` loops\n",
    "\n",
    "In Python, looping is allowed with any type of *iterable* object. This means we can loop not only on the value of an index, but also on the elements of a list, of a tupe, of a dictionary or even characters in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[5, 6, 7, 8, 9]\n",
      "[2, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "#range creates an iterator (NOTE: it is different from an iterable, but it's a technical subtlety) on the given indices\n",
    "print(list(range(10)))\n",
    "print(list(range(5,10)))\n",
    "print(list(range(2,10,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, I am number 0\n",
      "Hello, I am number 1\n",
      "Hello, I am number 2\n",
      "Hello, I am number 3\n"
     ]
    }
   ],
   "source": [
    "#looping in indices:\n",
    "for i in range(4):\n",
    "    print('Hello, I am number {}'.format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hey\n",
      "6\n",
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "#looping on a list (or tuple)\n",
    "l = ['hey', 6, [1,2]]\n",
    "\n",
    "for item in l:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1\n",
      "b 2\n",
      "c 3\n"
     ]
    }
   ],
   "source": [
    "#looping on a dictionary\n",
    "d = dict([('a',1),('b',2),('c',3)])\n",
    "\n",
    "for key in d:\n",
    "    print(key, d[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 hey\n",
      "1 6\n",
      "2 [1, 2]\n"
     ]
    }
   ],
   "source": [
    "#adding the indexing to an iterable\n",
    "l = ['hey', 6, [1,2]]\n",
    "\n",
    "for i, item in enumerate(l):\n",
    "    print(i, item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* LIST COMPREHENSION:\n",
    "    \n",
    "The for loop syntax can also be used to create a list in a faster and more coincise way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a0', 'a1', 'a2', 'a3', 'a4']"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['a'+str(i) for i in range(5)]\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a0', 'a1', 'a2', 'a3', 'a4']"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# same result as:\n",
    "l = []\n",
    "for i in range(5):\n",
    "    l.append('a'+str(i))\n",
    "    \n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#anothe example:\n",
    "l = [x**2 for x in range(5)]\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loops\n",
    "\n",
    "Differently from for loops, while loops will continue running until the specified condition becomes False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Another loop!\n",
      "Another loop!\n",
      "Another loop!\n",
      "Loop ended finally!\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "\n",
    "while a < 3:\n",
    "    print('Another loop!')\n",
    "    a += 1\n",
    "    \n",
    "print('Loop ended finally!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Exceptions**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Exceptions are Python error. They are thrown by the python interpreter at runtime when something goes wrong and they stop the running of the program. Exceptions can be **caught** (that is, handled and managed) with a special construct, if we don't want our code to stop unexpectedly. Exceptions can also be **raised** intentionally, if our code ends up unexpectedly in the wrong section of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'hello' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-08db260f1d00>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# exception gets thrown if we try to use an undefined variable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mhello\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[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'hello' is not defined"
     ]
    }
   ],
   "source": [
    "# an exception gets thrown if we try to use an undefined variable\n",
    "hello*10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exception caught!\n"
     ]
    }
   ],
   "source": [
    "# we can catch any exception thrown by the code\n",
    "try:\n",
    "    hello*10\n",
    "except:\n",
    "    print('Exception caught!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exception caught!\n",
      "name 'hello' is not defined\n"
     ]
    }
   ],
   "source": [
    "#we can catch only a specific exception, all the others will block the program\n",
    "#we can also get the message associated with the error with the 'as' clause\n",
    "try:\n",
    "    hello*10\n",
    "except NameError as err:\n",
    "    print('Exception caught!')\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Wrong value!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-1fd2740093c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#we can also raise a pre-existing exception type or a custom one\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Wrong value!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: Wrong value!"
     ]
    }
   ],
   "source": [
    "#we can also raise a pre-existing exception type or a custom one\n",
    "raise ValueError('Wrong value!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "Wrong anything!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-07b2056101f7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#we can also raise a pre-existing exception type or a custom one\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Wrong anything!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mException\u001b[0m: Wrong anything!"
     ]
    }
   ],
   "source": [
    "#we can also raise a pre-existing exception type or a custom one\n",
    "raise Exception('Wrong anything!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Functions**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function in Python is defined using the keyword `def`, followed by a function name, a signature within parentheses `()`, and a colon `:`. The code that follows, with one additional level of indentation, is the function body. Once defined, functions can be called simply by their name and passing the right arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "#define a function that prints some text\n",
    "\n",
    "def my_function():\n",
    "    \n",
    "    print('Hello!')\n",
    "    \n",
    "    \n",
    "my_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello! I am Jane.\n",
      "Hello! I am Paul.\n",
      "Hello! I am 3.\n"
     ]
    }
   ],
   "source": [
    "#define a function that prints some text\n",
    "#with one argument\n",
    "\n",
    "def my_function(name):\n",
    "    \n",
    "    print('Hello! I am {}.'.format(str(name)))\n",
    "    \n",
    "    \n",
    "my_function('Jane')\n",
    "my_function('Paul')\n",
    "my_function(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "# functions can also give back the result of some internal computation\n",
    "\n",
    "def sqrt(number):\n",
    "    \n",
    "    return number**.5\n",
    "\n",
    "var = sqrt(9)\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is good practice to endow functions with a docstring that explain what they do, the meaning of the arguments and what they return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqrt(number):\n",
    "    '''\n",
    "    Calculates square root of a number.\n",
    "    \n",
    "    Paramaters:\n",
    "    -----------\n",
    "    \n",
    "    name : int or float\n",
    "        Number the sqrt of which will be calculated.\n",
    "    \n",
    "    \n",
    "    Returns:\n",
    "    ---------\n",
    "    float : square root of the argument\n",
    "    \n",
    "    '''\n",
    "    \n",
    "    return number**.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function sqrt in module __main__:\n",
      "\n",
      "sqrt(number)\n",
      "    Calculates square root of a number.\n",
      "    \n",
      "    Paramaters:\n",
      "    -----------\n",
      "    \n",
      "    name : int or float\n",
      "        Number the sqrt of which will be calculated.\n",
      "    \n",
      "    \n",
      "    Returns:\n",
      "    ---------\n",
      "    float : square root of the argument\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#show docstring\n",
    "help(sqrt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "(3, [2], [9])\n",
      "(3, [2, 3], [9, 27])\n"
     ]
    }
   ],
   "source": [
    "# default arguments and multiple return values\n",
    "\n",
    "def power(number, exponents=[2]):\n",
    "    '''\n",
    "    Calculates the specified powers of the given number.\n",
    "    '''\n",
    "    \n",
    "    powers = [number**e for e in exponents]\n",
    "    \n",
    "    return number, exponents, powers\n",
    "\n",
    "\n",
    "print(type(power(3)))\n",
    "print(power(3))\n",
    "print(power(3,[2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[2, 3, 4]\n",
      "[9, 27, 81]\n"
     ]
    }
   ],
   "source": [
    "#function results can be unpacked!\n",
    "num, exponents, results = power(3,[2,3,4])\n",
    "\n",
    "print(num)\n",
    "print(exponents)\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Modules**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modules are external python files that can be imported and used in the code, without having to explicitely re-write all the code that they contain. Python modules usually contain the definition of useful functions or classes (see next section) that we want to use in the present code. Python comes with many pre-installed libraries that do a lot of useful things, if you installed Python with Anaconda the pre-installed libraries are even more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the math module that contain some pre-implemented functions\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "4.0\n",
      "148.4131591025766\n"
     ]
    }
   ],
   "source": [
    "#now math functionalities are available for direct usage\n",
    "\n",
    "print(math.factorial(5))\n",
    "print(math.sqrt(16))\n",
    "print(math.exp(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# modules can also be assigned a new name in the current environment, upon import\n",
    "import math as m\n",
    "\n",
    "m.factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can also import specific functions\n",
    "#this allows us to use the functions as if they were hardcoded in the notebook\n",
    "\n",
    "from math import factorial\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'exp' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-25-c0de36fc911a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# what happens if we try to use a function that was not imported?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'exp' is not defined"
     ]
    }
   ],
   "source": [
    "# what happens if we try to use a function that was not imported?\n",
    "exp(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "148.4131591025766"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can also import all what's inside a module at once\n",
    "#this allows us to use the functions as if they were hardcoded in the notebook\n",
    "\n",
    "from math import *\n",
    "\n",
    "exp(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create your own modules in order to make the code cleaner and make it easier to re-use the code. See, for example, [this link](https://stackoverflow.com/questions/37072773/how-to-create-and-import-a-custom-module-in-python/37074372)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Classes and Object-Oriented Programming**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will pretty much use ojects created by other people more than creating our own objects, but having a look at how they work is insightful, at least in order to know how to manipulate them correctly.\n",
    "\n",
    "Objects, roughly speaking, are entities that are endowed with variables that describe their internal state (**attributes**) and functions that act on that internal state (**methods**). Classes are the blueprints from which you can create many objects of the same kind, they describe which attributes they have and the way in which they can interact with their attributes and, often, with the outside environment.\n",
    "\n",
    "Objects behave pretty much as one would expect them to act in the real world. Let's see some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create the blueprint for all objects of type \"bicycle\"\n",
    "#we build a simplified bycicle with only one attribute, the gear\n",
    "\n",
    "class Bicycle():\n",
    "    \n",
    "    #this function must always be present!\n",
    "    #gets called everytime we create (INSTANTIATE) a new object of type Bicycle\n",
    "    def __init__(self, name=None):\n",
    "        \n",
    "        self.name = name #give a name to our bike\n",
    "        self.gear = 1 #start always at the lowest gear\n",
    "        \n",
    "    def gear_up(self):\n",
    "        '''\n",
    "        Increment gear by 1.\n",
    "        '''\n",
    "        \n",
    "        self.gear += 1\n",
    "        \n",
    "    def gear_down(self):\n",
    "        '''\n",
    "        Decrement gear by 1.\n",
    "        '''\n",
    "        \n",
    "        self.gear -= 1\n",
    "        \n",
    "    def get_gear(self):\n",
    "        '''\n",
    "        Tells us which is the current gear.\n",
    "        '''\n",
    "        \n",
    "        return self.gear\n",
    "        \n",
    "    def get_name(self):\n",
    "        '''\n",
    "        Tells us the name of the bicycle.\n",
    "        '''\n",
    "        \n",
    "        return self.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Larry\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# now we can create a specific bicycle, named Larry\n",
    "\n",
    "larry_bike = Bicycle('Larry')\n",
    "\n",
    "#check we got Larry\n",
    "print(larry_bike.get_name())\n",
    "\n",
    "#check we are in first gear\n",
    "print(larry_bike.get_gear())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Larry\n",
      "Paul\n"
     ]
    }
   ],
   "source": [
    "#There are no PRIVATE variables in Python, everything is always PUBLIC\n",
    "#technically we could also do:\n",
    "print(larry_bike.name)\n",
    "\n",
    "#and change name of bike from here\n",
    "larry_bike.name = 'Paul'\n",
    "print(larry_bike.get_name())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is highly recommended that you do not \"touch\" directly one object's attributes, but only through its implemented methods. Methods usually implement also a number of internal checks and logics that cannot be seen from the outside and messing with attributes, although always technically possible, may leave an object in an inconsistent state and cause malfunctions.\n",
    "\n",
    "For example, we could modify our bike to have gears only from 1 to 7, which is pretty sensible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create the blueprint for all objects of type \"bicycle\"\n",
    "#we build a simplified bycicle with only one attribute, the gear\n",
    "\n",
    "class Bicycle():\n",
    "    \n",
    "    #this function must always be present!\n",
    "    #gets called everytime we create (INSTANTIATE) a new object of type Bicycle\n",
    "    def __init__(self, name=None):\n",
    "        \n",
    "        self.name = name #give a name to our bike\n",
    "        self.gear = 1 #start always at the lowest gear\n",
    "\n",
    "        \n",
    "    def gear_up(self):\n",
    "        '''\n",
    "        Increment gear by 1.\n",
    "        '''\n",
    "        \n",
    "        self.gear += 1\n",
    "        \n",
    "        if not (self.gear > 0 and self.gear <= 7):\n",
    "            self.gear -= 1\n",
    "            print('Gear out of bounds!')\n",
    "        \n",
    "    def gear_down(self):\n",
    "        '''\n",
    "        Decrement gear by 1.\n",
    "        '''\n",
    "        \n",
    "        self.gear -= 1\n",
    "        \n",
    "        if not (self.gear > 0 and self.gear <= 7):\n",
    "            self.gear += 1\n",
    "            print('Gear out of bounds!')\n",
    "        \n",
    "    def get_gear(self):\n",
    "        '''\n",
    "        Tells us which is the current gear.\n",
    "        '''\n",
    "        \n",
    "        return self.gear\n",
    "        \n",
    "    def get_name(self):\n",
    "        '''\n",
    "        Tells us the name of the bicycle.\n",
    "        '''\n",
    "        \n",
    "        return self.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#create a new bike with no name\n",
    "anon_bike = Bicycle()\n",
    "\n",
    "print(anon_bike.get_name())\n",
    "print(anon_bike.get_gear())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gear out of bounds!\n"
     ]
    }
   ],
   "source": [
    "#try to decrease gear\n",
    "anon_bike.gear_down()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#everything works as expected as long as the object stays in the state in which it was build to stay\n",
    "#if we mess up the attributes directly we can \"break\" the oject intended functionality\n",
    "\n",
    "anon_bike.gear = -2\n",
    "\n",
    "anon_bike.get_gear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gear out of bounds!\n",
      "Gear out of bounds!\n",
      "-2\n"
     ]
    }
   ],
   "source": [
    "#gear has now a meaningless value!\n",
    "#even worse we now cannot change it anymore!!!\n",
    "\n",
    "anon_bike.gear_down()\n",
    "anon_bike.gear_up()\n",
    "\n",
    "print(anon_bike.get_gear())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Exercises**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Palindrome detector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#write a function that detects if a string is a palindrome\n",
    "#throw a ValueError exception if the argument is not a string\n",
    "\n",
    "def is_palindrome(string):\n",
    "    \n",
    "    #check argument type\n",
    "    if type(string) != str:\n",
    "        raise ValueError('Input is not a string!')\n",
    "    else:\n",
    "        is_pal = False\n",
    "        \n",
    "        # YOUR CODE\n",
    "        #check the string, change the value of is_pal on need\n",
    "        \n",
    "    return is_pal\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_strings = ['aijija', 'ghihg', 'kfk sdfg']\n",
    "\n",
    "for string in test_strings:\n",
    "    print(string, is_palindrome(string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#write a function that takes as an input a list of numbers and returns a sorted version of the list\n",
    "# try to figure out your own algorithm for sorting, but if you need help choose one of the (many) standard ways:\n",
    "#https://en.wikipedia.org/wiki/Sorting_algorithm\n",
    "\n",
    "def sort(arg):\n",
    "    \n",
    "    #YOUR CODE\n",
    "    \n",
    "    \n",
    "    \n",
    "    return sorted_list\n",
    "\n",
    "#if you invented your own algorithm, chances are you re-invented an existing one\n",
    "#check out the wikipedia page and try to figure out which category your algorithm falls into!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-3, 0, 2.5, 3, 7, 12]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#your function should return the same ordering of the python function sorted()\n",
    "test_list = [0, 7, 3, 2.5, 12, -3]\n",
    "\n",
    "print(sorted(test_list))\n",
    "print(sort(test_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can represent a matrix as a list of lists\n",
    "#write a function that takes a matrix as input and outputs its transpose\n",
    "#check that the input is a valid matrix (only numbers, right dimensions)\n",
    "\n",
    "def transpose(A):\n",
    "    \n",
    "    # YOUR CODE (checks)\n",
    "    \n",
    "    A_transpose = []\n",
    "    \n",
    "    # YOUR CODE\n",
    "\n",
    "    \n",
    "    return A_transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 9]\n",
      "[4, 5, 6, 9]\n",
      "[7, 8, 9, 9]\n"
     ]
    }
   ],
   "source": [
    "def print_matrix(A):\n",
    "    \n",
    "    for row in A:\n",
    "        print(row)\n",
    "        \n",
    "\n",
    "test_matrix = [[1,2,3,9],[4,5,6,9],[7,8,9,9]]\n",
    "\n",
    "print_matrix(test_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_matrix(transpose(test_matrix))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrix multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#you can represent a matrix as a list of lists\n",
    "#write a function that takes two matrices as input and outputs the product of the two\n",
    "#check that the inputs are valid matrices (only numbers, right dimensions) and their dimensions are compatible\n",
    "\n",
    "def matmul(A,B):\n",
    "    \n",
    "    # YOUR CODE (checks)\n",
    "    \n",
    "    C = []  # C = A dot B\n",
    "    \n",
    "    # YOUR CODE\n",
    "\n",
    "    \n",
    "    return C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 9]\n",
      "[4, 5, 6, 9]\n",
      "[7, 8, 9, 9]\n",
      "\n",
      "[1, 2, 3, 4]\n",
      "[5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "A_test = [[1,2,3,9],[4,5,6,9],[7,8,9,9]]\n",
    "B_test = [[1,2,3,4],[5,6,7,8]]\n",
    "\n",
    "print_matrix(A_test)\n",
    "print()\n",
    "print_matrix(B_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#transpose is the function you defined in the previous exercise\n",
    "C = matmul(A_test,transpose(B_test))\n",
    "\n",
    "print_matrix(C)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}