Functions_Objects_Classes_Full.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-random\" data-toc-modified-id=\"Final-exerice---sampling-from-a-random-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Final exerice - sampling from a random</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",
    "    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": [
    "## 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": [
    "vec_a = [1.2, 2.5, 3.2, 4.1, 5.3]\n",
    "vec_b = [2.4, 5.6, 2.5, 3.3, 7.8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79.75"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dot_product(vec_a, vec_b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we pass lists of different lengths?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "vec_c = [1.2, 2.5, 3.2, 4.1, 5.3, 2.0]"
   ]
  },
  {
   "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": [
    "dot_product(vec_c, vec_b)"
   ]
  },
  {
   "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",
    "    # 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",
    "    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": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79.75"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This should be still fine\n",
    "dot_product(vec_a, vec_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "Make sure the two input vectors are of the same length: len(list_a) == len(list_b)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-ccdbe381e008>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Now we fail, and we see clearly why we failed\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\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-6-67a95b6f8551>\u001b[0m in \u001b[0;36mdot_product\u001b[1;34m(list_a, list_b)\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m     \u001b[1;31m# Make sure the inputs are of the same length\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m     \u001b[1;32massert\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[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist_b\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'Make sure the two input vectors '\u001b[0m\u001b[0;31m\\\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     17\u001b[0m                                        \u001b[1;34m'are of the same length: len(list_a) == len(list_b)'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAssertionError\u001b[0m: Make sure the two input vectors are of the same length: len(list_a) == len(list_b)"
     ]
    }
   ],
   "source": [
    "# Now we fail, and we see clearly why we failed\n",
    "dot_product(vec_c, vec_b)"
   ]
  },
  {
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-9-90df077af746>, line 26)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-9-90df077af746>\"\u001b[1;36m, line \u001b[1;32m26\u001b[0m\n\u001b[1;33m    c = 0\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "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",
    "        ### 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",
    "        list_a = normalize_vec(list_a)\n",
    "        list_b = normalize_vec(list_b)\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": 96,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'dot_product' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-96-2660a95d5791>\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_a\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvec_b\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnormalize\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'dot_product' is not defined"
     ]
    }
   ],
   "source": [
    "dot_product(vec_a, vec_b, normalize=True)"
   ]
  },
  {
   "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": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def apply(alist, fun):\n",
    "    \"\"\"\n",
    "    Applies fun to each element of the list and returns the modified list.\n",
    "    ----------\n",
    "    Arguments:\n",
    "    alist : list - the list whose elements will be modified\n",
    "    fun   : callable - the function to apply \n",
    "    ----------\n",
    "    Output:\n",
    "    new_list : list - the modified list\n",
    "    \"\"\"\n",
    "    \n",
    "    new_list = []\n",
    "    for el in alist:\n",
    "        new_list.append(fun(el))\n",
    "    return new_list"
   ]
  },
  {
   "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": [
    "def add_one(n):\n",
    "    return n + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n"
     ]
    }
   ],
   "source": [
    "incremented_list = apply(my_list, add_one)\n",
    "print(incremented_list)"
   ]
  },
  {
   "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": [
    "apply(my_list, lambda e: e + 1)"
   ]
  },
  {
   "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\n",
    "    "
   ]
  },
  {
   "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": [
    "print(type(3))\n",
    "print(type(3.2))\n",
    "print(type(\"Hallo World\"))\n",
    "print(type(lambda x: x))\n",
    "print(type([1, 2, 3]))\n",
    "print(type((1, 2, 3)))"
   ]
  },
  {
   "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": [
    "class MyFirstClass:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = MyFirstClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.MyFirstClass'>\n"
     ]
    }
   ],
   "source": [
    "print(type(test))"
   ]
  },
  {
   "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": [
    "class Cat:\n",
    "    \n",
    "    def __init__(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_cat = Cat()"
   ]
  },
  {
   "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": [
    "my_cat.wake_up()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow\n"
     ]
    }
   ],
   "source": [
    "my_cat.meow()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    \n",
    "    def __init__(self, name, breed, happiness):\n",
    "        \n",
    "        # Object attributes\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.happiness = happiness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Let's create some more cats.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_second_cat = Cat('sammy', 'siamemse', 100)\n",
    "my_third_cat = Cat('sammy', 'siamemse', 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sammy\n",
      "sammy\n"
     ]
    }
   ],
   "source": [
    "print(my_second_cat.name)\n",
    "print(my_third_cat.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    \n",
    "    def __init__(self, name, breed, happiness):\n",
    "        \n",
    "        # Object attributes\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "        self.happiness = happiness\n",
    "    \n",
    "    def wake_up(self):\n",
    "        print('I hate the world!')\n",
    "        self.happiness -= 1\n",
    "        \n",
    "    def meow(self):\n",
    "        print('Meow')\n",
    "    \n",
    "    def feed(self):\n",
    "        print('Yumyumyum')\n",
    "        self.happiness += 1\n",
    "        \n",
    "    def rename(self, name):\n",
    "        self.name = name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_new_cat = Cat('Sweety', 'Persian', 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Sweety\n",
      "Breed:  Persian\n",
      "Happiness level:  1\n"
     ]
    }
   ],
   "source": [
    "print('Name:', my_new_cat.name)\n",
    "print('Breed: ', my_new_cat.breed)\n",
    "print('Happiness level: ', my_new_cat.happiness)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Now let's call some methods!</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I hate the world!\n"
     ]
    }
   ],
   "source": [
    "my_new_cat.wake_up()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Sweety\n",
      "Breed:  Persian\n",
      "Happiness level:  0\n"
     ]
    }
   ],
   "source": [
    "print('Name:', my_new_cat.name)\n",
    "print('Breed: ', my_new_cat.breed)\n",
    "print('Happiness level: ', my_new_cat.happiness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yumyumyum\n"
     ]
    }
   ],
   "source": [
    "my_new_cat.feed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Sweety\n",
      "Breed:  Persian\n",
      "Happiness level:  1\n"
     ]
    }
   ],
   "source": [
    "print('Name:', my_new_cat.name)\n",
    "print('Breed: ', my_new_cat.breed)\n",
    "print('Happiness level: ', my_new_cat.happiness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_new_cat.rename('Chubby')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Chubby\n",
      "Breed:  Persian\n",
      "Happiness level:  1\n"
     ]
    }
   ],
   "source": [
    "print('Name:', my_new_cat.name)\n",
    "print('Breed: ', my_new_cat.breed)\n",
    "print('Happiness level: ', my_new_cat.happiness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n",
      "Meow\n"
     ]
    }
   ],
   "source": [
    "for _ in range(10):\n",
    "    my_new_cat.meow()"
   ]
  },
  {
   "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",
    "###"
   ]
  },
  {
   "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",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>As mentioned above, modules are also objects and have a particular type.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'module'>\n"
     ]
    }
   ],
   "source": [
    "print(type(math))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "2.718281828459045\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(math.log(1))\n",
    "print(math.exp(1))\n",
    "print(math.sqrt(4))"
   ]
  },
  {
   "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": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8414709848078965\n"
     ]
    }
   ],
   "source": [
    "print(sin(1))"
   ]
  },
  {
   "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": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log as my_log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0986122886681098"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_log(3)"
   ]
  },
  {
   "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": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: requests in d:\\anaconda3\\lib\\site-packages (2.21.0)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in d:\\anaconda3\\lib\\site-packages (from requests) (2018.11.29)\n",
      "Requirement already satisfied: idna<2.9,>=2.5 in d:\\anaconda3\\lib\\site-packages (from requests) (2.8)\n",
      "Requirement already satisfied: urllib3<1.25,>=1.21.1 in d:\\anaconda3\\lib\\site-packages (from requests) (1.24.1)\n",
      "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in d:\\anaconda3\\lib\\site-packages (from requests) (3.0.4)\n"
     ]
    }
   ],
   "source": [
    "!pip install requests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = requests.get('https://www.psychologie.uni-heidelberg.de/empg2019/speakers.html')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<!DOCTYPE html>\\n<html lang=\"en\" dir=\"ltr\">\\n  <head>\\n    <meta charset=\"utf-8\" />\\n    <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge,chrome=1\" />\\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, maximum-scale=1.0\">\\n    <meta charset=\"utf-8\">\\n    <link rel=\"stylesheet\" href=\"https://cdnjs.cloudflare.com/ajax/libs/semantic-ui/2.3.3/semantic.min.css\">\\n    <link rel=\"stylesheet\" href=\"styles/style.css\">\\n    <script\\n\\t\\t\\t  src=\"https://code.jquery.com/jquery-3.3.1.min.js\"\\n\\t\\t\\t  integrity=\"sha256-FgpCb/KJQlLNfOu91ta32o/NMZxltwRo8QtmkMRdAu8=\"\\n\\t\\t\\t  crossorigin=\"anonymous\">\\n    </script>\\n    <script type=\"text/javascript\" src=\"https://cdnjs.cloudflare.com/ajax/libs/semantic-ui/2.3.3/semantic.min.js\"></script>\\n    <script src=\"scripts/fix-menu.js\"></script>\\n    <title>EMPG 2019 Heidelberg</title>\\n  </head>\\n\\n  <body>\\n    <!-- Following Menu -->\\n    <div class=\"ui huge top fixed hidden menu\">\\n      <div class=\"ui container\">\\n        <a class=\"item\" href=\"index.html\">Home</a>\\n        <a class=\"item\" href=\"dates.html\">Important Dates</a>\\n        <a class=\"item\" href=\"register.html\">Registration</a>\\n        <a class=\"item\" href=\"submission.html\">Submission</a>\\n        <a class=\"item\" href=\"program.html\">Program</a>\\n        <a class=\"active item\" href=\"speakers.html\">Speakers</a>\\n        <a class=\"item\" href=\"travel.html\">Travel and Venue</a>\\n        <a class=\"item\" href=\"contact.html\">Contact</a>\\n      </div>\\n    </div>\\n\\n    <!-- Sidebar Menu -->\\n    <div class=\"ui vertical thin sidebar menu\">\\n      <a class=\"item\" href=\"index.html\">Home</a>\\n      <a class=\"item\" href=\"dates.html\">Important Dates</a>\\n      <a class=\"item\" href=\"register.html\">Registration</a>\\n      <a class=\"item\" href=\"submission.html\">Submission</a>\\n      <a class=\"item\" href=\"program.html\">Program</a>\\n      <a class=\"active item\" href=\"speakers.html\">Speakers</a>\\n      <a class=\"item\" href=\"travel.html\">Travel and Venue</a>\\n      <a class=\"item\" href=\"contact.html\">Contact</a>\\n    </div>\\n\\n    <!-- Page Contents -->\\n    <div class=\"pusher\">\\n      <!-- Navbar -->\\n      <div class=\"ui main-menu container navbar\">\\n        <div class=\"ui secondary pointing massive menu\">\\n          <a class=\"toc item\">\\n            <i class=\"sidebar icon\"></i>\\n          </a>\\n          <a class=\"item\" href=\"index.html\">Home</a>\\n          <a class=\"item\" href=\"dates.html\">Important Dates</a>\\n          <a class=\"item\" href=\"register.html\">Registration</a>\\n          <a class=\"item\" href=\"submission.html\">Submission</a>\\n          <a class=\"item\" href=\"program.html\">Program</a>\\n          <a class=\"active item\" href=\"speakers.html\">Speakers</a>\\n          <a class=\"item\" href=\"travel.html\">Travel and Venue</a>\\n          <a class=\"item\" href=\"contact.html\">Contact</a>\\n        </div>\\n      </div>\\n\\n      <!-- Welcome -->\\n      <div class=\"ui vertical stripe segment main-content\">\\n        <div class=\"ui main container\">\\n          <h2 class=\"ui horizontal centered header\">Keynote Speakers</h2>\\n          <div class=\"ui container\">\\n            <div class=\"ui segment\">\\n              <img class=\"ui small left floated image\" src=\"img/rouder.png\">\\n              <h2 class=\"ui header\">Jeff Rouder, University of California, Irvine</h2>\\n\\t\\t\\t  <br>\\n              <h3 class=\"ui header\">Qualitative vs. Quantitative Individual Differences: Implications for Cognitive Control</h3>\\n              <p>Consider a task with a well-established effect such as the Stroop effect. In such tasks, there is often a canonical direction of the effect—responses to congruent items are faster than incongruent ones. And with this direction, there are three qualitatively different regions of performance: (a) a canonical effect, (b) no effect, or (c) an opposite or negative effect (for Stroop, responses to incongruent stimuli are faster than responses to congruent ones). Individual differences can be qualitative in that different people may truly occupy different regions; that is, some may have canonical effects while others may have the opposite effect. Or, alternatively, it may only be quantitative in that all people are truly in one region (all people have a true canonical effect). Which of these descriptions holds has two critical implications. The first is theoretical: Those tasks that admit qualitative differences may be more complex and subject to multiple processing pathways or strategies. Those tasks that do not admit qualitative differences may be explained more universally. The second is practical: it may be very difficult to document individual differences in a task or correlate individual differences across task if these tasks do not admit qualitative individual differences. In this talk, I develop trial-level hierarchical models of quantitative and qualitative individual differences and apply these models to cognitive control tasks. Not only is there no evidence for qualitative individual differences, the quantitative individual differences are so small that there is little hope of localizing correlations in true performance among these tasks.\\n              </p>\\n            </div>\\n            <div class=\"ui segment\">\\n                <img class=\"ui small left floated image\" src=\"img/strobl.jpg\">\\n                <h2 class=\"ui header\">Carolin Strobl, University of Zurich</h2>\\n\\t\\t\\t\\t<br>\\n                <h3 class=\"ui header\">A Statistician’s Botanical Garden - The Ideas behind Decision Trees and Random Forests</h3>\\n                <p>Classification and regression trees, model-based trees and random forests are powerful statistical methods from the field of machine learning. They have been shown to achieve a high prediction accuracy, especially in big data applications with many predictor variables and complex association patterns (such as nonlinear and higher-order interaction effects). While individual trees are easy to interpret, random forests are \"black box\" prediction methods. They do, however, provide variable importance measures, that are being used to judge the relevance of the individual predictor variables. The aim of this presentation is to introduce the rationale behind trees, model-based trees and random forests, to illustrate their potential for high-dimensional data exploration in psychological research, but also to point out limitations and potential pitfalls in their practical application.</p>\\n              </div>\\n            <div class=\"ui segment\">\\n              <img class=\"ui small left floated image\" src=\"img/trueblood.JPG\">\\n              <h2 class=\"ui header\">Jennifer Trueblood, Vanderbilt University</h2>\\n\\t\\t\\t  <br>\\n              <h3 class=\"ui header\">Urgency, Leakage, and the Relative Nature of Information Processing in Decision-making</h3>\\n              <p>Over the last decade, there has been a robust debate in decision neuroscience and psychology about what mechanism governs the time course of decision making. Historically, the most prominent hypothesis is that neural architectures accumulate information over time until some threshold is met, the so-called Evidence Accumulation hypothesis. However, most applications of this theory rely on simplifying assumptions, belying a number of potential complexities. Is stimulus information perceived and processed in an independent manner or is there a relative component to information processing? Does urgency play a role? What about evidence leakage? While the latter questions have been the subject of recent investigations, most studies to date have been piecemeal in nature, studying one aspect of the decision process or another. Here we develop a modeling framework, an extension of the Urgency Gating Model, in conjunction with a changing information experimental paradigm to jointly probe these aspects of the decision process. Using state-of-the-art Bayesian methods to perform parameter-based inference, we demonstrate 1) information processing is relative with early information influencing the perception of late information, 2) time varying urgency and evidence accumulation are of roughly equal importance in the decision process, and 3) leakage is present with a time scale of ~250ms. This is the first such study to utilize a changing information paradigm to jointly and quantitatively estimate the temporal dynamics of human decision-making.</p>\\n            </div>\\n          </div>\\n         \\n          \\n          \\n          </div>\\n        </div>\\n      <!-- Footer -->\\n      <div class=\"ui vertical footer segment sticky\">\\n        <div class=\"ui container\">\\n          <div class=\"ui stackable divided equal height stackable grid\">\\n            <div class=\"three wide column\">\\n              <h4 class=\"ui header\">About</h4>\\n              <div class=\"ui link list\">\\n                <a href=\"contact.html\" class=\"item\">Contact</a>\\n                <a href=\"https://www.xing.com/profile/Maximilian_Knapp3\" class=\"item\">Logo design by Maximilian Knapp</a>\\n                <a href=\"https://www.psychologie.uni-heidelberg.de/ae/meth/team/radev/index.html\" class=\"item\">Webpage by Stefan Radev</a>\\n              </div>\\n            </div>\\n            <div class=\"three wide column\">\\n              <h4 class=\"ui header\">Partners</h4>\\n              <div class=\"ui link list\">\\n                <a href=\"https://www.uni-heidelberg.de/index_e.html\" class=\"item\">Heidelberg University</a>\\n                <a href=\"https://www.psychologie.uni-heidelberg.de\" class=\"item\">Institute of Psychology</a>\\n              </div>\\n            </div>\\n            <div class=\"four wide column\">\\n              <a href=\"https://www.psychologie.uni-heidelberg.de/ae/meth/index-en.html\" class=\"ui fluid rounded image\">\\n                <img src=\"img/schriftzug_methoden.png\" alt=\"methods logo\">\\n              </a>\\n            </div>\\n            <div class=\"three wide column\">\\n              <a href=\"https://www.uni-heidelberg.de/index_e.html\" class=\"ui fluid rounded image\">\\n                <img src=\"img/logo-heidelberg.png\" alt=\"heidelberg logo\">\\n              </a>\\n            </div>\\n          </div>\\n        </div>\\n      </div>\\n      </div>\\n    </div>\\n  </body>\\n</html>\\n'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.text"
   ]
  },
  {
   "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 random\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.6.8"
  },
  "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
}