Functions_Objects_Classes_Code_Along.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Functions\" data-toc-modified-id=\"Functions-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Functions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Function-definitions\" data-toc-modified-id=\"Function-definitions-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Function definitions</a></span></li><li><span><a href=\"#Calling-a-function\" data-toc-modified-id=\"Calling-a-function-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Calling a function</a></span></li><li><span><a href=\"#Handling-errors\" data-toc-modified-id=\"Handling-errors-1.3\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>Handling errors</a></span></li><li><span><a href=\"#Types-of-arguments\" data-toc-modified-id=\"Types-of-arguments-1.4\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>Types of arguments</a></span></li><li><span><a href=\"#Final-exericise\" data-toc-modified-id=\"Final-exericise-1.5\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>Final exericise</a></span></li></ul></li><li><span><a href=\"#Objects-and-Classes\" data-toc-modified-id=\"Objects-and-Classes-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Objects and Classes</a></span><ul class=\"toc-item\"><li><span><a href=\"#Adding-methods-to-classes\" data-toc-modified-id=\"Adding-methods-to-classes-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Adding methods to classes</a></span></li><li><span><a href=\"#Adding-attributes\" data-toc-modified-id=\"Adding-attributes-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Adding attributes</a></span></li><li><span><a href=\"#Adding-methods\" data-toc-modified-id=\"Adding-methods-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Adding methods</a></span></li><li><span><a href=\"#Exercise---a-circle-class\" data-toc-modified-id=\"Exercise---a-circle-class-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Exercise - a circle class</a></span></li></ul></li><li><span><a href=\"#Modules\" data-toc-modified-id=\"Modules-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Modules</a></span><ul class=\"toc-item\"><li><span><a href=\"#Build-in-modules\" data-toc-modified-id=\"Build-in-modules-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Build-in modules</a></span></li><li><span><a href=\"#Third-party-libraries\" data-toc-modified-id=\"Third-party-libraries-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Third party libraries</a></span></li><li><span><a href=\"#Exercise---writing-our-own-modules\" data-toc-modified-id=\"Exercise---writing-our-own-modules-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Exercise - writing our own modules</a></span></li></ul></li><li><span><a href=\"#Final-exerice---sampling-from-a-Gaussian\" data-toc-modified-id=\"Final-exerice---sampling-from-a-Gaussian-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Final exerice - sampling from a Gaussian</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "<p>Functions provide you a way to organize your code into modular, reusable, and well-documented chunks.</p>\n",
    "<p>Functions in Python are defined with the <strong>def</strong> keyword. Here is an example of a very basic function performing the dot product between two vectors, i.e.:</p>\n",
    "$$c = \\boldsymbol{a}^{T}\\boldsymbol{b} = \\sum_{i=1}^{k}a_{i}b_{i}$$\n",
    "<p>Note, that in practice, we will never use pure Python for performing linear algebra operations, but will instead use the highly optimized <strong>numpy</strong> library for numerical computation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dot_product(list_a, list_b):\n",
    "    \"\"\"\n",
    "    Performs the dot product operation between two vectors represented\n",
    "    as Python lists. Note, that the list should have the same number of elements -\n",
    "    len(list_a) == len(list_b)\n",
    "    ----------\n",
    "    Arguments:\n",
    "    list_a : list - the first vector\n",
    "    list_b : list - the second vector\n",
    "    ----------\n",
    "    Output:\n",
    "    c : float - the dot product between the two vectors\n",
    "    \"\"\"\n",
    "    \n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calling a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of calling the function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79.75"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we pass lists of different lengths?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-009e5976a10c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdot_product\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mvec_c\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvec_b\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-1-07302b9e3441>\u001b[0m in \u001b[0;36mdot_product\u001b[1;34m(list_a, list_b)\u001b[0m\n\u001b[0;32m     15\u001b[0m     \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     16\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_a\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m         \u001b[0mc\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mlist_a\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mlist_b\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     18\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mc\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Handling errors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Ops, our function fails. Sometimes, typical errors in calling a function can be reduced to a small number of cases. In this case, it might be reasonable to add checks given meaningful error messages, i.e., the arguments of a function do not comply to the expectations of the function. For this, we can use the <strong>assert</strong> keyword.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dot_product(list_a, list_b):\n",
    "    \"\"\"\n",
    "    Performs the dot product operation between two vectors represented\n",
    "    as Python lists. Note, that the list should have the same number of elements -\n",
    "    len(list_a) == len(list_b)\n",
    "    ----------\n",
    "    Arguments:\n",
    "    list_a : list - the first vector\n",
    "    list_b : list - the second vector\n",
    "    ----------\n",
    "    Output:\n",
    "    c : float - the dot product between the two vectors\n",
    "    \"\"\"\n",
    "    \n",
    "    c = 0\n",
    "    for i in range(len(list_a)):\n",
    "        c += list_a[i] * list_b[i]\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This should be still fine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we fail, and we see clearly why we failed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Types of arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Usually, we want to program our functions to be as general as possible, meaning no hardcoded numbers inside the function body and additional options for common additional operations.</p> \n",
    "<p>Let's illustrate this. Suppose we want to to give the user the option to perform the dot product on normalized vectors for better interpretability (similarity).</p>\n",
    "<p>Memo. A vector $\\mathbf{v}$ is normalzied if its norm equals $1$, i.e., $||\\mathbf{v}|| = 1$. The $L2$ norm can be computed as follows:</p>\n",
    "$$||\\mathbf{v}|| = \\sqrt{\\sum_{i=1}^{k}|\\mathbf{v}_{i}|^{2}}$$\n",
    "$$\\widehat{\\mathbf{v}} = \\frac{\\mathbf{v}}{||\\mathbf{v}||}$$\n",
    "<p>Let's enable our function to do this by introducing a keyword indicating whether to perform normalization or not, demonstrating the use of default <strong>keyword arguments</strong>.<p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dot_product(list_a, list_b):\n",
    "    \"\"\"\n",
    "    Performs the dot product operation between two vectors represented\n",
    "    as Python lists. Note, that the list should have the same number of elements -\n",
    "    len(list_a) == len(list_b)\n",
    "    ----------\n",
    "    Arguments:\n",
    "    list_a : list - the first vector\n",
    "    list_b : list - the second vector\n",
    "    ----------\n",
    "    Output:\n",
    "    c : float - the dot product between the two vectors\n",
    "    \"\"\"\n",
    "    \n",
    "    # Make sure the inputs are of the same length\n",
    "    assert len(list_a) == len(list_b), 'Make sure the two input vectors '\\\n",
    "                                       'are of the same length: len(list_a) == len(list_b)'\n",
    "    \n",
    "    # Normalize, if specified\n",
    "    if normalize:\n",
    "        pass\n",
    "        ### \n",
    "        ### Write your code here\n",
    "        ###\n",
    "    \n",
    "    # Compute dot-product\n",
    "    c = 0\n",
    "    for i in range(len(list_a)):\n",
    "        c += list_a[i] * list_b[i]\n",
    "    return c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>We see that our function becomes messy with each additional degree of freedom we provide for the user. Any ideas how we can mitigate this in our case?</p> \n",
    "<p>We spot that we have written our normalization code twice. This is an indication that we can outsoruce this code into a separate function. Let's do this and observe how our code becomes much cleaner.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_vec(vec):\n",
    "    \"\"\"Your documentation here.\"\"\"\n",
    "    \n",
    "    ###\n",
    "    ### Your code here\n",
    "    ###\n",
    "    pass\n",
    "\n",
    "\n",
    "def dot_product(list_a, list_b, normalize=False):\n",
    "    \"\"\"\n",
    "    Performs the dot product operation between two vectors represented\n",
    "    as Python lists. Note, that the list should have the same number of elements -\n",
    "    len(list_a) == len(list_b)\n",
    "    ----------\n",
    "    Arguments:\n",
    "    list_a : list - the first vector\n",
    "    list_b : list - the second vector\n",
    "    ----------\n",
    "    Output:\n",
    "    c : float - the dot product between the two vectors\n",
    "    \"\"\"\n",
    "    \n",
    "    # Make sure the inputs are of the same length\n",
    "    assert len(list_a) == len(list_b), 'Make sure the two input vectors '\\\n",
    "                                       'are of the same length: len(list_a) == len(list_b)'\n",
    "    \n",
    "    # Normalize, if specified\n",
    "    if normalize:\n",
    "        ### \n",
    "        ### Your code here\n",
    "        ###\n",
    "    \n",
    "    # Compute dot-product\n",
    "    c = 0\n",
    "    for i in range(len(list_a)):\n",
    "        c += list_a[i] * list_b[i]\n",
    "    return c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>We can also pass functions as arguments to Python functions. Let's implement the well-known <strong>apply</strong> function, which takes two arguments: a list and a function, and applies the function passed to each element of the list.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>We can perform the trivial job of incrementing each element in a list.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Sometimes, the functions we write are very short and simple. We can avoid the process of defining functions with the <strong>def</strong> keyword by defining the function on the fly. These are also known as nameless, or <strong>lambda</strong> functions. The syntax of the lambda function is as follows:<br><strong>dfunction</strong> args : do something with args.</p>\n",
    "<p>Here is how we can implement the above example by using a lambda <strong>dfunction</strong>.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final exericise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Your turn! Write a filter function, which takes as an argument a list and another function, which returns <strong>True</strong>, if some condition pertaining to an element is met, and <strong>False</strong>, if the condition is not met.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_even(num):\n",
    "    \"\"\"Returns True if num is even and False if odd.\"\"\"\n",
    "    ###\n",
    "    ### Your code here\n",
    "    ###\n",
    "    pass\n",
    "\n",
    "def filter_list(alist, fun):\n",
    "    ###\n",
    "    ### Your code here\n",
    "    ###\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Bonus: How would you do the filter in a Pythonic way!</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objects and Classes\n",
    "<p>The term <strong>object</strong> might appear a bit unclear at first. However, we have been working with objects all the time. In fact, everything in python is an object - variables, functions, even modules!</p>\n",
    "<p>Roughly speaking, objects are particular instances of classes.</p>\n",
    "<p>The concepts of <strong>type</strong> and <strong>class</strong> are unified in Python 3, so you can think of classes as specifying the type of a given family of objects.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'function'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>The <strong>class</strong> defines the blueprint of an object, i.e., its attributes and behavior.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MyFirstClass'>\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding methods to classes\n",
    "<p>Let's create a blueprint for a cat.</p>\n",
    "\n",
    "![Cat](https://i.chzbgr.com/full/9013919744/h58F020A6/)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>A very basic cat.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Calling a method.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I hate the world!\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Let's create some more cats.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sammy\n",
      "sammy\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Now let's call some methods!</p>"
   ]
  },
  {
   "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": [
    "## Exercise - a circle class\n",
    "<p>Create a circle class with a class attribute pi = 3.14..., which given a radius can compute its area and perimeter.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "###\n",
    "### Your code here\n",
    "###s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules\n",
    "<p>One of the main assets of Python is its modules - built-in and third-party.</p>\n",
    "<p>Modules are just code (functions and classes) written by other people for solving a particular class of problems.</p>\n",
    "<p>A general rule of thumb in Python programming is: whenever you are facing a problem, think about whether other people might have faced it to. There is a high probability that you will be reinveting the wheel if you write everything from scratch.</p>\n",
    "<p>Modules are added to a program via the <strong>import</strong> keyword.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build-in modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mathematical functions \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>As mentioned above, modules are also objects and have a particular type.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>We can also import just a particular function from a module. This is rarely a good idea, as namespaces might collide, i.e, you might overwrite your own functions, if they have the same name.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>You can also do an aliased import</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6931471805599453\n"
     ]
    }
   ],
   "source": [
    "print(m.log(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also alias a function from a module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>You can also write your own modules! To do this, you need to put your functions and classes into a separate file and import this file into your programs.<p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Third party libraries\n",
    "<p>There is an enormous amount of third-party libraries out there! Fortunately Python has its own package-management system called <strong>pip</strong>. Let's demonstrate how to use <strong>pip</strong> from the console as well as from the notebook.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Also, take a look at the following modules!</p>\n",
    "\n",
    "1. <strong>numpy</strong>\n",
    "2. <strong>random</strong>\n",
    "3. <strong>collections</strong>\n",
    "4. <strong>scipy</strong>\n",
    "5. <strong>matplotlib</strong>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise - writing our own modules\n",
    "<p>To become more familiar with all the concepts we introduced, we will build a custom class for performing basic statistical operations (mean, variance, etc). Let's call it a <strong>Statistitian</strong></p>\n",
    "<p>The <strong>__init__</strong> method of the class will take a numeric vector as an input.</p>\n",
    "<p>We want instances of <strong>Statistitian</strong> to be able to perform the following operations on its input:</p>\n",
    "\n",
    "1. mean()\n",
    "2. var()\n",
    "3. median()\n",
    "4. sd()\n",
    "5. kurtosis()\n",
    "6. min()\n",
    "7. max()\n",
    "8. range()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Statistician:\n",
    "    \n",
    "    ### \n",
    "    ### Your code here\n",
    "    ###\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have implemented your class correctly, the following should work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test input\n",
    "inp = [2.5, 5.5, 7.5, 8.5]\n",
    "\n",
    "# stat = Statistician(inp)\n",
    "\n",
    "assert stat.mean() == 6.0, 'Error in mean computation'\n",
    "assert stat.var(population=False) == 5.25, 'Error in var() computation (sample)'\n",
    "assert stat.var(population=True) == 7.00, 'Error in var() computation (population)'\n",
    "assert stat.median() == 6.5, 'Error in median() computation'\n",
    "assert round(stat.std(population=False), 2) == 2.29, 'Error in std() computation (sample)'\n",
    "assert round(stat.std(population=True), 2) == 2.65, 'Error in std() computation (population)'\n",
    "assert round(stat.kurtosis(), 2) == -1.24, 'Error in kurtosis() computation (sample)'\n",
    "assert stat.min() == 2.5, 'Error in min() computation (sample)'\n",
    "assert stat.max() == 8.5, 'Error in max() computation (sample)'\n",
    "assert stat.range() == 6.0, 'Error in range() computation (sample)'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Now let's put this into a separate file and import it into our program.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final exerice - sampling from a Gaussian\n",
    "<p>Given the wikipedia article, implement the Box-Muller transform using only the <strong>random</strong> module.</p>\n",
    "<a>https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### \n",
    "### Your code here\n",
    "###"
   ]
  }
 ],
 "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.1"
  },
  "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": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}