0-Python-Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tutorial\n",
    "\n",
    "In this tutorial we'll walk through the basics of python programming and see a little of some useful libraries to use when working with simple machine learninig tasks.\n",
    "\n",
    "## Schedule\n",
    "  1. Why Python?\n",
    "  2. Installation\n",
    "  3. Language paradigm and syntax\n",
    "  4. Types\n",
    "  5. numpy\n",
    "  6. matplotlib\n",
    "  7. pandas\n",
    "  8. scikit-learn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Python?\n",
    "\n",
    "Python is a dynamically typed language with a very intuitive syntax, easy to install packages, run in multiple platforms, its is a mature and stable laguage and has a rich community and package ecosystem.\n",
    "However, Python also has a few drawbacks, like its efficiency and the existence of two stable and incompatible branches. \n",
    "The main point to use Python instead of other languages, like C or Fortran, is to optimize the time you spend coding, so simple one-shot tasks, data exploration and visualizations are the best use cases for Python. When dealing with tasks that require more computational efficiency, you should use other languange.\n",
    "\n",
    "That said, the Python package ecosystem has a lot of very good packages to deal with heavy number crunching problems and the easy of use can make up for the language ineficiency in many situations, which makes Python a great language to learn even to deal with heavy numerical tasks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation\n",
    "\n",
    "There is many ways to install Python and any of its registered packages onall major systems (Windows, MacOs and Linux). It is possible that your system already has Python installed and ready to use. \n",
    "However, the simplest way to install and use Python, speacially for this tutorial is to go to the [Anaconda download section](https://www.anaconda.com/distribution/#download-section) and download the **Python 3.7** installer for your system.\n",
    "The advantage of using the Anaconda distribuition is to have all the packages that we are going to use, all installed at user level and working the same regardless of the system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laguage Paradigm and syntax\n",
    "\n",
    "Python is a *Object-Oriented Language*, meaning that constructs carry the knowledge of how to deal with itselves. \n",
    "For instance, `\"foo\"` is a string  in Python, and we expect to be able to concatenate strings, so `\"foo\"`, `\"bar\"`, and all other have have in their implementation a method to concatenate with another string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('foobar', 'foobar')"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"foo\" + \"bar\", \"foo\".__add__(\"bar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that string concatanation can be done with `+`, but there is a method in the object `\"foo\"` that is called when one uses the plus sign. This is the general idea in Python, every syntax element is associated with a method for the object (or its type) and that how the object \"knows\" how to deal with itself.\n",
    "The idea in Python is that **Everything is an Object** (except for laguage syntax itself), so we can always discover how to use any object by looking at its attributes and methods interactively and every aspect of the language can be extended for user types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "The most basic element of programming is to assign a name to an object for later reference.\n",
    "To assign variables in Python, just write a valid variable name followed by `=` and then by its value: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo_aba12_cux = 1.2890723"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can ask the type of the variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(foo_aba12_cux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but we can change its value at will"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo_aba12_cux = \"norf\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(foo_aba12_cux)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows what means to be dynamically typed: variables don't have type, they are just names to some object which has a type.\n",
    "Being dynamically typed has advantages and disavantages, but mainly it makes it easier to test ideas.\n",
    "\n",
    "Back to variables, valid names for variables have the following rules:\n",
    "  - characters ASCII: a-zA-z\n",
    "  - digits: 0-9, except as the first character\n",
    "  - underscores: _\n",
    "  - unicode characters: β,ç,á,ô... (starting from Python 3.5)\n",
    "  - can't be a reserved word\n",
    "  \n",
    "When coding in the Jupyter Notebook or in the Ipython repl, a good way to see if the variable name is valid is to rely on the syntax highlighting:\n",
    "\n",
    "```python\n",
    "foo = 1\n",
    "@qux\n",
    "def bar(x):\n",
    "    for i in range(10):\n",
    "        print(i)\n",
    "    return\n",
    "print(2 + 3)\n",
    "print(\"foo!\")\n",
    "```\n",
    "\n",
    "Notice how the syntactic elements are collored differently. The bold green ones are reserved words, the pink ones are operators. The others can be names, but notice that builtin functions are green, so if we assign something to the green names we \"break\" the language regular behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-62-09f57f03a914>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-62-09f57f03a914>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def = 1\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "def = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "can't assign to operator (<ipython-input-63-5408f0c5a712>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-63-5408f0c5a712>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    foo_bar+qux = \"foo\"\u001b[0m\n\u001b[0m                       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to operator\n"
     ]
    }
   ],
   "source": [
    "foo_bar+qux = \"foo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "foobar_123 = \"good\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "old_print = print\n",
    "print = 2.0\n",
    "\n",
    "print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "old_print(\"foo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print = old_print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"foo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python we can assign multiple variables in many weird ways at once:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 7 8 9 10 12 13\n"
     ]
    }
   ],
   "source": [
    "a = 1 \n",
    "\n",
    "# \"Destructions\"\n",
    "\n",
    "b,c,d = variable = 2,3,4  \n",
    "\n",
    "e, _, f = [5,6,7]\n",
    "\n",
    "(g,h),(i,(_,j),k) = {(8,9),(10,(11,12),13)}\n",
    "\n",
    "print(a,b,c,d,f,g,h,i,j,k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is very useful when chaining functions or running throuhg complex data structures in loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control flow\n",
    "\n",
    "The basic control flow structures in Python are:\n",
    "\n",
    "The `if` block:\n",
    "```python\n",
    "if condition == True:\n",
    "    true_statement1()\n",
    "    true_statement2 \n",
    "    ...\n",
    "elif other_condition is False:\n",
    "    elif_statement1\n",
    "    elif_statement2\n",
    "    ...\n",
    "else\n",
    "    catch_all_statement1\n",
    "    catch_all_statement2\n",
    "    ...\n",
    "  \n",
    "out_of_if_block_statement1\n",
    "...\n",
    "\n",
    "```\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_control_var = \"ok\"\n",
    "\n",
    "if type(my_control_var) is float:\n",
    "    print(f\"Its a float. It has half the value {2*my_control_var}\")\n",
    "elif my_control_var == True:\n",
    "    print(\"Its true\")\n",
    "elif my_control_var in \"ok, mate\":\n",
    "    print(\"Found it in 'ok, mate'\")\n",
    "    new_value = ', '.join(3*[my_control_var])\n",
    "    print(new_value)\n",
    "else:\n",
    "    print(\"I don't know...\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `for` loop:\n",
    "```python\n",
    "for value in container:\n",
    "    do_stuff1\n",
    "    do_stuff2\n",
    "    ...\n",
    "    \n",
    "out_of_for_loop_statement1\n",
    "...\n",
    "```\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_awesome_list = [10,9,8,7,6,5,4,3,2,1]\n",
    "for num in my_awesome_list:\n",
    "    print(f\"The current number is {num}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are other control flow structures in Python, like `while` loops, `with` and `try-catch` blocks, but the `if` block and `for` loops are enough to do 99% of the task you will ever encounter.\n",
    "\n",
    "Related to control flow structures is the syntax to build containers descriptively.\n",
    "For instance, we could build a list as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_for_loop_list = []\n",
    "\n",
    "for i in range(10):\n",
    "    value_to_put_in_list = (10*i + 2, -3*i/4)\n",
    "    my_for_loop_list.append(value_to_put_in_list)\n",
    "    \n",
    "my_for_loop_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or in a shorter equivalent way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_descriptive_list = [(10*i+2,-3*i/4) for i in range(10)]\n",
    "my_descriptive_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even add conditions in the list comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_descriptive_list = [(10*i+2,-3*i/4) for i in range(10) if i%2==0]\n",
    "my_descriptive_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This syntactic perk can be used to build any container type in Python: lists, tuples, sets, dictionaries and even user types that implement the container protocol."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "The simplest way to build programs is to encapsulate simple reuseble procedures in functions. \n",
    "To create a function in Python we use the following syntax:\n",
    "\n",
    "```python\n",
    "def function_name(var1, v2, ..., *args, kwarg1=kwarg1_val, ..., **kwargs):\n",
    "    do_stuff1\n",
    "    do_stuff2\n",
    "    ...\n",
    "    return maybe_something\n",
    "```\n",
    "\n",
    "For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_complex_procedure(a,b):\n",
    "    c = (a+b)*10/b + a*(b-10)\n",
    "    return (a,b,c)\n",
    "\n",
    "def my_result(a0,b0,n=10,*args,printit=False):\n",
    "    a,b = a0,b0\n",
    "    for i in range(n):\n",
    "        _,a,b = my_complex_procedure(a,b)\n",
    "    if printit:\n",
    "        print(f\"a={a}, b={b}\")\n",
    "    return {(a0,b0):(a,b)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_result(1,1,5,printit=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions in Python are *First Class Citzens*, meaning they are valid values to assign to variables and to be returned as values. They can even be \"created\" without names with the `lambda` syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for function in [lambda x: x, lambda x: 2*x - 3, lambda x: sum([1.0,x,x**2/2,x**3/6])]:\n",
    "    print(f\"The value of this function at x=0.0 is\\n\\tf(x=0)={function(0.0)}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types\n",
    "\n",
    "Since anything in Python is an object, numbers are objects, booleans are objects, functions are objects and types are objects as well.\n",
    "This means that the only real type in python is `object` (this is not quite true, but is very close).\n",
    "That said, the best way to think about python types is regarding if they are a container or not.\n",
    "We can think of numbers `int`, `float`, `complex`, `bool` and some variations of `str` as *atomic* types, i.e. non containers.\n",
    "On the other hand, `list`, `tuple`, `dict`, `set`, `str` are containers.\n",
    "\n",
    "The main difference is that non container types are always immutable. This means that operations that would modify the value create a new value in memory. Some container types can be modified in place.\n",
    "Also, containers can be visited and iterated over, while atoms can't.\n",
    "\n",
    "Let's briefly see some of the ways to construct and operate on the most basic Python types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numbers\n",
    "\n",
    "In Python we can directly a few numeric types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int\n",
    "a, b = 1, 10\n",
    "\n",
    "# float\n",
    "pi, e = 3.141526, 2.718281\n",
    "\n",
    "# complex\n",
    "c = 1.5 + 9j\n",
    "\n",
    "# hexadecimal, binary\n",
    "m, n = 0x123, 0b1010 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All numeric types can be summed, multiplied, diveded, take the mod and div os integer division among other common numeric operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a+ b,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.539550436806"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " pi*e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-4.102743315607494,)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a*pi - b*e)/(pi + e),"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 5.5, 16, 2910)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 11 % 2, 11 // 2, 11 / 2, 2**4, m*n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "some functions have intuitive names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1, 3.141526)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(1,2), min(1,2), abs(-pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise\n",
    "\n",
    "Calculate the sum of three seqential numbers starting from 45 and incremented by 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "156"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_one = 45\n",
    "second_one = first_one + 7\n",
    "third_on = second_one + 7\n",
    "\n",
    "first_one + second_one + third_on"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Booleans\n",
    "\n",
    "Booleans in Python are `True` and `False` and have type `bool`. However, many things are *logically* equivalent to a boolean, which is only relevant to short circuit if conditions or logical operators. One thing to have in mind when using python is that `None` is also an object, representing the absence of value and `None` is logically equivalent to `False`. For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True, False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 10, \"o\" in \"afternoon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class 'NoneType'> None\n"
     ]
    }
   ],
   "source": [
    "val_of_print = print(\"10\")\n",
    "print(type(val_of_print), val_of_print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WOW!\n"
     ]
    }
   ],
   "source": [
    "if 1 < 10:\n",
    "    print(\"WOW!\")\n",
    "else:\n",
    "    print(\"I knew it\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Won't print next statement\n"
     ]
    }
   ],
   "source": [
    "if print(\"Won't print next statement\"):\n",
    "    print(\"This is a lie\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other values that can be thought as *empity* or *zero* are also equivalent to `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Foo\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(print(\"Foo\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "falsy_values = [[],0,None,\"\",(),set(),{}]\n",
    "for v in falsy_values:\n",
    "    if v:\n",
    "        print(f\"This is not falsy: {v}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any value that is *\"not empty or zero\"* is equivalent to `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is truthy: [0]\n",
      "This is truthy: 0\n",
      "This is truthy: 1e-07\n",
      "This is truthy: 1\n",
      "This is truthy: -3.1415926\n"
     ]
    }
   ],
   "source": [
    "truthy_values = [[0], \"0\", 0.0000001, 1, -3.1415926]\n",
    "for v in truthy_values:\n",
    "    if v:\n",
    "        print(f\"This is truthy: {v}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can perform the common logic operations on `bool`s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not\n",
    "print(\"not A\")\n",
    "print(f\"not True |\\t{not True}\")\n",
    "print(f\"not False|\\t{not False}\")\n",
    "\n",
    "# and \n",
    "print(\"\\n\")\n",
    "print(\"A and B\")\n",
    "print(\"A\\\\B\\tTrue |\\tFalse\\n----------------------\")\n",
    "print(f\"True |\\t{True and True} |\\t{True and False}\")\n",
    "print(f\"False|\\t{False and True}|\\t{False and False}\")\n",
    "\n",
    "# or\n",
    "print(\"\\n\")\n",
    "print(\"A or B\")\n",
    "print(\"A\\\\B\\tTrue |\\tFalse\\n----------------------\")\n",
    "print(f\"True |\\t{True or True} |\\t{True or False}\")\n",
    "print(f\"False|\\t{False or True} |\\t{False or False}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also the *bitwise* logicall operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bitwise and\n",
    "print(True & True, True & False, False & False)\n",
    "\n",
    "# bitwise or\n",
    "print(True | True, True | False, False | False)\n",
    "\n",
    "# bitwise complement (not exactly the `not` operation). negates each bit\n",
    "print(~True, ~False)\n",
    "\n",
    "#bitwise xor\n",
    "print(True ^ True, True ^ False, False ^ False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can combine the concepts of falsy and truthy to short cirtuit operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 > 2 and print(\"ops\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 < 2 and print(\"alright\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 < 2 or print(\"alright again\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 > 2 or print(\"ops\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the common comparisson operators also have intuitive notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 < 2, 1 <= 2, 1 > 2, 1 >= 2, 1 == 2, 1 != 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Container types\n",
    "\n",
    "Container types are, as the name suggests, structured \"bags\" of objects. The most useful in Python is the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "\n",
    "b = [1,2,3,4]\n",
    "\n",
    "c = [[1,2],3,(4,5),{6:[(7,[8,9]),10]}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things we can do with a list:\n",
    "  1. append\n",
    "  2. copy\n",
    "  3. clear\n",
    "  4. count\n",
    "  5. extend\n",
    "  6. index\n",
    "  7. insert\n",
    "  8. pop\n",
    "  9. remove\n",
    "  10. reverse\n",
    "  11. sort\n",
    "  \n",
    "The names do what they sugest, and we can always find what an object can do by creating a variable with a value of that type and using the tab-complete strategy: open a new cell, type the variable name followed by a `.` and hit tab. A list of attributes and methods will show in the notebook and we can figure what to do with that type of object. For instance, try hitting tab in the next cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let use a few of these methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "a.append(1)\n",
    "a.append(3)\n",
    "a.append(1)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.count(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.extend((2,4,6))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.index(1), a.pop(0), a.index(1), a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also get the value at a given index as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that indexing like this does not destroy the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One thing to have in mind with lists is that they are muttable and passed by reference to functions. This can lead to mistakes if the list is modified from one function call to another.\n",
    "To avoid mutability in Python, use `tuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0] = 10000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also do some algebra with lists: `+` is like the extend method and `*` is copy and extend with the copies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1] + [\"foo\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[2,3]*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "Tuples are like lists, but once created can't be modified inplace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ()\n",
    "\n",
    "b = (1,2,3,4)\n",
    "\n",
    "c = (1,(2,3),[4,{5:6}])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c[1] = \"foo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other than the immutabuility, tuples are very similar to lists. We can sum tuples and multiply"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1,2) + (3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1,2)*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists and tuples have a \"glob\" syntax for function calls or list/tuple concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2]\n",
    "b = (3,4)\n",
    "[*a, *b]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_args(*args):\n",
    "    print(\"args is a tuple\")\n",
    "    print(f\"See it as a tuple: {args}\")\n",
    "    print(\"Or see each element:\")\n",
    "    for e in args:\n",
    "        print(f\"{e}\")\n",
    "        \n",
    "print_args(1,\"foo\",{'A':'AAA'},*('2',(2,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicts\n",
    "\n",
    "Dicts lists of key-value pairs. They are muttable, but for a value to be a valid key it must be \"hashble\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {}\n",
    "\n",
    "b = {'1':1, (1,):1, 1:1}\n",
    "bb = {[1]:1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access dict values by their keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b['1'], b[(1,)], b[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and we can modify or insert new key-value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b['1'] = \"one\"\n",
    "b[2] = 0b10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dicts are the most useful data structure in Python, they form the basis for the language type system and are veyr flexible. We can see the methods a dict provide by using the autocompletion trick:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run this cell\n",
    "d = {'a':1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# press tab to see the methods\n",
    "d."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most useful methods for dict are `get`, `keys`, `values` and `items`. Also, there is a \"glob\" syntax for dicts to expand its items within function calls or for concatenating dicts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_kwargs(**kwargs):\n",
    "    print(\"kwargs is a dict:\")\n",
    "    print(f\"See it as a dict: {kwargs}\")\n",
    "    print(\"\\nOr see each item\")\n",
    "    for (k,v) in kwargs.items():\n",
    "        print(f\"{k}: {v}\")\n",
    "\n",
    "print_kwargs(a=1,b=2,**{'c':3,'d':4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {'a':1}\n",
    "b = {'b':2}\n",
    "c = {**a, **b}\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings\n",
    "\n",
    "Strings are containers of character, although there is no char type in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = \"foo\"\n",
    "string2 = \"bar\"\n",
    "\n",
    "string1 + string2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a lot of things we can do with strings, just use the autocomplete trick to find out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# press tab after the dot\n",
    "string1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the most useful methods are the `split` and `join`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "joint_strings = '_'.join([string1, string2])\n",
    "joint_strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "joint_strings.split(\"_\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping containers\n",
    "\n",
    "All the container types in Python can be accessed by iteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_things = [1, \"foo\", ('pi',3.1415)]\n",
    "\n",
    "for t in list_of_things:\n",
    "    print(t)\n",
    "    \n",
    "print(\"\\n\\n\")\n",
    "tuple_of_things = (\"bar\", \"qux\", [1,2,3], {'a':'b'})\n",
    "\n",
    "for t in tuple_of_things:\n",
    "    print(t)\n",
    "    \n",
    "print(\"\\n\\n\")\n",
    "\n",
    "dict_of_things = {1:\"one\", 'a':(1,2,3,4), (\"foo\",(1,2,3)):\"iei\"}\n",
    "print(\"dict keys\")\n",
    "for t in dict_of_things:\n",
    "    print(t)\n",
    "    \n",
    "print(\"\\ndict values\")\n",
    "for t in dict_of_things.values():\n",
    "    print(t)\n",
    "    \n",
    "print(\"\\ndict items = (key,value) pairs\")\n",
    "for (k,v) in dict_of_things.items():\n",
    "    print(f\"{k}: {v}\")\n",
    "    \n",
    "print(\"\\n\\n\")\n",
    "random_string = \"This is a random piece of text\"\n",
    "\n",
    "for c in random_string:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking for inclusion in containers\n",
    "\n",
    "We can query any container for the inclusion of some element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"f\" in \"foo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1,2) in [\"a\", 1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1,2) in [(1,2),(1,3),(4,2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('a',1) in {'a':1}.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "('a',1) in {'a':1}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Exercise 1\n",
    " \n",
    "Complete the following tasks:\n",
    "  1. write a function that accepts a list as input and gives back a list with the elemet `\"intruder\"` in the middle of it. Call the function with any list you want and then check if your original list is unchanged.\n",
    "  2. write a function to check if a given word is in a given string and, if positive, capitalizes it. \n",
    "  3. write the following functions for a numeric input `x`, assumed to be in a list `Xs`:\n",
    "    1. takes `x` and returns `2*x`\n",
    "    2. takes `x` and returns `x - 1`\n",
    "    3. takes `Xs` and returns a list where the elemets are divided by the sum of `Xs`.\n",
    "  4. build a list chaining the application of the functions in the item 3\n",
    "  5. use the string methods to format the string `\"a,b,c,d,e,f,g,h,i\"` so each vowel is capitalized."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "\n",
    "Numpy is a Python package that brings the numpy.array type into our arsenal, which is a fast homogeneous container with lots of numerical methods that increase the efficiency for numerical computations.\n",
    "Numpy arrays are somewhat like lists, somewhat like matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([1.,2,3,4])\n",
    "b = np.ones(4)\n",
    "c = np.zeros(3)\n",
    "d = np.arange(0.0,1.1,0.1)\n",
    "e = np.linspace(0,1,11, endpoint=True)\n",
    "f = np.arange(0,16).reshape((4,4))\n",
    "g = np.ones((2,2,2))\n",
    "\n",
    "print(a,b,c,d,e,f,g,sep=\"\\n\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do a lot of mathematical operations with arrays and most of them are element-wise, relying on a broadcasting mechanism that *\"completes\"* the smaller shape when possible:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, 3*a - 1, a**2, a/2, a.max(), a.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f * a, f @ a, f.T * a, f.T @ a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a * c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.reshape(a.shape + (1,)) * c.reshape((1,)+c.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy also provides trigonometric and other common mathematical functions to deal with arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sin(a), np.cos(a), np.arccos(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also functions to deal with the container aspect of arrays, like `sort`, `reshape` and many others.\n",
    "One aspect of arrays that is very useful is the fancy indexing syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g[0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g[:,1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g[0,...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f[2:4,2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "Matplotlib is THE standard plotting package for Python. Its provides every thing to create all sorts of visualizations, although it is quite \"low level\" and requires a lot of lines of code to make some complex plots.\n",
    "\n",
    "Its relies heavily on the object-oriented paradigm, which means that, in the end, plots are containers of objects that have displayable information and knows how to draw itself.\n",
    "\n",
    "The simplest plot we can do is by calling the `plot` function within the `pyplot` submodule of matplotlib:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot([1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib can deal with numpy arrays and other buitin Python containers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, (ax1,ax2) = plt.subplots(figsize=(7,4),nrows=2,ncols=1)\n",
    "\n",
    "x = np.linspace(-np.pi, np.pi, 51, endpoint=True)\n",
    "ax1.plot(x,np.sin(x), label='sin')\n",
    "ax2.plot(x,np.cos(x), label='cos')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can find what to do with the figure and the objects inside it by using the autocomplete trick, but thing get a little out of control here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# put the cursor after the . and press tab\n",
    "fig."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fortunatelly, matplotlib documentation is very good and there is a lot of examples out in the web, but the main resoning to deal with matplotlib objects is to start the completion after a \"`set_`\" or \"`get_`\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use the trick here, after the _\n",
    "fig.get_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and here to\n",
    "fig.set_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets see how to do some simple and useful customizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax1.set_title(\"Sine function\")\n",
    "ax1.set_xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi])\n",
    "ax1.set_xticklabels(r'$-\\pi$ $-\\frac{\\pi}{2}$ $0$ $\\frac{\\pi}{2}$ $\\pi$'.split())\n",
    "for p,s in ax1.spines.items():\n",
    "    if p in [\"top\", \"right\"]:\n",
    "        s.set_visible(False)\n",
    "\n",
    "l1 = ax1.get_lines()[0]\n",
    "l1.set_color(\"#cc3388\")\n",
    "\n",
    "ax1.legend(loc='upper left')\n",
    "ax2.grid(True)\n",
    "ax2.legend(loc=(1.05,0))\n",
    "\n",
    "fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `plot` method only plot lines. We can plot bars, scatter points and heatmaps by using the appropriate function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.bar(np.arange(0,10), np.random.rand(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample = lambda l,n: np.random.choice(l,n)\n",
    "sample_space = np.linspace(-5,5,101,endpoint=True)\n",
    "plt.scatter(sample(sample_space, 50), sample(sample_space, 50), color='r', marker='*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.pcolormesh(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib also provides 3D plots and functions to produce animations, but we won't cover it here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas\n",
    "\n",
    "Pandas is a package to deal with tabular data sets. It provides de DataFrame type, together with many query, transformation and plotting functions for it, built on top of numpy and matplotlib.\n",
    "\n",
    "A DataFrame is somewhat similar to a Python dict, but with lots of utilities homogeneous columns of data.\n",
    "There is a lot to learn about pandas, but the basics are very simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df = pd.DataFrame({'a':np.random.rand(10), \n",
    "                   'b':np.random.choice([True,False],10),\n",
    "                   'c':np.random.choice(['A','B'],10)})\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can index a DataFrame by the column name, which returns pandas Series object, eiter by the traditional index notation or using the `.` notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can recover a line by using the `loc` indexer, which the line as a pandas Series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['a'][1] == df.loc[1]['a']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can fancy index a Dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df['a']>0.4][df['b']==True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[['a','c','b']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create new columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['d'] = 2*df.a - 1 + df.b*2\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can plot a column against another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.plot.scatter(x='a',y='d')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also merge, split, query and do transformations using methods of a DataFrame and a lot more. To learn everything, consult the pandas documentation, which very good."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scikit-learn and datasets\n",
    "\n",
    "Scikits are Pythons packages followinuo a certain implementation guidelines for specific usecases. The best of them is scikit-learn, a package to do machine learning in Pyhton with plenty examples and datasets to test the models. Some of the ML examples in the next sessions will are built with scikit-learn, so here we just mention the fact that we can use to load simple public datasets, like the iris and digits mnist datasets, commonly used in ML examples and as starting point to implement a model.\n",
    "\n",
    "To load toy datasets in scikit-learn do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import datasets\n",
    "# press the tab key after the \"_\" and choose a dataset\n",
    "my_toy_dataset = datasets.load_boston()\n",
    "my_toy_dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice we can use the autocomplete trick to check which datasets are available, or refer to the documentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# press the tab key with the cursor after \"_\"\n",
    "datasets.load_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see the information available in a dataset by asking for its keys, since its a python dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in my_toy_dataset.keys(): print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and we can use the keys to inspect the detaset contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_toy_dataset[\"DESCR\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also transform it in a pandas DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_toy_dataframe = pd.DatoaFrame(np.hstack([my_toy_dataset['data'],np.atleast_2d(my_toy_dataset['target']).T]),\n",
    "                                columns=my_toy_dataset['feature_names'].tolist()+['target'])\n",
    "my_toy_dataframe.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2\n",
    "\n",
    "Lets fit a line to a sample of points and plot it.\n",
    "\n",
    "Consider a dataset $\\{(x_1,y_1),(x_2,y_2),\\dots,(x_n,y_n)\\}$ for which our theory says that $y = ax + b$.\n",
    "Given that our measure instrument have a nominal precision, we expect the data points to be not exactly described by the theory. We can assign a Gaussian distribution for the errors around the expected behaviour dictated by our model, or in other words we expect $y_i = ax_i + b + \\xi_i$, where $\\xi_i$ are normally distributed.\n",
    "This means that $E = \\sum_i \\xi_i = \\sum_i (y_i - ax_i - b)$ and the task to fit the line is to find the values of the paramenters $a$ and $b$ that minimize the total error $E$.\n",
    "\n",
    "Under this assumptions, the solution to this problem is given by \n",
    "$$\\hat{b} = \\bar{y} - \\hat{a}\\bar{x}$$\n",
    "\n",
    "and \n",
    "\n",
    "$$ \\hat{a} = \\frac{\\sum_i(x_i-\\bar{x})(y_i - \\bar{y})}{\\sum_i(x_i - \\bar{x})^2} $$\n",
    "\n",
    "where $\\bar{x} = \\frac{1}{n}\\sum_i x_i$ and $\\bar{y} = \\frac{1}{n}\\sum_i y_i$\n",
    "\n",
    "In this exercise you must write a function that that takes the dataset and output the solution $\\hat{a}$ and $\\hat{b}$for the line fit and then plot the data points and the line fitted.\n",
    "\n",
    "Use the following data points stored in a dict called `sample`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "+--------+--------+\n",
      "|    x   |    y   |\n",
      "+--------+--------+\n",
      "|  -20.0 |  -67.8 |\n",
      "|  -19.0 |  -64.9 |\n",
      "|  -18.0 |  -60.6 |\n",
      "|  -17.0 |  -56.2 |\n",
      "|  -16.0 |  -54.5 |\n",
      "|  -15.0 |  -51.0 |\n",
      "|  -14.0 |  -45.7 |\n",
      "|  -13.0 |  -43.0 |\n",
      "|  -12.0 |  -40.7 |\n",
      "|  -11.0 |  -36.2 |\n",
      "|  -10.0 |  -33.7 |\n",
      "|   -9.0 |  -30.2 |\n",
      "|   -8.0 |  -26.0 |\n",
      "|   -7.0 |  -24.7 |\n",
      "|   -6.0 |  -21.0 |\n",
      "|   -5.0 |  -16.3 |\n",
      "|   -4.0 |  -13.3 |\n",
      "|   -3.0 |  -8.44 |\n",
      "|   -2.0 |  -6.16 |\n",
      "|   -1.0 |  -3.16 |\n",
      "|    0.0 |   3.22 |\n",
      "|    1.0 |   5.02 |\n",
      "|    2.0 |   8.82 |\n",
      "|    3.0 |   10.8 |\n",
      "|    4.0 |   15.2 |\n",
      "|    5.0 |   19.4 |\n",
      "|    6.0 |   21.6 |\n",
      "|    7.0 |   26.6 |\n",
      "|    8.0 |   29.1 |\n",
      "|    9.0 |   33.0 |\n",
      "|   10.0 |   36.1 |\n",
      "|   11.0 |   42.1 |\n",
      "|   12.0 |   43.7 |\n",
      "|   13.0 |   46.2 |\n",
      "|   14.0 |   51.6 |\n",
      "|   15.0 |   53.0 |\n",
      "|   16.0 |   58.0 |\n",
      "|   17.0 |   59.3 |\n",
      "|   18.0 |   63.4 |\n",
      "|   19.0 |   68.4 |\n",
      "|   20.0 |   72.5 |\n",
      "+--------+--------+\n"
     ]
    }
   ],
   "source": [
    "from numpy.random import randn, seed\n",
    "seed(42)\n",
    "real_a, real_b = 3.5, 1.75\n",
    "sample = {x: y for (x, y) in zip([x_i for x_i in range(-20,21)],\n",
    "                                 [real_b + real_a*x_i + randn() for x_i in range(-20,21)])}\n",
    "\n",
    "print(\"\"\"\n",
    "+--------+--------+\n",
    "|    x   |    y   |\n",
    "+--------+--------+\n",
    "\"\"\" + \"\\n\".join([f\"| {float(x):6.3} | {y:6.3} |\" for (x,y) in sample.items()]) +\\\n",
    "\"\"\"\n",
    "+--------+--------+\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3\n",
    "\n",
    "Monte Carlo simulations are conceptually simple and a very effective approach to sample from unknown probability distributions. The simplest example of Monte Carlo, however, is to compute an approximation to the value of $\\pi$, which we know the first digits to be $3.1415926$.\n",
    "\n",
    "To compute this approximation, we \"compare\" the areas of a squre and a circle inscribed in the square. Suppose the circle to have radius $1$, so the lenght of the sides of the surrounding square must be $2$. If we assign the center of the figures to be in the origin $x=0, y=0$, then the corners of the square are $(-1,-1),(-1,1),(1,1),(1,-1)$ and if we sample random numbers in the interval $[0,1]$ we can cover 1 quarter of the area of the square and one quadrant of the circle.\n",
    "The areas are $1$ for the square quarter and ${\\pi \\over 4}$ for the circle quadrant. So, dividing the number of random points that fall within the circle quadrant by the total number of points sampled is somewhat like dividing the area of the circle quadrant by the area of the square quarter (somewhat meaning that we are estimating the area ratio and the estimate gets better the more we sample.  \n",
    "The precision of the estimate depends, in this case, only on the sample size). The area ratio should also be an estimate for $\\pi \\over 4$ in this case.\n",
    "Notice that a point $(x,y)$ within the cicle must satisfy $x^2 + y^2 \\le 1$.\n",
    "\n",
    "In this exercise you must implement a this Monte Carlo simulation that returns an estimate for the value of $\\pi$. It should accept as input the number of sample points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Exercise 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Exercise 1\n",
    " \n",
    "Complete the following tasks:\n",
    "  1. write a function that accepts a list as input and gives back a list with the elemet `\"intruder\"` in the middle of it. Call the function with any list you want and then check if your original list is unchanged.\n",
    "  2. write a function to check if a given word is in a given string and, if positive, capitalizes it. \n",
    "  3. write the following functions for a numeric input `x`, assumed to be in a list `Xs`:\n",
    "    1. takes `x` and returns `2*x`\n",
    "    2. takes `x` and returns `x - 1`\n",
    "    3. takes `Xs` and returns a list where the elemets are divided by the sum of `Xs`.\n",
    "  4. build a list chaining the application of the functions in the item 3\n",
    "  5. use the string methods to format the string `\"a,b,c,d,e,f,g,h,i\"` so each vowel is capitalized and the letters are separated by \"_:_\" instead of \",\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 0.8181818181818182, 0.6363636363636364, 0.45454545454545453, 0.2727272727272727, 0.09090909090909091, -0.09090909090909091, -0.2727272727272727, -0.45454545454545453, -0.6363636363636364, -0.8181818181818182]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'A_:_b_:_c_:_d_:_E_:_f_:_g_:_h_:_I'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def break_in(l):\n",
    "    n = len(l)\n",
    "    return l[:n//2] + [\"intruder\"] + l[n//2:]\n",
    "\n",
    "def find_and_capitalize(w,s):\n",
    "    if w in s: s.replace(w,w.capitalize())\n",
    "    return s\n",
    "\n",
    "def doubles_it(x):\n",
    "    return 2*x\n",
    "\n",
    "def decrement_it(x):\n",
    "    return x - 1\n",
    "\n",
    "def normalize_by_sum(Xs):\n",
    "    return [x/sum(Xs) for x in Xs]\n",
    "\n",
    "item_4_list = normalize_by_sum([decrement_it(doubles_it(x)) for x in range(-5,6)])\n",
    "print(item_4_list)\n",
    "\n",
    "def capitalize_vowels(s):\n",
    "    if s in \"aeiou\": return s.capitalize()\n",
    "    return s\n",
    "    \n",
    "original_string = \"a,b,c,d,e,f,g,h,i\"\n",
    "\"_:_\".join([capitalize_vowels(p) for p in original_string.split(',')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Exercise 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "+---+--------+--------+\n",
      "|   | Real   | Fit    |\n",
      "+---+--------+--------+\n",
      "| a |    3.5 |   3.48 |\n",
      "| b |   1.75 |   1.55 |\n",
      "+---+--------+--------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def line_fit_coefficients(data):\n",
    "    mean_x, mean_y = (sum(a)/len(a) for a in zip(*data.items()))\n",
    "    hat_a = sum((mean_x - x_i)*(mean_y - y_i) \n",
    "                for (x_i, y_i) in data.items())/sum((mean_x - x_i)**2\n",
    "                                                       for x_i in data.keys())\n",
    "    hat_b = mean_y - hat_a*mean_x\n",
    "    return hat_a, hat_b\n",
    "\n",
    "hat_a, hat_b = line_fit_coefficients(sample)\n",
    "print(f\"\"\"\n",
    "+---+--------+--------+\n",
    "|   | Real   | Fit    |\n",
    "+---+--------+--------+\n",
    "| a | {real_a:6.3} | {hat_a:6.3} |\n",
    "| b | {real_b:6.3} | {hat_b:6.3} |\n",
    "+---+--------+--------+\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fbb183386d8>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6,6))\n",
    "x, y = zip(*sample.items())\n",
    "ax.plot(x, y, '.',label='Data')\n",
    "ax.plot(x, [hat_b + hat_a*x_i for x_i in x], label='Fit')\n",
    "ax.legend(loc=(1.02,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution to Exercise 3  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = np.ones(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1.])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([*foo,*foo])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.1864"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 216x216 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "rand = np.random.rand\n",
    "\n",
    "def mc_sample_pi(n):\n",
    "    x,y = rand(2,n)\n",
    "    circle = x**2 + y**2\n",
    "    within_circle = circle[circle <= 1]\n",
    "    pi_estimate = 4*within_circle.shape[0]/n\n",
    "    # lets plot it\n",
    "    xc,yc = x[circle<=1], y[circle<=1]\n",
    "    xs,ys = x[circle>1], y[circle>1]\n",
    "    c_props, s_props = {'color':'r', 'marker':1}, {'color':'b', 'marker':1}\n",
    "    fig, ax = plt.subplots(figsize=(3,3))\n",
    "#     ax.scatter([*xc,*(-xc),*xc,*(-xc)],[*yc,*yc,*(-yc),*(-yc)],**c_props)\n",
    "#     ax.scatter([*xs,*(-xs),*xs,*(-xs)],[*ys,*ys,*(-ys),*(-ys)],**s_props)\n",
    "    ax.scatter(xc,yc,color='r',marker=1)\n",
    "    ax.scatter(xs,ys,color='b',marker=1)\n",
    "    for p,s in ax.spines.items():\n",
    "        s.set_visible(False)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    return pi_estimate\n",
    "\n",
    "pi_estimate = np.array([mc_sample_pi(10000) for _ in range(1)]).mean()\n",
    "pi_estimate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}