tutorials/tutorial_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python for biologists\n",
    "\n",
    "## Tutorial 4 - Numpy tutorial\n",
    "\n",
    "*by Tobias Andermann*\n",
    "\n",
    "In the following tutorials we will cover some data science operations in Python that are particularly useful for the natural sciences. The course is 'advanced' in the sense that it assumes that you know how to use the basic data structures and operations in Python, such as loops, strings, lists, functions, etc. If you have never been in contact with Python before, you can start with our [Python introduction tutorial](https://github.com/tobiashofmann88/python_for_biologists/blob/master/tutorials/tutorial_1.ipynb).\n",
    "\n",
    "Let's start getting you more familiar with the numpy library. We already used numpy briefly in the first tutorial, but here we will cover this very useful and essential package in more detail and point out the most useful numpy functions.\n",
    "\n",
    "________\n",
    "\n",
    "### Installation\n",
    "\n",
    "In this tutorial we will need to have these libraries installed. If you already installed them during the previous tutorials, there is no need to repeat this step.\n",
    "```\n",
    "pip install numpy\n",
    "pip install matplotlib\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic numpy math operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is used for defining and manipulating arrays, and is one of the most powerful and commonly used tools in python. This is how you define a new, empty array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], dtype=float64)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "my_array = np.array([])\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how you populate the array with values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array = np.array([1,2,3,4,5,6,7])\n",
    "my_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays are different to lists in python, even though they may look similar on first sight. The strength of arrays is that they allow a multitude of mathematical operations, while lists don't. Lists are more used to store a sequence of values (numbers, strings objects, lists, anything really). Arrays on the other hand usually contain integers or floats, but can also contain text-strings, which is not very common though and defies the purpose (since no mathematical operations can be executed on strings).\n",
    "\n",
    "See the following example to understand the different betwee **lists** and **arrays**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3,4,5,6,7]\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try some mathematical operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array+4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"int\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-aa5f4a7d3a83>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_list\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
     ]
    }
   ],
   "source": [
    "my_list+4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though both of our objects contain the same exact elements, adding a value to all elements in a list does not work. How about multiplications?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list*2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No error this time, but what happened to the list?\n",
    "You can also subtract, divide, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1,  0,  1,  2,  3,  4,  5])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_array-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to add the values of two arrays, these arrays need to have the same dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (5,) (4,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-e086d53ce4a2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0marray_b\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0marray_a\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0marray_b\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (5,) (4,) "
     ]
    }
   ],
   "source": [
    "array_a = np.array([1,2,3,4,5])\n",
    "array_b = np.array([2,3,4,5])\n",
    "\n",
    "array_a+array_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doesn't work because of array dimensions, but this works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3,  5,  7,  9, 11])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_a = np.array([1,2,3,4,5])\n",
    "array_b = np.array([2,3,4,5,6])\n",
    "\n",
    "array_a+array_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Raise your array to the power of 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  4,  9, 16, 25, 36, 49])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also perform scalar operations elementwise on the entire array\n",
    "my_array**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or take the log value of the array elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.30103   , 0.47712125, 0.60205999])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# log with base 10\n",
    "b = np.array([1,2,3,4])\n",
    "np.log10(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.69314718, 1.09861229, 1.38629436])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# log with base e\n",
    "np.log(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can try a multitude of mathematical operations [see here for an overview](https://numpy.org/doc/stable/reference/routines.math.html). I recommend that you play around with this for a bit, using different input arrays and values. It is important to have a good grip on these basic numpy array operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "\n",
    "### 2D arrays\n",
    "\n",
    "So far we have only worked with 1-dimensional arrays. Arrays can have any number of dimensions, let's work with 2D arrays for now. This is how you define a 2D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np_array = np.array([[ 0,  1,  2,  3,  4],\n",
    "                     [ 5,  6,  7,  8,  9],\n",
    "                     [10, 11, 12, 13, 14]])\n",
    "np_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Work through the following examples of basic and useful numpy operations. Try to understand them. Play around with different values. Ask if something is unclear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creates a 3x4 array of 0's\n",
    "np.zeros((3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creates a 3x4 array of int 1's\n",
    "np.ones((3,4)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90,\n",
       "       95])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### You can also create arrays with certain patterns like so\n",
    "# Creating a 1D array of numbers from 10 to 100 in increments of 5\n",
    "np.arange( 10, 100, 5 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 1D array of numbers from 0 to 2 in increments of 0.3\n",
    "np.arange( 0, 2, 0.3 ) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.02020202, 0.04040404, 0.06060606, 0.08080808,\n",
       "       0.1010101 , 0.12121212, 0.14141414, 0.16161616, 0.18181818,\n",
       "       0.2020202 , 0.22222222, 0.24242424, 0.26262626, 0.28282828,\n",
       "       0.3030303 , 0.32323232, 0.34343434, 0.36363636, 0.38383838,\n",
       "       0.4040404 , 0.42424242, 0.44444444, 0.46464646, 0.48484848,\n",
       "       0.50505051, 0.52525253, 0.54545455, 0.56565657, 0.58585859,\n",
       "       0.60606061, 0.62626263, 0.64646465, 0.66666667, 0.68686869,\n",
       "       0.70707071, 0.72727273, 0.74747475, 0.76767677, 0.78787879,\n",
       "       0.80808081, 0.82828283, 0.84848485, 0.86868687, 0.88888889,\n",
       "       0.90909091, 0.92929293, 0.94949495, 0.96969697, 0.98989899,\n",
       "       1.01010101, 1.03030303, 1.05050505, 1.07070707, 1.09090909,\n",
       "       1.11111111, 1.13131313, 1.15151515, 1.17171717, 1.19191919,\n",
       "       1.21212121, 1.23232323, 1.25252525, 1.27272727, 1.29292929,\n",
       "       1.31313131, 1.33333333, 1.35353535, 1.37373737, 1.39393939,\n",
       "       1.41414141, 1.43434343, 1.45454545, 1.47474747, 1.49494949,\n",
       "       1.51515152, 1.53535354, 1.55555556, 1.57575758, 1.5959596 ,\n",
       "       1.61616162, 1.63636364, 1.65656566, 1.67676768, 1.6969697 ,\n",
       "       1.71717172, 1.73737374, 1.75757576, 1.77777778, 1.7979798 ,\n",
       "       1.81818182, 1.83838384, 1.85858586, 1.87878788, 1.8989899 ,\n",
       "       1.91919192, 1.93939394, 1.95959596, 1.97979798, 2.        ])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a 1D array of 100 numbers equally spaced from 0 to 2 \n",
    "a = np.linspace( 0, 2, 100 ) \n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above array has exactly 100 values, as we defined in the `.linspace()` function. We can reshape this array into a 2D array with a specified number of rows and columns (needs to add up to 100 in this case, though). For example if we want this to be changed into an array with 5 rows and 20 columns, we do the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.02020202, 0.04040404, 0.06060606, 0.08080808,\n",
       "        0.1010101 , 0.12121212, 0.14141414, 0.16161616, 0.18181818,\n",
       "        0.2020202 , 0.22222222, 0.24242424, 0.26262626, 0.28282828,\n",
       "        0.3030303 , 0.32323232, 0.34343434, 0.36363636, 0.38383838],\n",
       "       [0.4040404 , 0.42424242, 0.44444444, 0.46464646, 0.48484848,\n",
       "        0.50505051, 0.52525253, 0.54545455, 0.56565657, 0.58585859,\n",
       "        0.60606061, 0.62626263, 0.64646465, 0.66666667, 0.68686869,\n",
       "        0.70707071, 0.72727273, 0.74747475, 0.76767677, 0.78787879],\n",
       "       [0.80808081, 0.82828283, 0.84848485, 0.86868687, 0.88888889,\n",
       "        0.90909091, 0.92929293, 0.94949495, 0.96969697, 0.98989899,\n",
       "        1.01010101, 1.03030303, 1.05050505, 1.07070707, 1.09090909,\n",
       "        1.11111111, 1.13131313, 1.15151515, 1.17171717, 1.19191919],\n",
       "       [1.21212121, 1.23232323, 1.25252525, 1.27272727, 1.29292929,\n",
       "        1.31313131, 1.33333333, 1.35353535, 1.37373737, 1.39393939,\n",
       "        1.41414141, 1.43434343, 1.45454545, 1.47474747, 1.49494949,\n",
       "        1.51515152, 1.53535354, 1.55555556, 1.57575758, 1.5959596 ],\n",
       "       [1.61616162, 1.63636364, 1.65656566, 1.67676768, 1.6969697 ,\n",
       "        1.71717172, 1.73737374, 1.75757576, 1.77777778, 1.7979798 ,\n",
       "        1.81818182, 1.83838384, 1.85858586, 1.87878788, 1.8989899 ,\n",
       "        1.91919192, 1.93939394, 1.95959596, 1.97979798, 2.        ]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(5,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also fill the array with random values between 0 and 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.74001436, 0.12984161, 0.92778301, 0.07672625, 0.49570568,\n",
       "       0.29320163, 0.40045479, 0.63617792, 0.05503776, 0.96416947,\n",
       "       0.19864421, 0.36233258, 0.34499518, 0.06154136, 0.34290884,\n",
       "       0.6699999 , 0.83829242, 0.57262143, 0.19558209, 0.29897307,\n",
       "       0.79416663, 0.48187567, 0.93008834, 0.35445644, 0.02559039,\n",
       "       0.46161158, 0.79312959, 0.82078239, 0.24850885, 0.42411661,\n",
       "       0.91611583, 0.56073588, 0.64324351, 0.93828452, 0.24900303,\n",
       "       0.07652539, 0.36782962, 0.0325134 , 0.99287605, 0.85477226,\n",
       "       0.98906067, 0.844119  , 0.65769997, 0.08520813, 0.63447829,\n",
       "       0.27977886, 0.86549087, 0.80351969, 0.35697466, 0.22088469,\n",
       "       0.83605937, 0.78550207, 0.88556182, 0.19212274, 0.25627411,\n",
       "       0.474251  , 0.02981747, 0.09122409, 0.67423951, 0.18574742,\n",
       "       0.13208999, 0.56917704, 0.16530051, 0.13654349, 0.33718535,\n",
       "       0.41659657, 0.68446419, 0.49199955, 0.51236923, 0.36189268,\n",
       "       0.16257048, 0.40652984, 0.15069797, 0.77403348, 0.5475443 ,\n",
       "       0.41195002, 0.36140081, 0.59266048, 0.97228396, 0.8117099 ,\n",
       "       0.80752831, 0.44812699, 0.98951169, 0.77180613, 0.04412954,\n",
       "       0.62532721, 0.04144324, 0.65331049, 0.41081668, 0.13815054,\n",
       "       0.73194921, 0.76116973, 0.69337699, 0.95367449, 0.31849352,\n",
       "       0.13289499, 0.1520524 , 0.87268957, 0.25180628, 0.88028717])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____\n",
    "\n",
    "### Getting array information\n",
    "\n",
    "There are also many functions that help you getting information about your arrays. Here are some of the most important.\n",
    "\n",
    "Try the following commands `.max()`, `.min()`, and `.sum()` and see what they are doing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array( [20,30,40,50] )\n",
    "a.max()\n",
    "a.min()\n",
    "a.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have a multi-dimensional array, use the \"axis\" parameter to specify how to calculate the sums, for example take this array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(12).reshape(3,4)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if we want to calculate the sum of each column we can do this by specifying axis=0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 15, 18, 21])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If instead you want to calculate the sum of each row, use axis=1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6, 22, 38])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The sum of the whole 2D array is simply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "**TASK:** Using these tools, can you produce the sum of each 4th number between 0 and 999?\n",
    "I.e. if you have the number from 0 to 999 `[0,1,2,3,4,5,6,7,8,...] `, add up the numbers `0+4+8+...`, `[1+5+9+...]`, `[2+6+10+...]`, and `[3+7+11+...]` to print four sums at the end.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([124500, 124750, 125000, 125250])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "### Array slicing\n",
    "\n",
    "Python in general, but numpy particularly, makes the subselection of parts of the array rather simple and straight forward (much easier than in R for example).\n",
    "\n",
    "You take a selection of an array by stating the index you are interested in. Remember that python starts counting with index 0.\n",
    "\n",
    "To demonstrate the python index logic look at the following example:\n",
    "```\n",
    "array/list:       [10 , 20 , 30 , 40 , 50]\n",
    "\n",
    "python index:     [0], [1], [2], [3], [4]\n",
    "\n",
    "\"human\" language: 1st, 2nd, 3rd, 4th, 5th element of array\n",
    "```\n",
    "\n",
    "For example if I want to print the 5th value of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])\n",
    "a[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that counting in python starts with the index 0!\n",
    "\n",
    "If I want to take the 2nd to the 4th element of an array I need to define the starting index (2) and the final index (5) separated by a colon. Python doesn't include the right boundary when ranges are specified, i.e. if you would put index 4 it would not include the 4th element but only go to the third. It's something to get used to but it has good reasons that python is handling it this way:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20, 30, 40])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print the last element by specifying the index `-1`, the second last with `-2` etc. Try the following subselections and pay attention what is being selected. Play around a bit with different indeces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2]\n",
    "a[1:4]\n",
    "a[-1]\n",
    "a[:8]\n",
    "a[2:]\n",
    "a[-5:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use this slicing for example to assign a new value to the selected elements, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0, 999, 999, 999,  40,  50,  60,  70,  80,  90, 100])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])\n",
    "a[1:4] = 999\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a 2D array, the slicing works similarly, except that we need to specify indeces in two dimensions (rows and columns). Take for example the following array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(12).reshape(3,4)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we only want to select the 2nd and third value in the last row, we provide first the row index and then the column indeces separated by a comma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9, 10])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[-1,1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you just want to select all rows or all columns you can dot his with only using `:`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2],\n",
       "       [ 5,  6],\n",
       "       [ 9, 10]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[:,1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes you need to flip an array, i.e. turn rows into columns and vice versa. You can do this by using `.T`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  4,  8],\n",
       "       [ 1,  5,  9],\n",
       "       [ 2,  6, 10],\n",
       "       [ 3,  7, 11]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-warning\">\n",
    "**TASK:** Use array slicing to produce the following 2D array with the number `999` in the central 4 cells.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2,   3,   4,   5,   6,   7,   8,   9],\n",
       "       [ 10,  11,  12,  13,  14,  15,  16,  17,  18,  19],\n",
       "       [ 20,  21,  22,  23,  24,  25,  26,  27,  28,  29],\n",
       "       [ 30,  31,  32,  33,  34,  35,  36,  37,  38,  39],\n",
       "       [ 40,  41,  42,  43, 999, 999,  46,  47,  48,  49],\n",
       "       [ 50,  51,  52,  53, 999, 999,  56,  57,  58,  59],\n",
       "       [ 60,  61,  62,  63,  64,  65,  66,  67,  68,  69],\n",
       "       [ 70,  71,  72,  73,  74,  75,  76,  77,  78,  79],\n",
       "       [ 80,  81,  82,  83,  84,  85,  86,  87,  88,  89],\n",
       "       [ 90,  91,  92,  93,  94,  95,  96,  97,  98,  99]])"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "______\n",
    "\n",
    "### Sampling random values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides just generating random numbers between 0 and 1, as we did earlier with the `np.random.random()` function, numpy has a whole range of random sampling methods.\n",
    "\n",
    "One method that is often used is the `np.random.choice()` function. Here you can defined a list that numpy randomly samples values from. For example we can simulate 100 dice throws by first defining the list containing all available options (numbers 1-6) and then randomely sampling from it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 4, 3, 1, 3, 2, 6, 4, 3, 1, 6, 1, 1, 4, 6, 6, 6, 4, 6, 6, 6,\n",
       "       2, 2, 3, 6, 5, 4, 3, 6, 6, 5, 2, 6, 4, 5, 5, 4, 4, 6, 1, 2, 1, 3,\n",
       "       2, 3, 3, 3, 5, 6, 5, 3, 5, 3, 1, 5, 1, 6, 2, 2, 2, 5, 5, 3, 5, 2,\n",
       "       3, 5, 5, 4, 3, 5, 2, 3, 6, 2, 6, 3, 2, 6, 5, 3, 6, 3, 1, 1, 3, 4,\n",
       "       4, 1, 1, 2, 2, 5, 2, 4, 4, 1, 3, 6])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "possible_values = [1,2,3,4,5,6]\n",
    "np.random.choice(possible_values,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above you see that the values are drawn with replacement (the same value can be drawn multiple times from the list of possible values).\n",
    "\n",
    "Let's say you want to randomely determine the presentation order for your next research group meeting, then you normally don't want to draw the same name multiple times and you want to ensure that every name is drawn. Therefore you need to turn off replacement, using the `replace=False` option and set the number of draws to be equal to the number of names in the 'bag':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Christina' 'Bert' 'Dora' 'Emil' 'Adam' 'Fernanda']\n"
     ]
    }
   ],
   "source": [
    "names = ['Adam','Bert','Christina','Dora','Emil','Fernanda']\n",
    "presentation_order = np.random.choice(names,len(names),replace=False)\n",
    "print(presentation_order)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insteead of using predefined lists of possible values, we can also sample from distributions.\n",
    "\n",
    "In this example I randomely sample values from a uniform distribution between 0 and 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "samples = np.random.uniform(0,100,10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When sampling random values it always helps to visualize what is happening. A good tool for this is plotting histograms of the sampled values. In Python you can do this easily using the matplotlib library, which we already used in yesterdays tutorial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we plot a histogram using the `hist()` function. We can specify how many bins the histogram should have, in this case you can choose 100:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "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": [
    "plt.hist(samples,100);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You see that the values are sampled with equal probability from across the defined range. Let's try a different distibution.\n",
    "\n",
    "Now we sample instead from a normal distribution. For this we need to specify the mean and standard deviation of the distribution we want to sample from, I choose mean=50 and std=15 in the example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAQ1klEQVR4nO3df6zddX3H8edrwPDXIiBdU9uyMu00uMTCbhhGszCZkx/LioljkAUbw1L/gAwXkw3dH7plJDVRmSYbWRVmMQ5kiKNxxA0rCTGZaFGCQGVULdKm0Co/ZDNTi+/9cb51x3Jvzzn3nnvvOZ8+H8nJ/X4/3+855/PN9/R13udzPufbVBWSpLb80nJ3QJI0foa7JDXIcJekBhnuktQgw12SGnT8cncA4NRTT61169Ytdzckaarcd99936+qFbNtm4hwX7duHTt37lzubkjSVEny2FzbHJaRpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBhrskNchwl6QGTcQvVKVJs+6af/v58p4tFw1slyaN4S6NmW8AmgQOy0hSg6zcpTHor9alSWDlLkkNsnKXOlbfaomVuyQ1yHCXpAYZ7pLUIMNdkhrkF6rSEvHHTVpKVu6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQQOnQiZ5EXAPcGK3/21V9f4kpwO3AK8A7gMur6qfJDkRuAn4LeAHwB9X1Z5F6r+06LzmjKbRMJX7j4E3V9XrgQ3A+UnOAT4IXFdVrwaeBq7o9r8CeLprv67bT5K0hAaGe/X8d7d6Qncr4M3AbV37NuDibnljt063/bwkGVuPJUkDDTXmnuS4JPcDB4C7gG8Dz1TVoW6XvcDqbnk18DhAt/1ZekM3Rz7m5iQ7k+w8ePDgwo5CkvQLhrr8QFU9D2xIchLwOeC1C33iqtoKbAWYmZmphT6etNQci9ckG2m2TFU9A9wNvAE4KcnhN4c1wL5ueR+wFqDb/nJ6X6xKkpbIwHBPsqKr2EnyYuAtwC56If/2brdNwB3d8vZunW77l6rKylySltAwwzKrgG1JjqP3ZnBrVX0+ycPALUn+FvgGcEO3/w3Ap5LsBp4CLl2EfkuSjmJguFfVA8CZs7R/Bzh7lvb/Bf5oLL2TJM2Lv1CVpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBQ11bRpoG/dd62bPlooH7SC2zcpekBlm5q3lW6zoWWblLUoMMd0lqkOEuSQ1yzF1TbVrH04eZ2SMthOEuLaJpffPR9DPcNRWsdKXROOYuSQ0y3CWpQYa7JDXIcJekBvmFqprkLBUd66zcJalBA8M9ydokdyd5OMlDSa7u2j+QZF+S+7vbhX33eW+S3UkeSfLWxTwASdILDTMscwh4T1V9PcmvAPcluavbdl1Vfah/5yRnAJcCrwNeCXwxyW9U1fPj7LjUCufwazEMDPeq2g/s75afS7ILWH2Uu2wEbqmqHwPfTbIbOBv4zzH0V3I8XRrCSGPuSdYBZwL3dk1XJXkgyY1JTu7aVgOP991tL7O8GSTZnGRnkp0HDx4cueOSpLkNHe5JXgZ8Fnh3Vf0QuB54FbCBXmX/4VGeuKq2VtVMVc2sWLFilLtKkgYYKtyTnEAv2D9dVbcDVNWTVfV8Vf0M+Di9oReAfcDavruv6dokSUtkmNkyAW4AdlXVR/raV/Xt9jbgwW55O3BpkhOTnA6sB746vi5LkgYZZrbMG4HLgW8mub9rex9wWZINQAF7gHcBVNVDSW4FHqY30+ZKZ8pI0tIaZrbMl4HMsunOo9znWuDaBfRLOiY5LVLj4i9UJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkOEuSQ0y3CWpQf4fqpoo/kJTGg8rd0lqkOEuSQ0y3CWpQYa7JDXIcJekBhnuktQgw12SGuQ8d2kKOP9fo7Jyl6QGWblLE6q/WpdGZbhrYhlu0vw5LCNJDRoY7knWJrk7ycNJHkpyddd+SpK7kjza/T25a0+SjyXZneSBJGct9kFIkn7RMJX7IeA9VXUGcA5wZZIzgGuAHVW1HtjRrQNcAKzvbpuB68fea0nSUQ0M96raX1Vf75afA3YBq4GNwLZut23Axd3yRuCm6vkKcFKSVWPvuSRpTiONuSdZB5wJ3AusrKr93aYngJXd8mrg8b677e3ajnyszUl2Jtl58ODBEbstSTqaocM9ycuAzwLvrqof9m+rqgJqlCeuqq1VNVNVMytWrBjlrpKkAYaaCpnkBHrB/umqur1rfjLJqqra3w27HOja9wFr++6+pmuTNGb+clVzGWa2TIAbgF1V9ZG+TduBTd3yJuCOvvZ3dLNmzgGe7Ru+kSQtgWEq9zcClwPfTHJ/1/Y+YAtwa5IrgMeAS7ptdwIXAruBHwHvHGuP1Rx/rCSN38Bwr6ovA5lj83mz7F/AlQvslyRpAfyFqiQ1yHCXpAYZ7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDfJ/YpKmjD/60jCs3CWpQVbuUiO8iJj6WblLUoMMd0lqkOEuSQ0y3CWpQX6hqmXhdD5pcVm5S1KDDHdJapDhLkkNMtwlqUGGuyQ1yHCXpAY5FVJLxumP0tIZWLknuTHJgSQP9rV9IMm+JPd3twv7tr03ye4kjyR562J1XJI0t2GGZT4JnD9L+3VVtaG73QmQ5AzgUuB13X3+Iclx4+qsJGk4A8O9qu4Bnhry8TYCt1TVj6vqu8Bu4OwF9E+SNA8L+UL1qiQPdMM2J3dtq4HH+/bZ27VJkpbQfMP9euBVwAZgP/DhUR8gyeYkO5PsPHjw4Dy7IUmazbzCvaqerKrnq+pnwMf5/6GXfcDavl3XdG2zPcbWqpqpqpkVK1bMpxuSpDnMK9yTrOpbfRtweCbNduDSJCcmOR1YD3x1YV2UJI1q4Dz3JDcD5wKnJtkLvB84N8kGoIA9wLsAquqhJLcCDwOHgCur6vnF6bokaS4Dw72qLpul+Yaj7H8tcO1COiVJWhgvPyBJDTLcJalBhrskNchwl6QGeVVILSqvBCktDyt3SWqQlbvUoP5PTHu2XLSMPdFysXKXpAZZuUuNs4o/Nlm5S1KDDHdJapDDMho7pz9Ky8/KXZIaZLhLUoMMd0lqkGPu0jHEaZHHDsNdY+GXqNJkcVhGkhpkuEtSgwx3SWqQY+6aN8fZpcll5S5JDRoY7kluTHIgyYN9backuSvJo93fk7v2JPlYkt1JHkhy1mJ2XpI0u2Eq908C5x/Rdg2wo6rWAzu6dYALgPXdbTNw/Xi6KUkaxcBwr6p7gKeOaN4IbOuWtwEX97XfVD1fAU5KsmpcnZUkDWe+Y+4rq2p/t/wEsLJbXg083rff3q5NkrSEFjxbpqoqSY16vySb6Q3dcNpppy20G5LG5MhZUF6mYDrNN9yfTLKqqvZ3wy4HuvZ9wNq+/dZ0bS9QVVuBrQAzMzMjvzlIWhivM9O2+Q7LbAc2dcubgDv62t/RzZo5B3i2b/hGkrREBlbuSW4GzgVOTbIXeD+wBbg1yRXAY8Al3e53AhcCu4EfAe9chD5LkgYYGO5Vddkcm86bZd8CrlxopzRZ/PjePn9t3B5/oSpJDTLcJalBhrskNchwl6QGGe6S1CCv566ROKvi2ObMqelh5S5JDTLcJalBhrskNchwl6QGGe6S1CDDXZIaZLhLUoMMd0lqkD9i0qz8sZIO87UwnazcJalBVu76OSs0qR1W7pLUIMNdkhpkuEtSgwx3SWqQ4S5JDTLcJalBC5oKmWQP8BzwPHCoqmaSnAJ8BlgH7AEuqaqnF9ZNSdIoxjHP/Xer6vt969cAO6pqS5JruvW/HMPzaBE4t11q02IMy2wEtnXL24CLF+E5JElHsdDKvYD/SFLAP1bVVmBlVe3vtj8BrJztjkk2A5sBTjvttAV2Q9Jy8j/OnjwLDfc3VdW+JL8K3JXkW/0bq6q64H+B7o1gK8DMzMys+0iS5mdB4V5V+7q/B5J8DjgbeDLJqqran2QVcGAM/dQCHDmubmUltW/e4Z7kpcAvVdVz3fLvA38DbAc2AVu6v3eMo6MaH79Eldq3kMp9JfC5JIcf55+r6gtJvgbcmuQK4DHgkoV3U5I0inmHe1V9B3j9LO0/AM5bSKckTT4/AU42r+cuaUk4o2ZpefkBSWqQlbuksbJCnwxW7pLUICv3hlgxSTrMcG+UMxk0CYZ5HVqULA6HZSSpQVbukpacnywXn+E+hfwYK2kQw33KWQFJmo1j7pLUIMNdkhpkuEtSgwx3SWqQX6hOMGfFSJovw31KOCtGx4K5XucWN6NzWEaSGmTlLmniOUQ5OsN9wjj8Ih2dQT8ch2UkqUFW7kvIikPSUjHcJTXHQmoRwz3J+cBHgeOAT1TVlsV6rkk21xi6Y+vSeA3zb+1YCvpFCfckxwF/D7wF2At8Lcn2qnp4MZ5vuRyrLxppUlgkzW2xKvezgd1V9R2AJLcAG4Gxh/vRTu4wgTuuF4cvMmnyDfMjqbmKtiPve7Rt832OcUpVjf9Bk7cD51fVn3brlwO/XVVX9e2zGdjcrb4GeGTsHRmvU4HvL3cnxsRjmUwey2Sa5GP5tapaMduGZftCtaq2AluX6/lHlWRnVc0sdz/GwWOZTB7LZJrWY1msee77gLV962u6NknSEliscP8asD7J6Ul+GbgU2L5IzyVJOsKiDMtU1aEkVwH/Tm8q5I1V9dBiPNcSmpohpCF4LJPJY5lMU3ksi/KFqiRpeXltGUlqkOEuSQ0y3IeQ5PwkjyTZneSa5e7PKJKsTXJ3koeTPJTk6q79lCR3JXm0+3vycvd1GEmOS/KNJJ/v1k9Pcm93bj7TfYE/FZKclOS2JN9KsivJG6b4vPx59/p6MMnNSV40LecmyY1JDiR5sK9t1vOQno91x/RAkrOWr+dHZ7gP0HcphQuAM4DLkpyxvL0aySHgPVV1BnAOcGXX/2uAHVW1HtjRrU+Dq4FdfesfBK6rqlcDTwNXLEuv5uejwBeq6rXA6+kd19SdlySrgT8DZqrqN+lNoriU6Tk3nwTOP6JtrvNwAbC+u20Grl+iPo7McB/s55dSqKqfAIcvpTAVqmp/VX29W36OXoCspncM27rdtgEXL08Ph5dkDXAR8IluPcCbgdu6XabiOACSvBz4HeAGgKr6SVU9wxSel87xwIuTHA+8BNjPlJybqroHeOqI5rnOw0bgpur5CnBSklVL09PRGO6DrQYe71vf27VNnSTrgDOBe4GVVbW/2/QEsHKZujWKvwP+AvhZt/4K4JmqOtStT9O5OR04CPxTN8z0iSQvZQrPS1XtAz4EfI9eqD8L3Mf0nhuY+zxMTR4Y7seIJC8DPgu8u6p+2L+tevNhJ3pObJI/AA5U1X3L3ZcxOR44C7i+qs4E/ocjhmCm4bwAdOPRG+m9Yb0SeCkvHOaYWtNyHo5kuA829ZdSSHICvWD/dFXd3jU/efjjZPf3wHL1b0hvBP4wyR56Q2NvpjdmfVI3FADTdW72Anur6t5u/TZ6YT9t5wXg94DvVtXBqvopcDu98zWt5wbmPg9TkweG+2BTfSmFblz6BmBXVX2kb9N2YFO3vAm4Y6n7Noqqem9VramqdfTOwZeq6k+Au4G3d7tN/HEcVlVPAI8neU3XdB69S2JP1XnpfA84J8lLutfb4WOZynPTmes8bAfe0c2aOQd4tm/4ZrJUlbcBN+BC4L+AbwN/tdz9GbHvb6L3kfIB4P7udiG98eodwKPAF4FTlruvIxzTucDnu+VfB74K7Ab+BThxufs3wnFsAHZ25+ZfgZOn9bwAfw18C3gQ+BRw4rScG+Bmet8V/JTeJ6or5joPQOjNnvs28E16M4SW/Rhmu3n5AUlqkMMyktQgw12SGmS4S1KDDHdJapDhLkkNMtwlqUGGuyQ16P8AnhKV2XsZCGQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "samples = np.random.normal(50,15,10000)\n",
    "plt.hist(samples,100);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly you can sample from an exponential distribution by specifying the scale parameter (inverse of the rate parameter). I choose `scale = 10` here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "scrolled": true
   },
   "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": [
    "samples = np.random.exponential(10,10000)\n",
    "plt.hist(samples,100);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's move on to [tutorial 5](https://github.com/tobiashofmann88/python_for_biologists/blob/master/tutorials/tutorial_5.ipynb)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}