notebooks/1_ScientificProgramming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Scientific Programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Notebook settings \n",
    "\n",
    "# multiple lines of output per cell\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">### Today\n",
    ">\n",
    "> - Scientific programming\n",
    ">    - [NumPy](#NumPy)\n",
    ">    - [Matplotlib](#Matplotlib)\n",
    "> \n",
    ">\n",
    "> - Regular expressions (another notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A Sample of Python Libraries for Scientific Programming\n",
    "\n",
    "In addition to the Standard Library, `python.org` offers an ever-growing collection of freely available components that are constantly upgraded, tested and updated. There are many modules, packages and programs available from [PyPI](https://pypi.python.org/pypi) - the Python Package Index. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These libraries are developed either to extend the functionalities of Python, or as more specialized/efficient version of existing modules (or both). In the remaining of this tutorial we will briefly introduce two fundamental packages for scientific computing with Python: **NumPy** and **matplotlib**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy\n",
    "\n",
    "The **Num**eric(al) **Py**thon package is the core library for scientific computing in Python. It enriches Python with high performance data structures, as well as with function to manipulate such data structures and for a whole range of numerical routines. \n",
    "\n",
    "**SciPy**, another core scientific package provides a wide inventory on functions that, by operating on NumPy arrays, can be used for a range of scientific applications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when imported, numpy is usually renamed as \"np\". \n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Arrays\n",
    "\n",
    "**ndarrays** (i.e. *N*-dimensional arrays) are the main data structure on which NumPy is based. \n",
    "\n",
    "ndarrays are **multidimensional** **homogeneous** arrays composed by a **predetermined number** of items:\n",
    "\n",
    "\n",
    "- the dimensionality of an ndarray is defined by its **shape** (i.e., a tuple of integers specifying the size of each dimension, a.k.a. *axes*). The number of axes of an array is called its **rank**. \n",
    "\n",
    "\n",
    "- Sometimes \"dimension\" is used interchangeably for the shape and the rank of an array.\n",
    "\n",
    "\n",
    "- Ndarrays are composed by items of the same type. In NumPy arrays, types are defined by the object **dtype** (data-type), and each array is associated to one and only one dtype.\n",
    "\n",
    "\n",
    "- When a ndarray is created, its size is defined and cannot be changed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy arrays can be created in many different ways, among which by passing a regular Python list or tuple to the `array()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# let's create a rank-1 array (i.e. a vector)\n",
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's verify that this is a numpy array\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this is a rank-1 array\n",
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# its only axis has shape [6]\n",
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if not explicitly specified, array() automatically infers the dtype on the basis of the type of the \n",
    "# elements in the list\n",
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 6\n"
     ]
    }
   ],
   "source": [
    "# indexing can be used to access values...\n",
    "print(a[0], a[2], a[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 9, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ... or to change them\n",
    "a[1] = 9\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 9],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the rank of an array can be changed, e.g. into  2-rank array with 3 rows and 2 columns\n",
    "# NB: row*col must be equal to no. of elements (6 here)\n",
    "a.reshape(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "2\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "# the same syntax can be used to create rank 2 arrays\n",
    "b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(b)\n",
    "print(b.ndim)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# but indexing is a bit more articulated\n",
    "print(b[0, 0])\n",
    "print(b[2, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `dtype` option can be used to specify to the `array()` function which type of elements are in the array (see the [NumPy documentation](https://docs.scipy.org/doc/numpy-1.10.1/user/basics.types.html) for the full list of supported data-types):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]\n",
      " [7. 8. 9.]]\n"
     ]
    }
   ],
   "source": [
    "c = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype = \"float32\")\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays with some initial content can be created by using different functions, depending on the **initial value**..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# 2-rank array of zeros\n",
    "a = np.zeros((3, 4))\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# 2-rank array of ones\n",
    "b = np.ones((3, 4))\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]]\n"
     ]
    }
   ],
   "source": [
    "# 2-rank array with an user-selected initial value\n",
    "c = np.full((3, 4), 14.05)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... or on the **function** used to generate the initial values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0.0904358  0.77470158 0.3177095  0.21967632]\n",
      "  [0.22035245 0.03111779 0.26451328 0.33709163]\n",
      "  [0.16473415 0.70002986 0.7641751  0.24900002]]\n",
      "\n",
      " [[0.59536238 0.93562077 0.37195672 0.9190486 ]\n",
      "  [0.33572707 0.80136177 0.2747715  0.23903339]\n",
      "  [0.67345318 0.22368555 0.49437416 0.9984387 ]]]\n"
     ]
    }
   ],
   "source": [
    "# 3-rank array with random values\n",
    "d = np.random.random((2, 3, 4))\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy display arrays according to the following rules:\n",
    "\n",
    "- the last axis is printed left to right\n",
    "\n",
    "- the second-to-last is printed top to bottom\n",
    "\n",
    "- the rest are printed top to bottom as well, but the slices are separated by empty lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array Indexing\n",
    "\n",
    "1-rank array indexing, slicing and iteration works much as for the normal Python lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[3 4 5]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6])\n",
    "print(a[2])\n",
    "print(a[2:5])\n",
    "for v in a: print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When dealing with multidimensional arrays (i.e. rank > 1), it is necessary to specify an index or a slice **for each dimension**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [5 6]\n",
      " [8 9]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
    "print(a.shape)\n",
    "\n",
    "print(a), print(\"--------\")\n",
    "\n",
    "print(a[1, 1]), print(\"--------\")\n",
    "\n",
    "print(a[0:2]), print(\"--------\")\n",
    "\n",
    "print(a[:, 1:3]), print(\"--------\")\n",
    "\n",
    "print(a[0:2, 1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# unspecified indices works the same as with normal lists\n",
    "print(a[:2, :3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# missing indices are considered complete slices\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "# negative indices can be used as well\n",
    "print (a[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The iteration over multidimensional arrays starts always with respect to the first axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6]\n",
      "[7 8 9]\n"
     ]
    }
   ],
   "source": [
    "for v in a: print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**boolean indexing** allows you to pick out all the array elements that satisfy a given condition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True False]\n",
      " [ True False  True]\n",
      " [False  True False]]\n"
     ]
    }
   ],
   "source": [
    "# let's create a boolean array of the same shape as \"a\", where each slot tells us if \n",
    "# that element of \"a\" is an even number\n",
    "even_idx = ( a % 2 == 0 )\n",
    "print(even_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6 8]\n"
     ]
    }
   ],
   "source": [
    "# let's extract the even numbers in our array\n",
    "print(a[even_idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Basic Math \n",
    "\n",
    "Basic mathematical functions apply element-wise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[15.05 15.05 15.05 15.05]\n",
      " [15.05 15.05 15.05 15.05]\n",
      " [15.05 15.05 15.05 15.05]]\n"
     ]
    }
   ],
   "source": [
    "# e.g. for the sum\n",
    "print(b + c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]\n",
      " [14.05 14.05 14.05 14.05]]\n"
     ]
    }
   ],
   "source": [
    "# element-wise multiplication\n",
    "print(b * c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `dot()` can be used to calculate the inner product:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n"
     ]
    }
   ],
   "source": [
    "# inner product of rank 1 matrices, or vectors (returns a number, i.e. a scalar)\n",
    "print(np.dot(np.array([9, 10]), np.array([11, 12])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1 -3]\n"
     ]
    }
   ],
   "source": [
    "# matrix-vector multiplication\n",
    "print(np.dot(np.array([[1, -1, 2],[0, -3, 1]]), np.array([2, 1, 0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  0 -10]\n",
      " [ -3  -1]]\n"
     ]
    }
   ],
   "source": [
    "# matrix-matrix multiplication\n",
    "print(np.dot(np.array([[0, 4, -2], [-4, -3, 0]]), np.array([[0, 1], [1, -1], [2, 3]])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, Numpy functions allow to perform computation on arrays or to transform them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "--------\n",
      "12.0\n",
      "--------\n",
      "[3. 3. 3. 3.]\n",
      "--------\n",
      "[4. 4. 4.]\n"
     ]
    }
   ],
   "source": [
    "# compute the sum of all the elements along an axis\n",
    "print(b)\n",
    "print(\"--------\")\n",
    "print(np.sum(b)) # sum all element\n",
    "print(\"--------\")\n",
    "print(np.sum(b, axis=0)) # think: sum over and \"collapse\" axis 0 (= columns)\n",
    "print(\"--------\")\n",
    "print(np.sum(b, axis=1)) # think: sum over and \"collapse\" axis 1 (= rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "[[0 1 2]\n",
      " [3 4 5]]\n",
      "--------\n",
      "(3, 2)\n",
      "[[0 3]\n",
      " [1 4]\n",
      " [2 5]]\n"
     ]
    }
   ],
   "source": [
    "# transpose of a matrix\n",
    "f = np.arange(6).reshape(2,3)\n",
    "print(f.shape)\n",
    "print(f)\n",
    "print(\"--------\")\n",
    "f_transp = f.T\n",
    "print(f_transp.shape)\n",
    "print(f_transp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> 'regular' (rank 1) vector <<\n",
      "rank: 1\n",
      "shape: (5,)\n",
      "[0 1 2 3 4]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> column vector <<\n",
      "rank: 2\n",
      "shape: (5, 1)\n",
      "[[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]\n",
      " [4]]\n",
      "--------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">> row vector <<\n",
      "rank: 2\n",
      "shape: (1, 5)\n",
      "[[0 1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "# 3 different types of vectors\n",
    "a_1 = np.arange(5)\n",
    "print(\">> 'regular' (rank 1) vector <<\")\n",
    "print(\"rank: \" + str(a_1.ndim))\n",
    "print(\"shape: \" + str(a_1.shape))\n",
    "print(a_1), print(\"--------\")\n",
    "\n",
    "a_2 = a_1.reshape(5,1)\n",
    "print(\">> column vector <<\")\n",
    "print(\"rank: \" + str(a_2.ndim))\n",
    "print(\"shape: \" + str(a_2.shape))\n",
    "\n",
    "print(a_2), print(\"--------\")\n",
    "\n",
    "a_3 = a_2.reshape(1,5)\n",
    "print(\">> row vector <<\")\n",
    "print(\"rank: \" + str(a_3.ndim))\n",
    "print(\"shape: \" + str(a_3.shape))\n",
    "print(a_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`np.linalg` provides access to linear algebra functions, e.g., solvers, eigenvalues/vectors, norms and decompositions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "True\n",
      "--------\n",
      "-2.0000000000000004\n"
     ]
    }
   ],
   "source": [
    "# inverse of a matrix\n",
    "a = np.array([[1., 2.], [3., 4.]])\n",
    "print(a)\n",
    "print(np.linalg.inv(a))\n",
    "print(np.allclose(np.dot(a,np.linalg.inv(a)),np.eye(2)))\n",
    "print(\"--------\")\n",
    "print(np.linalg.det(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "matlotlib is a 2D **plotting library**. \n",
    " \n",
    "You can have an idea of the possibilities offered by this package by exploring the [examples](http://matplotlib.org/examples/index.html) section of the documentation\n",
    "\n",
    "The easiest way to drop plots with matplotlib it is by relying on the MATLAB-like interface provided by the `pyplot` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# to make plots in IPython using Matplotlib, you must first enable IPython's matplotlib mode\n",
    "# we may want to use the backend inline, that will embed plots inside the Notebook\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Line plots\n",
    "\n",
    "Line plots represents the relationship between *x*-values and *y*-values by means of a line. \n",
    "\n",
    "Graphs of this sort can be drawn by using the [`.plot()` function](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot), with its default settings "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make an array for the x-values and one array for the y-values\n",
    "x = np.arange(1, 150)\n",
    "y = np.log(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11c8d8f40>]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's create the plot\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# export the plot in a .pdf file\n",
    "plt.savefig(\"data/exemplar-lineplot.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# export the plot in a .png file\n",
    "plt.savefig(\"data/exemplar-lineplot.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple calls of the `.plot()` function draw **multiple line plots** in the same figure \n",
    "\n",
    "(note that matplotlib will try to automatically manage many graphical parameters among which the axis size and the line colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cb194f0>]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cb198e0>]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y) # think of (x, y) as an array (of rank 2) being plotted\n",
    "plt.plot(x, y * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Scatterplots\n",
    "\n",
    "A scatterplot represents one or more groups of observations as points in a cartesian space. \n",
    "\n",
    "The [`scatter()` function](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.plot) implements a method to draw this kind of plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 100\n",
    "x = np.random.normal(0, 1, n)\n",
    "y = np.random.normal(0, 1, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x11cc8f160>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use different marker settings for `plot()` (marker type, size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cd09910>]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y, \".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Color-coding (the default behavior of both `scatter()` and `plot()` allows you to plot different groups of data points:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x11ce46190>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x11ce46640>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAnVklEQVR4nO3dfXxc1Xkn8N8z0shIIbEcy6kjycTkpaQBHJzIfLq1kxQcIFnAUaGIlA9t+pK6tA0ENrGxk6zj0H4Wxd7UCWm7jdfJbvsJu6CAMSaENQSyIaZLYvkFB0JoExJiSVBkQE6DB/Qyz/4xc6WZ0T137vvLzO/7j63RzJ1zJc1zzz3nOc8RVQUREWVXLukGEBFRMAzkREQZx0BORJRxDORERBnHQE5ElHGtSbxpV1eXLl++PIm3JiLKrIMHDx5X1SW1jycSyJcvX47h4eEk3pqIKLNE5Bm7xzm0QkSUcQzkREQZx0BORJRxDORERBnHQE5ElHEM5ERROToE7DgL2NpZ+vfoUNItogaVSPohUcM7OgTccx0wVSh9feJY6WsAWDGQXLuoIbFHThSFB2+aC+KWqULpcaKQMZATReHEiLfHiQJgICeKwsJeb48TBcBAThSFtVuAfHv1Y/n20uNEIQslkItIp4jcISI/FpEnReQ/hHFcosxaMQBceguwcBkAKf176S2c6KRIhJW18iUA/0dVf1dE2gB0hHRcouxaMcDATbEIHMhF5HUA3gvgDwFAVScBTAY9LhERuRPG0MqbAYwD+B8iclhEdonIa2qfJCLrRWRYRIbHx8dDeFsiIgLCCeStAN4F4L+p6koALwPYVPskVd2pqn2q2rdkyby66ERE5FMYgXwEwIiqfr/89R0oBXYiIopB4ECuqs8BOCYiZ5QfWgvgR0GPS0RE7oSVtXItgFvLGStPA/ijkI5LRER1hBLIVfUIgL4wjkVERN5wZScRUcYxkBMRZRwDORFRxjGQExFlHAM5EVHGMZATEWUcAzkRUcYxkBMRZRwDORFRxjGQExFlHAM5EVHGMZATEWUcAzkRUcYxkKfd0SFgx1nA1s7Sv0eHkm4REaVMWPXIKQpHh4B7rgOmCqWvTxwrfQ1wd3YimsUeeZo9eNNcELdMFUqPExGVMZCn2YkRb48TUVNiIE+zhb3eHieipsRAnmZrtwD59urH8u2lx4mIyhjI02zFAHDpLcDCZQCk9O+lt3Cik4iqMGsl7VYMMHATkSP2yImIMo6BnIgo4xjIiYgyjoGciCjjGMiJiDKOgZyIKOMYyImIMi60QC4iLSJyWES+GdYxiYiovjB75B8H8GSIxyMiIhdCCeQi0gvgYgC7wjgeERG5F1aP/IsANgIohnQ8onTjzk2UIoEDuYhcAuB5VT1Y53nrRWRYRIbHx8eDvi1Rcqydm04cA6BzOzcxmFNCwuiRrwawTkR+DuA2AOeLyNdrn6SqO1W1T1X7lixZEsLbUqjYw3SPOzdRygQO5Kq6WVV7VXU5gA8DeEhVrw7cMooPe5jecOcmShnmkRN7mF5x5yZKmVADuar+X1W9JMxjUgzYw/SGOzdRyrBHTuxhesWdmyhluEMQlXqS91xXPbzCHqYzPzs3HR0qDVedGCldJNduYfCnUDCQ01wwYZCJjjWhbF0srQllgD9nCoyBnEoadW/QtPSCnSaUG/HnTrFiIKfsqhek09QL5oQyRYiTnZRNbnLf05RWyQllihADOWWTmyCdpl4wUxYpQhxaoWxyE6QX9pZ77DVC7gXvOTyK7fuewthEAd2d7dhw0RnoX9lT/SROKKdLWuZOQsJATtnUvggovGj/uCXqtMqjQzh53xasO/kc+nQxtuUGsHdiDTbv/iEA2AfzDAeLhpGmuZOQcGiFGleUC3fKwaCj8CxyoujNHcdgfhfW5fajMDWD7fueCv4eFI00zZ2EhD3yNGuw279QFV5y93hUvWCbYNAhk9jYOoS9k2swNlEwvJASl9TcSYSfZ/bI04oVCZ0lnQVi+NB3ywulfzvbbb9PKZDE307En2cG8rRqwNu/UCWdBWL40I/pYrTnW7DhojPsX8e678lL4m8n4s8zA3lapSl1Lo2SLlxlEwxOaht2tV2Nmy87e/5EJ9Bcd1lpvmAl8bcT8eeZY+RpFVPqXKYlmQVik07YsXYLtjq1p1mW6WchKyTuv52IP8/skadV0kMHVN+KAeCGx4GtE6V/6wWGZrnL4rDgfBF/nhnI0yrpoQMKX9ITtHFplguWFxF/njm0kmZcQNJYmqXuO4cF7UX4eWaPnCguzXKXxWHB2LFHTuSXnwUeYfXK0rxYjHVlYsdATuRHkpkZzAqhGhxaocjtOTyK1YMP4fRN92L14EPYc3g0nAMnmaucZGYGs0KoBnvkFKk9h0exefcPUZiaAQCMThTM1QG9SLpXmmRmBrNCqAZ75BSp7fuemg3illCqAybdK/WSShj2nYMx+0PTt4qSYsFATpEyVQEMXB0w6V6p28yMKJbl2723pZGX/ZMRAzlFylQFMHB1wKQX17hNJYzizqHqvW2EeWeS5popNIuBnCK14aIz0J5vqXrMsTqgW2nIVXazRD+qOwfrvSHRHB9oriJfGcdATpHqX9mDmy87Gz2d7RAAPZ3t5uqAXmRlcU3Udw5RHt90N3HXNeyhpwyzVihy/St7ggduO25zlZNcPBP1svwoj2/q1Wt58tpLplCaFzA1AFHVYAcQWQbgnwAsBVAEsFNVv+T0mr6+Ph0eHg70vkSu1KYpAigNRyggLaWgtHBZtIEl6iAW1fF3nGVfM6XWwmXlYR6H9tldbNJ4B5VyInJQVfvmPR5CIH8jgDeq6iEReS2AgwD6VfVHptcwkFNs3AYjl4Flz+FRbN/3FMYmCujubMeGi86I5m4jDWwvgnakNE9gYvod1LsA0DymQB54aEVVnwXwbPn//y4iTwLoAWAM5ET1hBYw3U76OW3wUO7x6okRrNLFePfUAEaxJrzFTWlVWzNFcnPDKpXqjccnnSraBEKd7BSR5QBWAvi+zffWi8iwiAyPj4+H+bbUYKzVoKMTBSjmVoP6WtrvZdLPLrBUZG4IFD1yHIP5XViX2w8gpMVNaVaZmfM7/+AvUyjpVNEmEFogF5FTAdwJ4HpV/WXt91V1p6r2qWrfkiVLwnpbakChrgZ1WjxTyy6w2GRudMgkNrbOZWsEXtyUFX4zhdKQKtrgQslaEZE8SkH8VlXdHcYxqXmFuhq0anjgGGYnOmsUsACbxi/F8OBD1cM4htv/bnlh7v/lxU1NMX7up6ohy9pGLnAgFxEB8FUAT6rq3wRvUgYwlSpS3Z3tGLUJ2r5Xg1YGn6NDOHnfFrQXnsWM5pCTIp7VLnx+agB7i2uA2nFvw243Y7oYwNzipsiKgzUKlrWNVBg98tUAfh/AD0XkSPmxT6nqt0I4dvokXXWvCWy46IyqoAiEtBoUwGee/g3c+tIXbPrkc6xhnP6VPbZ52gUswPbpAfRU9LpXDz5kHA7KUiBviruKBhRG1sp+GNcJNyCn2hkM5KGwAkfYAWXP4VHc+ugvHIO4ZXYYx2ZY4PG3XIvhH70NYxOF2XH7yIqDxYh3FdnFlZ1eMZXKMz+9vChWg27f95SrIA7UDONUDAvMBbtSgLaCXWdHHi+dnHI+Tso5TTLX+12wJ58sBnKvuEO4J2nq5bntHTsN45iC3YLWHPItgqmZuUtFvkVCGQ5yEmYA9XtXkabfcbNi0SyvmErlSWQbS/jg1Dte1JF3VdTLFNQmClPzk2GCLZquK9R8e/gvOZym33GzYiD3KitV91IiTWPHdiV1BcDVv3kaDm+5ED8bvBiPbDrfsRdpCmotIpgqVkfuqaJGGszCDqB+Sw6n6XfcrDi04gdTqVwLPZUwgDAmUU0ZNbUB1VIbzNIwFGLi9+eTpt9xs2Igp0hFmUroR9BJ1P6VPRh+5kX87+8fw4wqWkRw+bt78J0fj9cNZmGPJUcRQP38fOr+jrnuInIcWqFIRbaxRAB7Do9i9eBDOH3TvVg9+JCnMeU9h0dx58FRzJSrhs6o4s6Dozjv7UvqDkuYhkI+MfSYr3HtyHZf8sjxd8xdhmIRuIytHyxjS0mp7RUDpeDn9uKyevAh217woo48AMymIHa257F13ZlVxzx9073G+U8vbaiU+rQ/lrANVWRlbIliF+BWPUiuNGAef67NIX91ujjvOaahkHptsIL16EQBLSKYUa1aVRoocEc97MF1F7FgIKdsCVgiwRSIRycKWHnT/VUB2a5X7RSMK9kFZrux5Hptq72DsIZ0asfXffXM4yg3wXUXseAYOWWLU4kEF5wmAmt71ROFKWz4RvX4td24tEltYLbGklvEvqKFXdvs7iAs1sXCdz55wJ+lK1x3EQsGcsqWgLfqplxyEysX3JogveH2I1jQmqtaQNTZnrd9rV1g7l/Zgy8MvNP1JGW9VEKr3ouvfPI4hj247iIWHFoh11IxsRbwVt0uV7reUInVw7WC5URhCu35Fuy48pzZYQ0vKZbGfO2WR4Ad1ePV3Z1dju3r7mz3n08e17AH111Ejlkr5ErQbI/QRLAjuykTxWJNMNbq6WzHI5vOBxDCRc5wXgfO/hz+4MCbbIdXrJ+/NRHq1D4v78kec3oxa4Xcs8lk2L6vKx31tiPYbWbDRWdgwx2PVRW8suRz85feWyp7vIGzRwzj1at++mXcfNk+x6wVAP4WXXHnnobBQE7VDJkMfS//EUaxZt7TE6mnEfKtuhUMP3fPE7ZZK6Yeb6hL0B3Gq+tdJAKVHuCwR0NgIKdqhp7h5rZv4O5X5gfyRqmnUS9YRl5mgGl6FACzVqiaoWf4azieiuXgSfBcZuDoUGlF49bO0r9ulqMHSNMLu5wtZQ975M3IaTWfoWcoC3tx82+fHV/WSkQrDv1OSroeA/e7yKZivFpPjODf0IWbX74Cw9/qwoaZUcf3DrpalbKPgbzZ1As0NpsNWz3D/hXhb7/mq40+xbKTTZA9XVcMYM/M6uphHBdtZD1w4tBKVvi5XbdTbzVfGhZwRLTiMJadbAxDU8UTI66GOvy00XFnn7D+bijVGMizIMxSoG5W860YKFWm2zpR+jfurIaAwdAklp6rYXJyrLjY1bi1qS19v3zAGJBN5Wy/+I5/be4Ssk10EWMgzwJTD/W+G70fy5QFkabsiIDB0KTunpQ+PvgH9n4Fz219K4qfXYjntr4VP+1cPW/S8qS2Ydv0gKvev10b1+X2Y7Dtq8aAbJqMXfXTL4d3Z5O1oNhkddAZyLPA1IsuvOj9DzPlRYz2HB7F1pcvx0ltq3rcSzCsPZ61icTLr04j31JdWWU288bHB//A3q/grIOfwVKMIyfAUoyj++e78dPuD2Gk2IWiCkaKXdg09VHsLZZSN+v1/u161zfmh9COV6ufWBOQ+1f24JFN51fvOxpWLZUsBsU4CoKlCCc7s8CUYwy4m0SrlNBqPjfZInOTkefixdwkNrYOoVtewJguxrbpAdfBcP7x5mqk5HOCRR15TJycqm7HDu+TlMsObUe7TFY91i6TeM0zD+Lyjv9uu4hIUSoJUHn+tT8ba+s46+vuV16wP8F6Adllbnrd302QCdykNFkddAbyLFi7Bdj9p/bf8/OHGfNqPrtskRtuP4LhZ17EX/efPfu8yom+vcU12Ds5fwES4H4Rkt3E4VRR0dHWisNbLqx+ssO4/Fs23VsV4KzA9z0dty2d+AY97lh7vDJbBsC8n82dB0er89R3+Fws5JCBZKn83azL7cfGk0Po3vMCTt6/FB0fLAfqLAbFJltgxaGVLFgxALS/3v57GfjDtAuoCuDWR39RNd7tpqftZRGSp8lNh3H5ykU2Q1/7AlbteS++V/gdFA0fn+elq2rc2o41ROQmS+XAW65FoWaoqaBtOPCWa22PPctFBpL1/uty+zGY34Xe3HHkRNFReHZu+CQL8yq1Uj6EGDYG8qz44OfT/4dpmBAzBVQFqgKWqafdImK7orLeJsp1Jzcr2XzwrXF5ywUz38UlzwyiR44jJ0CrFFFbFLGgbTj2rg0A5satTfXORycKxqqLYxOF2fO74p97cePUR6vG3Ydm3otlh7bXn3ysk4Fk/W42tg6ho2aYaHb4JItBMQ1ptDEKZWhFRD4A4EsAWgDsUtXBMI7bkPyuWEx7pbqjQ5i++1q0zrxS+vrEsdLXgGNN7cogbzccYSqV62Zxj+l4tj36mp/vSLF6XB6wD3YiwLTmkIPieenCsXdvwKp1f1b1HKea5wLYbsjc2ZGvanvlUJPVe+5AuS0BFkxZbeuW4/ZPODGS/r89kyYqCBa4HrmItAD4FwAXABgBcADA76nqj0yvadp65A1c//nk599euh2v8VL+13D+zN/O20bNUlsz2+0SelMNcb/Hc3P8pxdchZxN97qogve07zbW/rar5V6pNpi351uwoDWHiYL9z2x/23XozdkEXh8701tte0D+MrRjUnSirEd+LoCfqOrT5Te6DcCHABgDedNyO/sfQZ0RvwHN7etOKTxn+/qFk8/jpVftA5Jd79htTRO349+m49U7L7ve/Jh2odem5/osFjuO21vHvf72I7bfV5RK5p4ozGXS3GB4LgDn3rNHVtt23Xs1Nk79ffUdR9qHT2hWGGPkPQAqp4dHyo9VEZH1IjIsIsPj4+Pe3yXuBQlRvJ+b2f8Icnb9Vsfz8rqx4mLbY4yp/eN1KwjW4Wn8u4ab86pdZCMCbJsesM1vH3v3xrrn0b+yxzjxCQAvvzqNzo787B6cCw37gALA87LE/huS8/X32r+yB1s/8zl0XP53TTOm3GjCCOR2cznzxmtUdaeq9qlq35Ilhj9Ek7gXJET1fm5m/yNYyOC3xoiX1+1qu9q4iKeWAHOLVnwyLUt3k9Hi9rwqF9ksPCWPvcU1+MbMezGtOaiWxsb3ynnzxsS9tNkyVVS8dHJq9sLy8uQ08rn5i5e+eOU5WHrZf5k/+QgAOoNAf69Jl2Yg38II5CMAllV83QtgLITjzol7lVZU7+dm9j+CnF2/NUa8vO6ci9dji66vyqzYXLGisVIYm1FYPeZFHXmsy+3H/rbr8ETLh3Hh/WvrBjDTeY1OFIxZMCcKU1iX248rWh5GqxQh5ayVdfod1wHTarMbUzOKU09pta+BXpORURSbj/FUASN3bLbN5qHGE8YY+QEAbxOR0wGMAvgwgKtCOO6cuBckRPV+bmb/I1jIYMqaqBdQvbyu1Lv+C1y5b+3suPN5b1+C9oOjke6ss3b6u7gpv2t2bLej8OxstoypR2k6LwFmH6/NgunubMfGk/OzVjpk0tMKx/6VPcat42q9dHJq/sIlSzkjY8/hUazbc6btfXG3vDB7Hj3HvlmqvZKlrBNyLXAgV9VpEfkYgH0opR9+TVWfCNyySnGv0ory/eqlRLlYjeeVpzS8AK+zm1jse9PrQ9+MwpqoHJ0oYH/bbfOCa+vMK47B1e687NIAKzdn2HDRGeje43OpvIv3t9Mipgz0Odv3PYU+XWw7CVuE4OkFV+ElPRWvPfQKgOlye8Op707pEUoeuap+C8C3wjiWrQiCW6rer1IEObt+N+cNtKlvxTHC3IyiNpXPbwbHKfnc7DE62/PGVD9rGKZ/ZU9p2bpNiqXXC7z18/jE0GOYcUj/dfpeZfu25QZKeeUVFzTV0tAPACyWX81/YdprpZAn2ai1EveChKQXQESwkMFvQA07EAdVO1FpSgk0BdcDe7+CVQe34SCOY6ytC9umB/DA9PuMwbyzYy57pOODN4VygbfuKGZUjQuCADhmuVi6O9uxd2INMIXZImNFyGwQd5TmWinkSTYCORD/Kq0mWhWWJbUTldum5/dGp1tOQatdcD06hLMO/We0S6kkbK8cx2B+FzAFfC9/HvItgqmZ6rD6q1emsefw6NwkI1B1gT/wlmtx/be6MPa/7rW9Y6nNVz/v7UtwZ8W8gSmIu51LsIZp9k7Nrfx8eoHLKar2Re6e51dE+67SfIFXdvrRtCs7m00EH2S7FZfrcvtne6PPyWJ0X3az7fuYVp+OFLvwnslbsNDUK2/P48hn50862q3YzLcIXtPWihOFKSxsz+Plyel5Fwc7izry6GhrrRrCAtwNa9VeLL45cw0WTf1b3fdE++uBG39W/3l+uFnFzEDvmWllJwM5RSOicgRulrv/bPDi2edaAW5hex6Hilc4LrEfKy8QsvPFK8+ZF0RNZQL8qGy31Xa3dWdqHdj7ldKdR+1mFHbvunXCf6Od7DjLkDBQXvLfwOUqomQK5Kx+SP45rX6NKBffysU2ZXRYqZG1qzcnClMY0y7b11hL7J3SMe0WQYW512fte/tdxLXn8Cj+4MCbcOPkn8zm9E+r4WMeZRnaeim8TbaDT9QYyMmfeqtfI8z971/Zgy8MvNNxZaddIKy3xN5pTNouaIexsAmwHw/3u4jLOu+9xTVYM3kL3vzqrfhPU9eggAXVT4w6C6veKuYsblaRYgzk5E+9HlXEmxGYNhy2hh3sAt7e4hpsqqnrvS3/F7NL7PtX9mBRh32NE7ug7bTk3i1TzRm/tWSM5z35J/HWUam3ijmLm1WkWHayVihd6vWoYsjFd0qNNK3erKzr3Z5vwc0XVy+Zv3jFG3Hro7+YV1bWrrdem2ff2ZHHr16ZxlRx7tX5nKCtNYeXJ6vvDuqNd/tdxGU67+HXXQDccLPja4OYX01yNfovvcU8mZnkWo0GxEBO/tRb/WrIxd8zsxrbBx8Kr5yuIfPBLhDmc4JTT2nFxMkpfOTUH2Bj/nZ03P0cTt6/FNumrsT//NW58/K6BcDl7567YNi1w039c69lhP0uxvJ7AQjCuMnHZavRb6plnvRajQbDrBXyx0fWgd9MDNPr/mnVM1j1w88a2+AY/GvaflLbsMlQ5MvarCJIJkkkDBexyhIGLSKYUUVPSOUR7Ljd5IOCi3JjCWpGdj2qt11Y+nr3etsellMmhlOAMb1u2aHtAMwbdRiHXmzG9ztkEhtbh2aHXSpZQcrUjq17n4g/kNdejCrqp/SvLP3M622FFxa/E7MUHgZy8q9y9atDYLGeE3Y53TfouH01/HqZD4bvd4t9USwr1dHUjonC1NzqT0vQxS42r98zs3r2DuP/nfIpLHW4iPm9aPrht7omhYdZKxQOF3nBfjMxTN835YXXzXwwfN+0m5FVvKpenrm16/3HP7UZhd0f878xiU1q5/Td12L/XX8/mxf/BjXsslW+SMXZSw6yyQeFg4GcwuEiL9jvB956nbWBxNMLrsL+tuvwYPGceXnhrjIfbFLjTLsZAXPFq5zaaQ1djE4UsKF1aP6qSi+LXWwuiq0zr+B63Db7db2LWJCt8LyqlwpK0ePQCvlSO5H4QHv9Eq9Byun2HPsmzjr01dkA2SvHcYU8jG/MvBdrc0fQLS9gTBej91L7OitVqsb3j6EoObSjNEaOaVRNeFZeaPpX9uBz9zyBl07Or8fSIuKttK7T0Ivhotgjx/H0gqswpl14sHgOrpCHjZsl+8peCTAclLYqmc2GgZw8s0s329J2OQbzu0qbOlhsesd1P/CGYLLqp18Ganq5HTKJtbkjWDN5y+xjP19xMVyxAtQ91yFX7v325uaqIe4trsGijjw+e+mZVe397KVn2gZIT6V1680nGFI7RUpTApUXsYtaH8NSHJ8XeD1fNF3McYSORbNCw6EV8sxuIu2Oyd/CX8s1wVYPOi37dzFB2emw87wth+wVAOhoa50X+EzDCJW1w+1KAVRd1OrNJ9itiqzRIZN4f8sRPPqh7xo3S67cPHrDRWdg+76nbPcjddWmsMW9oXqDY4+cPDNNmP3jr87F1s98zv+BnYKJoZdqTVDmc4Kt68709n51Lg6m8zTdVVg99b3F0kYPN+ZLpXXF5dDJ7OO1qZ2Gmozd8oLrxVR1UxHjrn3i9Ltmr9wz9sjJs8gm0pyCydot8wo/WROULSLYfsU7vY/R1slecTofK0PF6uECqOqpH3zdBTjQ/zDErrfsps7IioHS67ZOlO9y5hOXdUlcVVKMu/YJi2aFioGcPIss3cwpmKwYwOPv+iuM6lzBq01TH8UDLe/DFwZ8BHHAMXvF6XxqS+RW9nCtoYxHNp1vblO9glJBn1/DVSpiwPfwjEWzQsVATp5Flm5WJ5isWvdnOND/MN7TvhvvmbwFB193QbD3XTFQGsdfuAwKwXNYgs1TH617XL+1wu3e19V8gtfn13B1BxXwPTyL+8LR4FhrhdIlA5kMp2+613bUunaXn7RIXY0YSwZ+12nDWiuUWtU56V3YcNG+VOckp21Jer3Kin7z9yPXTBucR3zRYiCnRLnKqIhCgA9WEqViTdz+/LhgJ0Ex5OhzjJwS5We8uTZjZF5OdD0Bc5id5ggCt82jwOP1FL0YcvTZIyd3Iro19FrcyVcPvrbtky8HzmHub3kE/QtuAk4ZARb0Ai1bsOfw6tjvLlhCNgNiSLVkjzyrnHawj+K9IlqF5zUn3XMP1K7thRftn+v2g2X4eRy5d2fg3rHXHn2cxbHIpxhSLRnIsyju5c0R3hp6zUn33AO1a7uJ2w+W4efx0cmve2tbDVN+ulMwZwnZDIgh1TJQIBeR7SLyYxE5KiJ3iUhnSO0iJ3HXxYjw1tBrTrrnHqjbNnr5YJmW9ufsN6Zw2zv2M97t5ecX9/i9L3HeacYlhhz9oGPkDwDYrKrTIvJ5AJsB3Bi8WeQo7uXN9TZaDshLRoXnjBFT26sI8M6r3H+wTMcUwe+2/TPumPwtd22r4Xe8283PL7HsIC+SqMAYl4hTLQP1yFX1flWdLn/5KACur41D3MubU7QKz/OqUheVBAEF/vV+940wHDOnRQzmd+EPT/2BrxWvUY53ZyK7Je47zQYSZtbKHwO43fRNEVkPYD0AnHbaaSG+bRNau8V+B/uoAqvdRsuVWSsxr9Az9UDtF8a4qyTo6W7GOre7rgG0Oji2zryCrQvv9FUFMsr89Exkt7CQlm91A7mIfBvAUptvfVpV7y4/59MApgHcajqOqu4EsBMoLdH31VoqqRdYo3pPu+On5HbYeeigou07zgpnmGjFALB7vf33fAaeKFdghroaNaoLd8RDeI2sbiBX1fc7fV9EPgLgEgBrNYnCLc0qLcubTbfD990Ya/tc7xof5t2M18DjIgBGtQIztN5+lBfuuO80G0jQrJUPoDS5uU5VT4bTJMoUU++z8GKsGQeuhw7CzCDwMneQ8I44oVWsjHIcO+4KjA0kUPVDEfkJgAUArLyrR1X1mnqvY/XDBmIaqgBKH8QbHo+lGasHH7IdOujpbMcjm86P7o3dDjMYh3Ti+xmFYmsn7OcZpLQJBkUqkuqHqvrWIK+nBrB2C7D7T+2/F+MkVWKFrNwOcTXKRB7HsVOJKzvD0ogLGZxY57t7PUqVuG3E+OF2HDpIw++mUXbESVEqKs1h0awwpCRzIza152sngQ+37URhWn43jTKRl0TGFNXFHYLC0Cjjn26ZzldaAC2m68Odpt8Nd8ShgLhDUJQaZfzTLdN5aTF9E15p+t2kJWU0q3ghNOIYeRgaZfzTrSydb5baSmYJp2+mHQN5GJptAihL55ultpIZ67A4YiAPQ7MtZMjS+WaprWSWpiGyFOJkJ1EYOH4brTRNWifINNnJHjlRUBy/jR6HyBwxkBMFxfHb6HGIzBHTD4mC4vhtPJi+acQeOVFQTHGkhDGQEwXF8VtKGAM5UVAcv6WEcYycKAwcv6UEsUdORJRxDORERBnHQN7o0rCpAjUn/u3FhmPkjSwtmypQ8+HfXqzYI29kXHFISeHfXqwYyBtZHCsOeftMdrjaNVYM5I0s6hWHLBblX6NfALnaNVYM5I0s6hWHvH32pxkugFztGisG8kYW9YpD3j770wwXQK52jRWzVhpdlCsOF/Yaiv3z9tlR0hfAuDbB4GrX2LBHTv7x9tmfJMePm2FYpwkxkJN/vH32J8kLYDMM6zQhDq1QMLx99s76eSWxx2fSwzoUiVACuYh8EsB2AEtU9XgYxyRqaEldADmv0ZACD62IyDIAFwD4RfDmEFGksj6v0ej59z6FMUa+A8BGABrCsYgoSlme1+BErVGgoRURWQdgVFUfE5F6z10PYD0AnHbaaUHeloiCyOq8htNEbRbPJ0R1A7mIfBvAUptvfRrApwBc6OaNVHUngJ0A0NfXx947EXnDiVqjuoFcVd9v97iInA3gdABWb7wXwCEROVdVnwu1lUREnKg18j1Grqo/VNU3qOpyVV0OYATAuxjEyREnq8ivrE/URoh55BQfbjZAQSSZf59yohr/cHVfX58ODw/H/r6UsB1nGW6NlwE3PB5/e4gyRkQOqmpf7eNcok/x4WQVUSQYyCk+3GyAKBIM5BQfTlYRRYKBnOKT5VWFRCnGrBWKV1ZXFRKlGHvkREQZx0BORJRxDORERBnHQE5ElHEM5EREGZfIEn0RGQfwTPnLLgCNvj1cM5wj0Bzn2QznCPA80+pNqrqk9sFEAnlVA0SG7WoHNJJmOEegOc6zGc4R4HlmDYdWiIgyjoGciCjj0hDIdybdgBg0wzkCzXGezXCOAM8zUxIfIyciomDS0CMnIqIAGMiJiDIuFYFcRK4VkadE5AkR2ZZ0e6IkIp8UERWRrqTbEgUR2S4iPxaRoyJyl4h0Jt2msIjIB8p/pz8RkU1JtycKIrJMRL4jIk+WP48fT7pNURGRFhE5LCLfTLotQSUeyEXkPAAfArBCVc8E8F8TblJkRGQZgAsA/CLptkToAQBnqeoKAP8CYHPC7QmFiLQA+DsAHwTwDgC/JyLvSLZVkZgG8AlV/Q0AvwngLxv0PAHg4wCeTLoRYUg8kAP4cwCDqvoqAKjq8wm3J0o7AGwE0LAzzKp6v6pOl798FECj7ON2LoCfqOrTqjoJ4DaUOiANRVWfVdVD5f//O0qBrifZVoVPRHoBXAxgV9JtCUMaAvmvA3iPiHxfRL4rIquSblAURGQdgFFVfSzptsTojwHcl3QjQtID4FjF1yNowABXSUSWA1gJ4PsJNyUKX0SpU1VMuB2hiGWHIBH5NoClNt/6dLkNi1C6jVsFYEhE3qwZzIusc56fAnBhvC2KhtN5qurd5ed8GqXb9FvjbFuExOaxzP2NuiUipwK4E8D1qvrLpNsTJhG5BMDzqnpQRH474eaEIpZArqrvN31PRP4cwO5y4P6BiBRRKmQzHkfbwmQ6TxE5G8DpAB4TEaA03HBIRM5V1edibGIonH6fACAiHwFwCYC1WbwgG4wAWFbxdS+AsYTaEikRyaMUxG9V1d1JtycCqwGsE5H/COAUAK8Tka+r6tUJt8u3xBcEicg1ALpVdYuI/DqABwGc1kABYB4R+TmAPlXNUtU1V0TkAwD+BsD7VDVzF2MTEWlFafJ2LYBRAAcAXKWqTyTasJBJqafxjwBeVNXrE25O5Mo98k+q6iUJNyWQNIyRfw3Am0XkcZQmkD7SyEG8CfwtgNcCeEBEjojIPyTdoDCUJ3A/BmAfShOAQ40WxMtWA/h9AOeXf39Hyj1XSrHEe+RERBRMGnrkREQUAAM5EVHGMZATEWUcAzkRUcYxkBMRZRwDORFRxjGQExFl3P8HIUaLd9GvtygAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x, y)\n",
    "plt.scatter(x * 2 , y * 2) # what's happening here? (hint: array-like input to scatter...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Manipulating the appearance of a plot\n",
    "\n",
    "Matplotlib allows you to manipulate almost every property of a plot: figure size and resolution, line appearance, axis and grid properties, textual elements ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(1, 150)\n",
    "y = np.log(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You to change the appearance of the **line**\n",
    "\n",
    "(NOTE: See the [matplotlib documentation](https://matplotlib.org/users/colors.html) for a quick introduction on how a color can be specified by the user)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cf252b0>]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cf25700>]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cf25a30>]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11cf25e20>]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y * 2.5, color = \"r\")  # you can change the line color \n",
    "plt.plot(x, y * 2, linewidth = 0.75)  # you can change the line width\n",
    "plt.plot(x, y * 1.5, linestyle = '--')  # you can change the line style\n",
    "plt.plot(x, y, marker = '*')  # you can change the marker style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can manually choose the **axis limits**, the **axis titles**, the **axis ticks** and **their text** (and plot a grid, if you like):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d046910>]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(0.0, 7.0)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(-5.0, 155.0)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'log (x)')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.XTick at 0x11cbda520>,\n",
       "  <matplotlib.axis.XTick at 0x11cbda4f0>,\n",
       "  <matplotlib.axis.XTick at 0x11cbd5070>,\n",
       "  <matplotlib.axis.XTick at 0x11d055190>],\n",
       " [Text(0, 0, 'zero'),\n",
       "  Text(50, 0, 'fifty'),\n",
       "  Text(100, 0, 'one hundred'),\n",
       "  Text(150, 0, 'one hundred and fifty')])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y)\n",
    "\n",
    "# set the axis limits\n",
    "plt.ylim(0, 7)  \n",
    "plt.xlim(-5, 155)  # set the x-axes limits\n",
    "\n",
    "# let's set the y-axis text\n",
    "plt.ylabel(\"log (x)\")\n",
    "\n",
    "# let's set the x-axis ticks and their text (in an awful way...)\n",
    "plt.xticks(range(0, 151, 50), [\"zero\", \"fifty\", \"one hundred\", \"one hundred and fifty\"], size='small')\n",
    "\n",
    "# fancy a grid?\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can give the plot a **main title** and add a **legend**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d132280>]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d1326d0>]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d132a30>]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Logarithms Comparison')"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11d132d00>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, np.log10(x))\n",
    "plt.plot(x, np.log(x))\n",
    "plt.plot(x, np.log2(x))\n",
    "\n",
    "# create the main title\n",
    "plt.title('Logarithms Comparison')\n",
    "\n",
    "# add a legend\n",
    "plt.legend(['base 10', 'natural', 'base 2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also **annotate** some points that may be of any interest (see [this tutorial](https://matplotlib.org/users/annotations_intro.html))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d246340>]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(35, 2, \"that's log(20) !\")"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x, y)\n",
    "plt.annotate(\"that's log(20) !\", xy = (20, np.log(20)), xytext = (35, 2), \n",
    "             arrowprops=dict(facecolor='r', edgecolor='None', shrink=0.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Bar plots\n",
    "\n",
    "Unfortunately, humans are quite bad at comparing angles, so a better way to compare the frequencies of categorical data is to use bar plots. In these graphs:\n",
    "\n",
    "- every bar is associated with a given value\n",
    "\n",
    "\n",
    "- the height of each bar is proportional to the frequency of a given value\n",
    "\n",
    "\n",
    "- all the bars have the same width\n",
    "\n",
    "These plots can be drawn by using the [`bar()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.bar) or the [`barh()](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.barh) functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "n = 12\n",
    "x = np.arange(n)\n",
    "y = np.random.uniform(0.5, 1.0, n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 12 artists>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.XTick at 0x11cf91340>,\n",
       "  <matplotlib.axis.XTick at 0x11cf91310>,\n",
       "  <matplotlib.axis.XTick at 0x11cd94f40>,\n",
       "  <matplotlib.axis.XTick at 0x11cbd57c0>,\n",
       "  <matplotlib.axis.XTick at 0x11cbd5f10>,\n",
       "  <matplotlib.axis.XTick at 0x11cbda0d0>,\n",
       "  <matplotlib.axis.XTick at 0x11d05c100>,\n",
       "  <matplotlib.axis.XTick at 0x11cbd5fa0>,\n",
       "  <matplotlib.axis.XTick at 0x11d0696a0>,\n",
       "  <matplotlib.axis.XTick at 0x11d069580>,\n",
       "  <matplotlib.axis.XTick at 0x11d055250>,\n",
       "  <matplotlib.axis.XTick at 0x11d107e20>],\n",
       " [Text(0, 0, 'A'),\n",
       "  Text(1, 0, 'B'),\n",
       "  Text(2, 0, 'C'),\n",
       "  Text(3, 0, 'D'),\n",
       "  Text(4, 0, 'E'),\n",
       "  Text(5, 0, 'F'),\n",
       "  Text(6, 0, 'G'),\n",
       "  Text(7, 0, 'H'),\n",
       "  Text(8, 0, 'I'),\n",
       "  Text(9, 0, 'J'),\n",
       "  Text(10, 0, 'K'),\n",
       "  Text(11, 0, 'L')])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# vertical barplot\n",
    "plt.bar(x, y)\n",
    "plt.xticks(x, list(string.ascii_uppercase[:12]), size='small') # let's use some random letters for each value of a variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 12 artists>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "([<matplotlib.axis.YTick at 0x11d21f8e0>,\n",
       "  <matplotlib.axis.YTick at 0x11cf65160>,\n",
       "  <matplotlib.axis.YTick at 0x11cbda190>,\n",
       "  <matplotlib.axis.YTick at 0x11d3cb880>,\n",
       "  <matplotlib.axis.YTick at 0x11d3cbd90>,\n",
       "  <matplotlib.axis.YTick at 0x11d3d82e0>,\n",
       "  <matplotlib.axis.YTick at 0x11d3d87f0>,\n",
       "  <matplotlib.axis.YTick at 0x11d3d8d00>,\n",
       "  <matplotlib.axis.YTick at 0x11d3d8520>,\n",
       "  <matplotlib.axis.YTick at 0x11d3cb460>,\n",
       "  <matplotlib.axis.YTick at 0x11d3de400>,\n",
       "  <matplotlib.axis.YTick at 0x11d3de910>],\n",
       " [Text(0, 0, 'A'),\n",
       "  Text(0, 1, 'B'),\n",
       "  Text(0, 2, 'C'),\n",
       "  Text(0, 3, 'D'),\n",
       "  Text(0, 4, 'E'),\n",
       "  Text(0, 5, 'F'),\n",
       "  Text(0, 6, 'G'),\n",
       "  Text(0, 7, 'H'),\n",
       "  Text(0, 8, 'I'),\n",
       "  Text(0, 9, 'J'),\n",
       "  Text(0, 10, 'K'),\n",
       "  Text(0, 11, 'L')])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAD4CAYAAADFAawfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAL+0lEQVR4nO3dXaxlZ1kH8P9jsQSiFtqO2A/qIImK8pHAaAhap7ZRS3tBCHOhGI3EpCEGAzcCEmNI5ALiTWNMJUiUGIKYYP3gw6qlzhQsFU+T0oKmpGJBaAlQTFWaCB0eL86WnrN7dNY+3evst2d+v2Qn+2N1zXPenPnP23ft9T7V3QFgXN+26QIA+P8JaoDBCWqAwQlqgMEJaoDBPWmOk1544YV99OjROU4NcGjdcccdX+nuI8vvzxLUR48ezdbW1hynBji0quqze71v6QNgcIIaYHCCGmBwghpgcIIaYHCCGmBwghpgcIIaYHCz3PBy9xceytE3fnCOUwOHwH1vvXbTJTyhmFEDDE5QAwxOUAMMbnJQV9XRqnrfnMUA8Fhm1ACDE9QAg1tbUFfVdVW1VVVbpx9+aF2nBTjrrS2ou/sd3X2su4+d89Tz1nVagLOepQ+Awa0a1JdX1c2Lx6/NUhEAu0y+hby770vyjPlKAWAvlj4ABieoAQY3y+55z7vkvGzZHQtgLcyoAQYnqAEGp3EAwJrM1RDBjBpgcIIaYHCCGmBwk4J6Z9OAqvqBxS55l85bGgDJijPqRTi/O8kru/vz85QEwE6rBPX5Sd6X5NXd/emZ6gFgySpB/cIkX+ruO/b6UOMAgHmsEtQ3J/lsVb15rw81DgCYx6rf+nhdkhdV1S/MUAsAe1jpzsTuPl1VP5fk5qr6XHefmqkuABYmBfWiacCJxfP/SvLiGWsCYAc3vAAMzn7UAIMzowYYnKAGGJygBhicxgGwh7k2gIf9MKMGGJygBhicoAYY3MpBvbOJAADzM6MGGNzagtp+1ADzWFtQ248aYB6WPgAGJ6gBBrefoK4kp9ddCAB7209QX5bkgXUXAsDeVgrqqro6yW8n+f15ygFgWXX32k967Nix3traWvt5AQ6zqrqju48tv+9iIsDgBDXA4OxHDWyEPb+nM6MGGJygBhicoAYYnKAGGJzGAQCDM6MGGJzGAQCD0zgAYHCWPgAGJ6gBBieoAQa38l4f3X1fkhPrLwWAvZhRAwxult3znnfJedmyMxbAWphRAwxOUAMMTuMA4AnhbG40YEYNMDhBDTA4QQ0wuDMG9fL+01V1dVW9edaqAPgWM2qAwQlqgMFN/Xre8ao6uXh+fpIblw+oquuSXJck53zXkbUUB8D0GfWp7r6iu69I8vq9DtA4AGAelj4ABieoAQZ3xjXq5f2nu/umJDfNWBMAO5hRAwxOUAMMTuMAgMGZUQMMTlADDE7jAODAnM2b/z8eZtQAgxPUAIMT1ACDmxTUVfVjVfV3VXWyqk5V1SvmLgyAbWe8mFhVFyS5IcnV3f1AVX17kmOzVwZAkmnf+rg2yZ919wNJ0t3fSPKxWasC4FumLH1clOSBJKmqKxfLH3+5fFBVXVdVW1W1dfrhh9ZdJ8BZa0pQ35/kkiTp7lsWzQMuXj5I4wCAeUwJ6g8leXlVXZwkVXXOvCUBsNOU/agfrKpXJ3lPVXWSR5JcP3dhAGybdAt5d/99kivmLQWAvbjhBWBw9qMGGJwZNcDgBDXA4AQ1wOA0DoAZ2CCfdTKjBhicoAYYnKAGGNzkoK6qo1X15cXueSer6vichQGwbdWLiae6+8QslQCwp7UtfdiPGmAeqwb18R1LH7s2nbYfNcA8LH0ADM63PgAGJ6gBBjd56aO770ti2QPggJlRAwxO4wCAwZlRAwxOUAMMTlADDE7jANgAjQVYhRk1wOAENcDgBDXA4CatUVfV0ST/mORTi7c+2t2/MVdRADxqlYuJds4D2ACNAwAGt0pQ72wa8JrlDzUOAJiHpQ+AwfnWB8DgVplRH6+qk4vnd3b369ZfDgDLJgX1omnAkXlLAWAvlj4ABqdxAMDgzKgBBieoAQZnP2pgF3tlj8eMGmBwghpgcIIaYHBnXKPesRf13Ukqya1J3tLd35i3NACS6TPqU919ZZIrF//N62arCIBdVlr66O5O8pYkL5unHACWrbxG3d3/neTJy+9rHAAwj5WDuqrOTfL15fc1DgCYx36+9fGmJH+x7kIA2NvUOxOPV9Ut2Q72jya5fraKANjljEFtL2qAzXLDC8DgBDXA4DQOABicGTXA4AQ1wOA0DgAeF40G5mdGDTA4QQ0wOEENMLhJQV1Vl1fVyaq6tao+XFXPnbswALZN6fByQZIbkvxUd39x8fri2SsDIMm0b31cm+TG7v5iknT3g0kenLUqAL5lytLHRUnuP9NBGgcAzGNKUN+f5JIzHaRxAMA8pgT1B5O8vKq+J0mq6nwXEwEOzpT9qL9aVb+S5E+qKtluw/XauQsDYNukW8i7+yNJjs9cCwB7cMMLwODsRw0wODNqgMEJaoDBCWqAwWkcABtk032mMKMGGJygBhicoAYY3NTGAUer6suL5gFbVfWzcxcGwLZVZtSnuvuKJD+R5PXzlAPAsv0sfTw1ycPLb9qPGmAeqwT18ao6meSuJH+4/KH9qAHmsZ+lj6NJfqmqnjJLRQDssvLSR3d/PUklOXf95QCwbJU7E/936ePJST7Q3RaiAQ7A1MYB9yU5Mm8pAOzFDS8Ag9M4AGBwZtQAgxPUAIMT1ACD0zgAdrCRPyMyowYYnKAGGJygBhjc5KCuqtuq6tfnLAaAx5ra4eWZST6b5Kp5ywFg2dQZ9Ykk707ymap69l4HaBwAMI+pQX1Vkr9J8sfZDu3H0DgAYB5n/B51VV2a5PlJ3p/tYH9KkrfNXBcAC1Nm1CeSvLa7r+7un05yT1U9a+a6AFiYEtSvSHJqx+tb8n8sfwCwfmdc+ujuy5dev2e+cgBY5oYXgMFpHAAwODNqgMEJaoDBCWqAwQlqgMEJaoDBCWqAwQlqgMEJaoDBCWqAwVV3r/+kVf+Z5J61n/iJ68IkX9l0EQMxHrsZj93O5vH43u4+svzmLLeQJ7mnu4/NdO4nnKraMh6PMh67GY/djMdjWfoAGJygBhjcXEH9jpnO+0RlPHYzHrsZj92Mx5JZLiYCsD6WPgAGJ6gBBrfvoK6qq6vqnqq6t6reuMfnVVW/s/j8rqp64eMrdWwTxuPnF+NwV1XdVlUv2ESdB+lMY7LjuB+pqtNVdaibJk8Zj6q6oqrurKpPVdWpvY45LCb8nTmvqt5fVZ9YjMerNlHnELp75UeSc5L8S5LvS3Jukk8k+aGlY65J8ldJKsmLk/zDfv6sJ8Jj4ni8JMnTF89fepjHY+qY7DjuliQfSnJi03Vv+HfkaUn+Kclli9ffvem6Nzweb0rytsXzI0m+muTcTde+icd+Z9Q/muTe7v5Md389yXuTvGzpmJcl+aPednuSp1XVRfv880Z3xvHo7tu6+98XL29PcukB13jQpvyOJMmvJvnTJF86yOI2YMp4vDLJjd39uSTp7sM8JlPGo5N8Z1VVku/IdlA/crBljmG/QX1Jkn/b8frzi/dWPeawWPVn/eVs/9/GYXbGMamqS5K8PMnbD7CuTZnyO/L9SZ5eVSer6o6q+sUDq+7gTRmP303ynCT3J7k7yWu7+5sHU95Y9nsLee3x3vL3/KYcc1hM/lmr6iezHdQ/PmtFmzdlTK5P8obuPr09aTrUpozHk5K8KMlVSZ6S5GNVdXt3f3ru4jZgynj8TJI7k1yZ5NlJ/raqPtLd/zFzbcPZb1B/Pskzd7y+NNv/6q16zGEx6WetqucneWeSl3b3gwdU26ZMGZNjSd67COkLk1xTVY90958fSIUHa+rfma9099eSfK2qbk3ygiSHMainjMerkry1txep762qf03yg0k+fjAlDmSfFwKelOQzSZ6VRy8E/PDSMddm98XEj296QX6ux8TxuCzJvUlesul6RxmTpePflcN9MXHK78hzknx4cexTk3wyyXM3XfsGx+P3krx58fwZSb6Q5MJN176Jx75m1N39SFW9JslfZ/vq7R9096eq6tWLz9+e7av41yzC6eFs/+t4KE0cj99MckGSGxYzyEf6EO8QNnFMzhpTxqO7/7mqbkpyV5JvJnlnd39yc1XPZ+Lvx28leVdV3Z3tCd8buvus3P7ULeQAg3NnIsDgBDXA4AQ1wOAENcDgBDXA4AQ1wOAENcDg/geX7+I8vIy61wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# horizontal barplot\n",
    "plt.barh(x, y)\n",
    "plt.yticks(x, list(string.ascii_uppercase[:12]), size='small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "##### Histograms\n",
    "\n",
    "Roughly speaking, histogram are for continuous (a.k.a. numerical) variables what barplots are for categorical variables. Also in this kind of plot, indeed, values are represented by means of bars. However:\n",
    "\n",
    "\n",
    "- each bar is associated with a bin (i.e. an interval of values)\n",
    "\n",
    "\n",
    "- the area inside the bars (rather than their height) is proportional to the frequency of a value or of a set of values\n",
    "\n",
    "\n",
    "- the width of each bar is proportional to the bin size.\n",
    "\n",
    "\n",
    "\n",
    "The [`hist()`](https://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.hist) function implements most of the functionalities you'll need to plot histograms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.random.normal(-1, 1, 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = plt.hist(data, density = True, edgecolor='black')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the `bins` argument allows us to specify in how many bins we want to organize our values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.00130731, 0.00065365, 0.00130731, 0.00261461, 0.00326826,\n",
       "        0.00457557, 0.01176575, 0.01960959, 0.02287785, 0.03987283,\n",
       "        0.03856552, 0.06797991, 0.08497489, 0.09935525, 0.13138425,\n",
       "        0.17844726, 0.20459338, 0.23270045, 0.29675845, 0.33859223,\n",
       "        0.35362625, 0.37062123, 0.37127488, 0.3850016 , 0.4072258 ,\n",
       "        0.37062123, 0.39676735, 0.33728493, 0.32028995, 0.27257329,\n",
       "        0.23727603, 0.21897374, 0.1764863 , 0.14315   , 0.1000089 ,\n",
       "        0.0888968 , 0.06471164, 0.03660457, 0.03464361, 0.02483881,\n",
       "        0.0111121 , 0.01307306, 0.00653653, 0.00588288, 0.00261461,\n",
       "        0.00326826, 0.        , 0.        , 0.00065365, 0.00130731]),\n",
       " array([-4.66458162, -4.51159524, -4.35860887, -4.20562249, -4.05263611,\n",
       "        -3.89964973, -3.74666335, -3.59367697, -3.44069059, -3.28770421,\n",
       "        -3.13471783, -2.98173145, -2.82874507, -2.6757587 , -2.52277232,\n",
       "        -2.36978594, -2.21679956, -2.06381318, -1.9108268 , -1.75784042,\n",
       "        -1.60485404, -1.45186766, -1.29888128, -1.1458949 , -0.99290853,\n",
       "        -0.83992215, -0.68693577, -0.53394939, -0.38096301, -0.22797663,\n",
       "        -0.07499025,  0.07799613,  0.23098251,  0.38396889,  0.53695527,\n",
       "         0.68994164,  0.84292802,  0.9959144 ,  1.14890078,  1.30188716,\n",
       "         1.45487354,  1.60785992,  1.7608463 ,  1.91383268,  2.06681906,\n",
       "         2.21980544,  2.37279181,  2.52577819,  2.67876457,  2.83175095,\n",
       "         2.98473733]),\n",
       " <BarContainer object of 50 artists>)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(data, bins = 50, density = True, edgecolor='black')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.00196096, 0.        , 0.00196096, 0.        , 0.        ,\n",
       "        0.00196096, 0.00196096, 0.00196096, 0.        , 0.        ,\n",
       "        0.00588288, 0.00196096, 0.00196096, 0.00392192, 0.00392192,\n",
       "        0.00784384, 0.        , 0.00588288, 0.01764863, 0.00980479,\n",
       "        0.00784384, 0.01176575, 0.01372671, 0.0333363 , 0.02157055,\n",
       "        0.02353151, 0.02353151, 0.03725822, 0.04118014, 0.04118014,\n",
       "        0.03529726, 0.03529726, 0.04510205, 0.0666726 , 0.07255548,\n",
       "        0.06471164, 0.07255548, 0.09020411, 0.09216507, 0.1098137 ,\n",
       "        0.08628219, 0.10196986, 0.11765753, 0.12942329, 0.14707192,\n",
       "        0.16079863, 0.18040822, 0.19413493, 0.21374452, 0.20590068,\n",
       "        0.19413493, 0.23531507, 0.23139315, 0.23139315, 0.3098315 ,\n",
       "        0.2863    , 0.29414383, 0.33140205, 0.32944109, 0.35493356,\n",
       "        0.33532397, 0.3961137 , 0.32944109, 0.3961137 , 0.34512876,\n",
       "        0.37062123, 0.3961137 , 0.35885548, 0.35885548, 0.37258219,\n",
       "        0.40395753, 0.37846507, 0.43729383, 0.40591849, 0.37846507,\n",
       "        0.39219178, 0.36669931, 0.3529726 , 0.39023082, 0.44513767,\n",
       "        0.35493356, 0.29414383, 0.36081644, 0.35689452, 0.35689452,\n",
       "        0.31375342, 0.29022192, 0.28041712, 0.28237808, 0.25492466,\n",
       "        0.26472945, 0.24511986, 0.20197877, 0.20786164, 0.23923698,\n",
       "        0.2098226 , 0.18629109, 0.17060342, 0.17256438, 0.1333452 ,\n",
       "        0.14511096, 0.15099383, 0.10393082, 0.10196986, 0.09412603,\n",
       "        0.09804794, 0.09020411, 0.07843836, 0.07451644, 0.0666726 ,\n",
       "        0.05294589, 0.02941438, 0.03725822, 0.0431411 , 0.0333363 ,\n",
       "        0.03725822, 0.0333363 , 0.03725822, 0.02549247, 0.01176575,\n",
       "        0.01568767, 0.01176575, 0.00588288, 0.02157055, 0.00980479,\n",
       "        0.00784384, 0.01176575, 0.00392192, 0.00392192, 0.00784384,\n",
       "        0.00196096, 0.00784384, 0.00196096, 0.00392192, 0.00196096,\n",
       "        0.00196096, 0.00588288, 0.00196096, 0.        , 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "        0.00196096, 0.        , 0.        , 0.        , 0.00392192]),\n",
       " array([-4.66458162, -4.61358616, -4.5625907 , -4.51159524, -4.46059979,\n",
       "        -4.40960433, -4.35860887, -4.30761341, -4.25661795, -4.20562249,\n",
       "        -4.15462703, -4.10363157, -4.05263611, -4.00164065, -3.95064519,\n",
       "        -3.89964973, -3.84865427, -3.79765881, -3.74666335, -3.69566789,\n",
       "        -3.64467243, -3.59367697, -3.54268151, -3.49168605, -3.44069059,\n",
       "        -3.38969513, -3.33869967, -3.28770421, -3.23670875, -3.18571329,\n",
       "        -3.13471783, -3.08372237, -3.03272691, -2.98173145, -2.93073599,\n",
       "        -2.87974053, -2.82874507, -2.77774962, -2.72675416, -2.6757587 ,\n",
       "        -2.62476324, -2.57376778, -2.52277232, -2.47177686, -2.4207814 ,\n",
       "        -2.36978594, -2.31879048, -2.26779502, -2.21679956, -2.1658041 ,\n",
       "        -2.11480864, -2.06381318, -2.01281772, -1.96182226, -1.9108268 ,\n",
       "        -1.85983134, -1.80883588, -1.75784042, -1.70684496, -1.6558495 ,\n",
       "        -1.60485404, -1.55385858, -1.50286312, -1.45186766, -1.4008722 ,\n",
       "        -1.34987674, -1.29888128, -1.24788582, -1.19689036, -1.1458949 ,\n",
       "        -1.09489944, -1.04390399, -0.99290853, -0.94191307, -0.89091761,\n",
       "        -0.83992215, -0.78892669, -0.73793123, -0.68693577, -0.63594031,\n",
       "        -0.58494485, -0.53394939, -0.48295393, -0.43195847, -0.38096301,\n",
       "        -0.32996755, -0.27897209, -0.22797663, -0.17698117, -0.12598571,\n",
       "        -0.07499025, -0.02399479,  0.02700067,  0.07799613,  0.12899159,\n",
       "         0.17998705,  0.23098251,  0.28197797,  0.33297343,  0.38396889,\n",
       "         0.43496435,  0.48595981,  0.53695527,  0.58795073,  0.63894618,\n",
       "         0.68994164,  0.7409371 ,  0.79193256,  0.84292802,  0.89392348,\n",
       "         0.94491894,  0.9959144 ,  1.04690986,  1.09790532,  1.14890078,\n",
       "         1.19989624,  1.2508917 ,  1.30188716,  1.35288262,  1.40387808,\n",
       "         1.45487354,  1.505869  ,  1.55686446,  1.60785992,  1.65885538,\n",
       "         1.70985084,  1.7608463 ,  1.81184176,  1.86283722,  1.91383268,\n",
       "         1.96482814,  2.0158236 ,  2.06681906,  2.11781452,  2.16880998,\n",
       "         2.21980544,  2.2708009 ,  2.32179635,  2.37279181,  2.42378727,\n",
       "         2.47478273,  2.52577819,  2.57677365,  2.62776911,  2.67876457,\n",
       "         2.72976003,  2.78075549,  2.83175095,  2.88274641,  2.93374187,\n",
       "         2.98473733]),\n",
       " <BarContainer object of 150 artists>)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# we won't draw the edge of each bar\n",
    "plt.hist(data, bins = 150, density = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We set `density = True` in order to plot the **frequency density** of a bin (i.e. the relative frequency of a bin divided by its width), rather than its relative (or absolute) frequency (as it is in the graph bar). \n",
    "\n",
    "When the bins are equally spaced, the relative (or absolute) frequency and the frequency density are proportional. However, this proportionality is lost when the histograms plots the density of **unequally spaced** bins (i.e. when the value of the argument `bins` is a sequence)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n, bins, patches = plt.hist(data, bins = 999, density = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# equal bins ('density' doesn't matter for overall 'shape')\n",
    "n, bins, patches = plt.hist(data, bins = 9, density = False,  edgecolor='black')\n",
    "patches[4].set_fc(\"r\")\n",
    "patches[5].set_fc(\"r\")\n",
    "patches[6].set_fc(\"r\")\n",
    "patches[7].set_fc(\"r\")\n",
    "patches[8].set_fc(\"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# unequal bins. density = False (relative frequency)\n",
    "n, bins, patches = plt.hist(data, bins = np.array([min(data), -3, -2, -1, max(data)]), density = False,  edgecolor='black')\n",
    "patches[3].set_fc(\"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# unequal bins. density = True (frequency density)\n",
    "n, bins, patches = plt.hist(data, bins = np.array([min(data), -3, -2, -1, max(data)]), density = True, edgecolor='black')\n",
    "patches[3].set_fc(\"r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Drawing several plots per canvas\n",
    "\n",
    "Multiple plots per canvas can be drawn by using the function `subplot()` to setup a grid and activate one plot per time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: MacOSX\n"
     ]
    }
   ],
   "source": [
    "%matplotlib auto\n",
    "\n",
    "x = np.arange(1, 150)\n",
    "y_base10_log = np.log10(x)\n",
    "y_natural_log = np.log(x)\n",
    "y_base2_log = np.log2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11e6c60a0>]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Base 10 Log')"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set up a 2 x 2 grid, set the first plot as active and draw the first curve\n",
    "plt.subplot(2, 2, 1)\n",
    "plt.plot(x, y_base10_log)\n",
    "plt.title('Base 10 Log')\n",
    "\n",
    "# uncomment to compare subplots with the same y-axis limits\n",
    "# plt.ylim(0,8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d16a520>]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Natural Log')"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# activate the second subplot and draw the second curve\n",
    "plt.subplot(2, 2, 2)\n",
    "plt.plot(x, y_natural_log)\n",
    "plt.title('Natural Log')\n",
    "\n",
    "# uncomment to compare subplots with the same y-axis limits\n",
    "# plt.ylim(0,8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11d3ea850>]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Base 2 Log')"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# activate the third subplot and draw the third curve\n",
    "plt.subplot(2, 2, 3)\n",
    "plt.plot(x, y_base2_log)\n",
    "plt.title('Base 2 Log')\n",
    "\n",
    "# uncomment to compare subplots with the same y-axis limits\n",
    "# plt.ylim(0,8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.tight_layout()  # adjust spacing between subplots to minimize the overlaps.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Further Reading:**\n",
    ">\n",
    "> Tutorial introductions to the Python scientific computing libraries (including other libraries that we'll briefly use in this class, such as \"SciPy\", \"Pandas\" and \"scikit-learn\") can be found in:\n",
    ">\n",
    "> - the [SciPy Lecture Notes](http://www.scipy-lectures.org/) ( the [pdf version](http://www.scipy-lectures.org/_downloads/ScipyLectures-simple.pdf)).\n",
    ">\n",
    ">\n",
    "> - The `python-course.eu` section dedicated to [Numerical Python](https://www.python-course.eu/numerical_programming.php).\n",
    ">\n",
    ">\n",
    "> - For a gentle introduction to the main matplotlib modules, have a look at the [beginner's guide](https://matplotlib.org/users/beginner.html) available on `matplotlib.org`.\n",
    ">\n",
    ">\n",
    "> - An excellent plotting package built on top of matplotlib is called [`Seaborn`](https://seaborn.pydata.org)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1.\n",
    "\n",
    "Plot the sine and the cosine waves in the same graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2.\n",
    "\n",
    "Read the file data/adams-hhgttg.txt and:\n",
    "\n",
    "\n",
    "- count the occurrences of each word.\n",
    "\n",
    "\n",
    "- Create a graph plotting word frequencies (on the **y-axis**) by words sorted by frequency (that is, you list the corpus words from the most frequency to the least frequent words **x-axis**). For clarity, please do not report the words in the x-axis label.\n",
    "\n",
    "\n",
    "- In a similar graph, plot the frequencies of the top-frequent 25 words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}