0101_GettingStartedWithPython.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Getting Started With Python\n",
    "\n",
    "## Installation\n",
    "\n",
    "There are various ways to install Python. Assuming the reader is not (yet) well versed in programming, I suggest to download the Anaconda distribution, which works for all major operating systems (Mac OS X, Windows, Linux) and provides a fully fledged Python installation including necessary libraries and Jupyter notebooks. \n",
    "\n",
    "* Go to https://www.anaconda.com/distribution/#download-section\n",
    "* Download latest version corresponding to your OS\n",
    "* Run .exe/.pkg file. \n",
    "  - Make sure to set flag \"Add Anaconda to my PATH environment variable\" and \n",
    "  - \"Register Anaconda as my default Python 3.x\"\n",
    "\n",
    "Be sure to download the latest Python 3.x version (not 2.x; this older Python version should by now no longer be a topic and backward compability is anyway no longer given!). \n",
    "\n",
    "The installation should not cause any problems. If you wisch a step-by-step guide (incl. some further insights) see [Cyrille Rossants excellent notebook](http://nbviewer.jupyter.org/github/ipython-books/minibook-2nd-code/blob/master/chapter1/12-installation.ipynb) or simply the [Jupyter Documentation](https://jupyter.org/documentation) on the topic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IPyton / Jupyter Notebooks\n",
    "\n",
    "What you see here is a so called Jupyter notebook. It makes it possible to interactively combine code with output (results, graphics), markdown text and LaTeX (for mathematical expressions). All codes discussed in this course will be provided through such notebooks and you soon will understand and appreciate the functionality they provide.\n",
    "\n",
    "* The basic markdown commands are well summarized [here](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Working%20With%20Markdown%20Cells.html). \n",
    "* LaTeX is a typesetting language with extensive capabilities to typeset math. For a basic introductin to math in LaTeX see sections 3.3 - 3.4 (p. 22 - 33) of *More Math into LaTeX* by Grätzer (2007), [available as pdf here](http://static.latexstudio.net/wp-content/uploads/2014/09/math.into_.Latex_.4ed.pdf). Also very insightful are the video tutorials by Dr. Trefor Bazett on YouTube, see e.g. [here](https://www.youtube.com/watch?v=Jp0lPj2-DQA&ab_channel=Dr.TreforBazett).\n",
    "\n",
    "If you are keen on learning more about IPython/Jupyter, consider [this notebook](http://nbviewer.jupyter.org/github/ipython-books/minibook-2nd-code/blob/master/chapter1/13-nbui.ipynb) - a well written introduction by Cyrille Rossant. A more comprehensive intro can be found [here](https://www.youtube.com/watch?v=1A7tea9LSEk&ab_channel=Influxity) and a short video-intro is provided below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/jZ952vChhuI\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "            \n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x10db1eb71f0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "from datetime import timedelta\n",
    "\n",
    "YouTubeVideo('jZ952vChhuI')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Types in Python\n",
    "\n",
    "### Building Blocks\n",
    "\n",
    "To analyze data in Python, data has to be stored as some kind of data type. These data types form the structure of the data and make data easily accessible. Python's basic building blocks are:\n",
    "* Numbers (integer, floating point, and complex)\n",
    "* Booleans (true/false)\n",
    "* Strings\n",
    "* Lists\n",
    "* Dictionaries\n",
    "* Tuples\n",
    "\n",
    "We will discuss the first four data types above as these are relevant for us.\n",
    "\n",
    "Python is a dynamically typed language, meaning that - unlike in static languages such as VBA, C, Java etc. - you do not explicitly need to assign a data type to a variable. Python will do that for you. A few examples will explain this best: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a:  42\n",
      "b:  <class 'float'>\n",
      "c:  <class 'str'>\n",
      "d:  <class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a = 42       # In VBA you would first have to define data type, only then the value: Dim a as integer; a = 42\n",
    "b = 10.3     # VBA: Dim b as Double; b = 10.3\n",
    "c = 'hello'  # VBA: Dim c as String; c = \"hello\"\n",
    "d = True     # VBA: Dim d as Boolean; d = True\n",
    "\n",
    "print('a: ', (a))\n",
    "print('b: ', type(b))\n",
    "print('c: ', type(c))\n",
    "print('d: ', type(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Running Code in Jupyter\n",
    "\n",
    "How did I execute this code section? If I only want to run a code cell, I select the cell and hit `ctrl + enter`. If you wish to run the entire notebook, go to Kernel (dropdown menu) and select \"Restart & Run All\". There are lots of shortcuts that let you handle a Jupyter notebook just from the keyboard. Press `H` on your keyboard (or go to Help/Keyboard Shortcuts) to see all of the shortcuts. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Arithmetics\n",
    "Simple arithmetic operations are straight forward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " a = -2 \n",
      " b = 12.0 \n",
      " c = 1.4142135623730951 \n",
      " d = 1 \n",
      " e = 3\n"
     ]
    }
   ],
   "source": [
    "a = 2 + 4 - 8      # Addition & Subtraction\n",
    "b = 6 * 7 / 3 - 2  # Multiplication & Division\n",
    "c = 2**(1/2)       # Exponents & Square root\n",
    "d = 10 % 3         # Modulus\n",
    "e = 10 // 3        # Floor division\n",
    "\n",
    "print(' a =', a, '\\n',\n",
    "      'b =', b, '\\n',\n",
    "      'c =', c, '\\n',\n",
    "      'd =', d, '\\n',\n",
    "      'e =', e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can even use arithmetic operators to concatenate strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "HelloHelloHello\n"
     ]
    }
   ],
   "source": [
    "a = 'Hello'\n",
    "b = 'World!'\n",
    "print(a + ' ' + b)\n",
    "\n",
    "print(a * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "Now let's look at lists. Lists are capable of combining multiple data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e:  <class 'list'>\n",
      "[<class 'str'>, <class 'str'>, <class 'str'>, <class 'float'>, <class 'int'>]\n"
     ]
    }
   ],
   "source": [
    "e = ['Calynn', 'Dillon', '10.3', c, d]\n",
    "print('e: ', type(e))\n",
    "print([type(item) for item in e])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the third element in list `e` is set in quotation marks and thus Python interprets this as string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy Arrays\n",
    "\n",
    "### NumPy Arrays from Lists\n",
    "\n",
    "For as useful list appear, its flexibility come at a high cost. Because each element contains not only the value itself but also information about the data type, storing data in list consumes a lot of memory. For this reason the Python community introduced NumPy (short for Numerical Python). Among other things, this package provides **fixed-type arrays** which are more efficient to store and operate on dense data than simple lists. \n",
    "\n",
    "Fixed-type arrays are dense arrays of uniform type. Uniform here means that all entries of the array have the same data type, e.g. all are floating point numbers. We start by importing the NumPy package (following general convention we import this package under the alias name `np`) and create some simple NumPy arrays form Python lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 18, 12])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Integer array\n",
    "np.array([3, 18, 12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3., 18., 12.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Floating point array\n",
    "np.array([3., 18, 12])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, we can explicitly set the data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3., 18., 12.], dtype=float32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([3, 18, 12], dtype='float32') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [2, 3, 4],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multidimensional arrays\n",
    "np.array([range(i, i + 3) for i in [1, 2, 3]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've seen above that we can define the data type for NumPy arrays. A list of available data types can be found in the [NumPy documentation](https://docs.scipy.org/doc/numpy/user/basics.types.html).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Arrays from Scratch\n",
    "Sometimes it is helpful to create arrays from scratch. Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer array with 8 zeros \n",
    "np.zeros(shape=8, dtype='int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.]], dtype=float32)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2x3 floating-point array filled with 1s\n",
    "np.ones((2, 3), 'float32')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that I do not need to use `np.ones(shape=(2, 3), dtype='float32')` to define the shape. It's ok to go with the short version as long as the order is correct, Python will understand. However, going with the explicit version helps to make your code more readable and I encourage students to follow this advice.\n",
    "\n",
    "Each predefined function is documented in a help page. One can search for it by calling `?np.ones`, `np.ones?` or `help(np.ones)`. If it is not clear how the function is precisely called, it is best to use * (wildcard character) - as in `np.*ne*?`. This will list all functions in the NumPy library which contain 'ne' in their name. In our example `np.ones?` shows the following details:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.one?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function description also shows examples of how the function can be used. Often this is very helpful, but for the sake of brevity, these are omitted here.\n",
    "\n",
    "In the function description we see that the order of arguments is `shape, dtype, order`. If our inputs are in this order, one does not need to specify the argument. Furthermore, we see that `dtype` and `order` is optional, meaning that if left undefined, Python will simply use the default argument. This makes for a very short code. However, going with the longer explicit version helps to make your code more readable and I encourage students to follow this advice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.71, 2.71],\n",
       "       [2.71, 2.71],\n",
       "       [2.71, 2.71]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3x2 array filled with 2.71\n",
    "np.full(shape=(3, 2), fill_value=2.71)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True],\n",
       "       [ True,  True]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3x3 boolean array filled with 'True'\n",
    "np.full((2, 2), 1, bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array filled with linear sequence\n",
    "np.arange(start = 0, stop = 1, step = 0.1)  # or simply np.arrange(0, 1, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.33333333, 0.66666667, 1.        ])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Array of evenly spaced values\n",
    "np.linspace(start = 0, stop = 1, num = 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays with random variables are easily created. Below three examples. See the [numpy.random documentation page](https://docs.scipy.org/doc/numpy/reference/routines.random.html) for details on how to generate other random variable-arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.72384969, 0.75558845, 0.43896765, 0.51796104],\n",
       "       [0.93973015, 0.95335858, 0.31814063, 0.4450227 ],\n",
       "       [0.63031166, 0.42601343, 0.99211742, 0.22967725],\n",
       "       [0.24568246, 0.85261188, 0.42802222, 0.77539716]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4x4 array of uniformly distributed random variables\n",
    "np.random.random_sample(size = (4, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.66821039,  8.48679449, 16.01873447],\n",
       "       [ 5.2082683 ,  8.5586136 ,  1.74618651],\n",
       "       [-6.30042556, -2.33825845,  5.27180312]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3x3 array of normally distributed random variables (with mean = 4, sd = 6)\n",
    "np.random.normal(loc = 4, scale = 6, size = (3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12,  3, 13],\n",
       "       [ 3,  1, 12],\n",
       "       [ 6,  8,  3]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3x3 array of random integers in interval [0, 15)\n",
    "np.random.randint(low = 0, high = 15, size = (3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4x4 identity matrix\n",
    "np.eye(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Array Attributes\n",
    "Each NumPy array has certain attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are some attributes we can call:\n",
    "\n",
    "| Attribute | Description            |\n",
    "|-----------|------------------------|\n",
    "| `ndim`    | No. of dimensions      |\n",
    "| `shape`   | Size of each dimension |\n",
    "| `size`    | Total size of array    |\n",
    "| `dtype`   | Data type of array     |\n",
    "| `itemsize` | Size (in bytes)       |\n",
    "| `nbytes`   | Total size (in bytes) |\n",
    "\n",
    "To show how one can access them we'll define three arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(1234)  # Set seed for reproducibility\n",
    "\n",
    "x = np.random.randint(10, size = 6)          # 1-dimensional array (vector)\n",
    "y = np.random.randint(10, size = (3, 4))     # 2-dimensional array (matrix)\n",
    "z = np.random.randint(10, size = (3, 4, 5))  # 3-dimensional array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A brief note regarding the setting of the seed: Numpy suggests a new way of setting the seed. Details see [here](https://towardsdatascience.com/stop-using-numpy-random-seed-581a9972805f). This is what is suggested moving forward: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.77395605, 0.43887844, 0.85859792],\n",
       "       [0.69736803, 0.09417735, 0.97562235],\n",
       "       [0.7611397 , 0.78606431, 0.12811363]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rng = np.random.default_rng(seed=42)\n",
    "rng.random(size=(3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's how we call for these properties:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  [3 6 5 4 8 9] \n",
      "\n",
      " [[1 7 9 6]\n",
      " [8 0 5 0]\n",
      " [9 6 2 0]] \n",
      "\n",
      " [[[5 2 6 3 7]\n",
      "  [0 9 0 3 2]\n",
      "  [3 1 3 1 3]\n",
      "  [7 1 7 4 0]]\n",
      "\n",
      " [[5 1 5 9 9]\n",
      "  [4 0 9 8 8]\n",
      "  [6 8 6 3 1]\n",
      "  [2 5 2 5 6]]\n",
      "\n",
      " [[7 4 3 5 6]\n",
      "  [4 6 2 4 2]\n",
      "  [7 9 7 7 2]\n",
      "  [9 7 4 9 0]]]\n"
     ]
    }
   ],
   "source": [
    "print(' ', x, '\\n\\n', y, '\\n\\n', z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ndim:       3\n",
      "shape:      (3, 4, 5)\n",
      "size:       60\n",
      "data type:  int32\n",
      "itemsize:   4\n",
      "nbytes:     240\n"
     ]
    }
   ],
   "source": [
    "print('ndim:      ', z.ndim)\n",
    "print('shape:     ', z.shape)\n",
    "print('size:      ', z.size)\n",
    "print('data type: ', z.dtype)\n",
    "print('itemsize:  ', z.itemsize)\n",
    "print('nbytes:    ', z.nbytes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index: How to Access Elements\n",
    "What might be a bit counterintuitive at the beginning is that **Python's indexing starts at 0**. Other than that, accessing the $i$'th element (starting at 0) of a list or a array is straight forward.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Calynn', 'Dillon', '10.3', 1.4142135623730951, 1] \n",
      "\n",
      "[3 6 5 4 8 9] \n",
      "\n",
      "[[1 7 9 6]\n",
      " [8 0 5 0]\n",
      " [9 6 2 0]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(e, '\\n')  # List from above\n",
    "print(x, '\\n')  # One dimensional np array from above\n",
    "print(y, '\\n')  # Two dimensional np array from above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10.3'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10.310.3'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e[2] * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[2, 0]  # Note again that [m, n] starts counting for both rows (m) as well as columns (n) from 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To access the end of an array, you can also use negative indices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[-2, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays are also possible as inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 9, 5])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = [3, 5, -4]\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ 4, 11])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(12).reshape((3, 4))\n",
    "print(x)\n",
    "row = np.array([1, 2])\n",
    "col = np.array([0, 3])\n",
    "x[row, col]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Knowing the index we can also replace elements of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[99, 99, 99, 99],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0] = 99\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT NOTE:**\n",
    "\n",
    "**NumPy arrays have a fixed type. This means that e.g. if you insert a floating-point value to an integer array, the value will be truncated!**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  3,  3,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0] = 3.14159; x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Slicing\n",
    "We can also use square brackets to access a subset of the data. The syntax is:\n",
    "\n",
    "`x[start:stop:step]`\n",
    "\n",
    "The default values are: `start=0`, `stop='size of dimension'`, `step=1` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:3]  # First three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[7:]  # Elements AFTER 7th element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6, 7])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[4:8]  # Element 5, 6, 7 and 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::2]  # Even elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1::2]  # Odd elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::-1]  # All elements reversed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 7, 5, 3, 1])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[::-2]  # Odd elements reversed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Array slicing works the same for multidimensional arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 7, 9, 6],\n",
       "       [8, 0, 5, 0],\n",
       "       [9, 6, 2, 0]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y  # from above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 7, 9],\n",
       "       [8, 0, 5]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[:2, :3]  # Rows 0 and 1, columns 0, 1, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 5, 2])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[:, 2]  # Third column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 7, 9, 6])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[0, :]  # First row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**IMPORTANT NOTE:**\n",
    "\n",
    "**When slicing and assigning part of an existing array to a new variable, the new variable will only hold a \"view\" but not a copy. This means, that if you change a value in the new array, the original array will also be changed. The idea behind this is to save memory. But fear not: with the \".copy()\" method, you still can get a true copy.**\n",
    "\n",
    "Here a few corresponding examples for better understanding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 7]\n",
      " [8 0]]\n"
     ]
    }
   ],
   "source": [
    "ySub = y[:2, :2]\n",
    "print(ySub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[99  7]\n",
      " [ 8  0]] \n",
      "\n",
      "[[99  7  9  6]\n",
      " [ 8  0  5  0]\n",
      " [ 9  6  2  0]]\n"
     ]
    }
   ],
   "source": [
    "ySub[0, 0] = 99\n",
    "print(ySub, '\\n')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[33  7]\n",
      " [ 8  0]] \n",
      "\n",
      "[[99  7  9  6]\n",
      " [ 8  0  5  0]\n",
      " [ 9  6  2  0]]\n"
     ]
    }
   ],
   "source": [
    "ySubCopy = y[:2, :2].copy()\n",
    "ySubCopy[0, 0] = 33\n",
    "print(ySubCopy, '\\n')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenating, Stacking and Splitting\n",
    "Often it is useful to combine multiple arrays into one or to split a single array into multiple arrays. To accomplish this, we can use NumPy's `concatenate` and `vstack`/`hstack` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, 11, 12, 13, 21, 22, 23])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "y = np.array([11, 12, 13])\n",
    "z = np.array([21, 22, 23])\n",
    "np.concatenate([x, y, z])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, 11, 12, 13])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Stack two vectors horizontally\n",
    "np.hstack([x, y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [11, 12, 13]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Stack two vectors vertically\n",
    "np.vstack([x, y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [21, 22, 23]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Stack matrix with column vector\n",
    "m = np.arange(0, 9, 1).reshape((3, 3))\n",
    "np.vstack([m, z])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2, 21],\n",
       "       [ 3,  4,  5, 22],\n",
       "       [ 6,  7,  8, 23]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Stack matrix with row vector\n",
    "np.hstack([m, z.reshape(3, 1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The opposite of concatenating is splitting. Numpy has `np.split`, `np.hsplit` and `np.vsplit` functions. Each of these takes a list of indices, giving the split points, as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 2.] [3. 4.] [5. 6. 7.]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(8.0)\n",
    "a, b, c = np.split(x, [3, 5])\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]] \n",
      "\n",
      " [[12 13 14 15]]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(16).reshape(4, 4)\n",
    "upper, lower = np.vsplit(x, [3])\n",
    "print(upper, '\\n\\n', lower)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1]\n",
      " [ 4  5]\n",
      " [ 8  9]\n",
      " [12 13]] \n",
      "\n",
      " [[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]\n",
      " [14 15]]\n"
     ]
    }
   ],
   "source": [
    "left, right = np.hsplit(x, [2])\n",
    "print(left, '\\n\\n', right)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditions\n",
    "\n",
    "### Boolean Operators\n",
    "\n",
    "Boolean operators check an input and return either `True` (equals 1 as value) or `False` (equals 0). This is often very helpful if one wants to check for conditions or sort out part of a data set which meet a certain condition. Here are the common comparison operators:\n",
    "\n",
    "| **Operator** | **Description**            |\n",
    "|:------------:|----------------------------|\n",
    "| ==           | equal ($=$)                |\n",
    "| !=           | not equal ($\\neq$)         |\n",
    "| <            | less than ($<$)            |\n",
    "| <=           | less or equal ($\\leq$)     |\n",
    "| >            | greater ($>$)              |\n",
    "| >=           | greater or equal ($\\geq$)  |\n",
    "| &            | Mathematical AND ($\\land$) |\n",
    "| &#124;       | Mathematical OR ($\\lor$)   |\n",
    "| `in`         | element of ($\\in$)         |\n",
    "\n",
    "The following sections give a glimpse of how these operators can be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7]\n",
      "[False False  True False False False False False]\n",
      "[ True  True  True False  True  True  True  True]\n",
      "[ True  True False False False False False  True]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(start=0, stop=8, step=1)\n",
    "print(x)\n",
    "print(x == 2)\n",
    "print(x != 3)\n",
    "print((x < 2) | (x > 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n",
      "[ True  True  True  True  True False False False]\n"
     ]
    }
   ],
   "source": [
    "# Notice the difference\n",
    "print(x[x <= 4])\n",
    "print(x <= 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### If ... else statements\n",
    "\n",
    "These statements check a given condition and depending on the result (`True`, `False`) execute a subsequent code. As usual, an example will do. Notice that indentation is necessary for Python to correctly compile the code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 is an even number\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "\n",
    "if x%2 == 0:\n",
    "    print(x, 'is an even number')\n",
    "else:\n",
    "    print(x, 'is an odd number')\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to have more than one condition as the next example shows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 is positive\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "\n",
    "if x > 0:\n",
    "    print(x, 'is positive')\n",
    "elif x < 0:\n",
    "    print(x, 'is negative')\n",
    "else:\n",
    "    print(x, 'is neither strictly positive nor strictly negative')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combining these two statements would make for a nested if ... else statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3 is negative and odd\n"
     ]
    }
   ],
   "source": [
    "x = -3\n",
    "if x > 0:\n",
    "    if (x%2) == 0:\n",
    "        print(x, 'is positive and even')\n",
    "    else:\n",
    "        print(x, 'is positive and odd')\n",
    "elif x < 0:\n",
    "    if (x%2) == 0:\n",
    "        print(x, 'is negative and even')\n",
    "    else:\n",
    "        print(x, 'is negative and odd')\n",
    "else:\n",
    "    print(x, 'is 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "#### \"For\" Loops\n",
    "\n",
    "\"For\" loops iterate over a given sequence. They are very easy to implement as the following example shows. We start with an example and give some explanations afterwards. \n",
    "\n",
    "For our example, let's assume you ought to sum up the integer values of a sequence from 10 to 1 with a loop. There are obviously more efficient ways of doing this but this serves well as an introductory example. From primary school we know the result is easily calculated as\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "    \\sum_{i=1}^n x_i = \\dfrac{n (n+1)}{2} \\qquad -> \\qquad \\dfrac{10 \\cdot 11}{2} = 55\n",
    "\\end{equation}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  9,  8,  7,  6,  5,  4,  3,  2,  1])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq = np.arange(start=10, stop=0, step=-1)\n",
    "seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seqSum = 0\n",
    "\n",
    "for value in seq:\n",
    "    seqSum = seqSum + value\n",
    "\n",
    "seqSum\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A few imprtant notes:\n",
    "* Indentation is not just here for better readability of the code but it is actually necessary for Python to correctly interpret the code.\n",
    "* Though it is not necessary, we initiate `seqSum = 0` here. Otherwise, if we run the code repeatedly we add to the previous total!\n",
    "* `value` takes on every value in array `seq`. In the first loop `value=10`, second loop `value=9`, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops can be nested, too. Here's an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  9,  8,  7,  6],\n",
       "       [ 5,  4,  3,  2,  1]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq = seq.reshape(2, 5)\n",
    "seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "seqSum = 0\n",
    "row = seq.shape[0]\n",
    "col = seq.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for rowIndex in range(0, row):\n",
    "    for colIndex in range(0, col):\n",
    "        seqSum = seqSum + seq[rowIndex, colIndex]\n",
    "        \n",
    "seqSum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### \"While\" Loops\n",
    "\n",
    "\"While\" loops execute as long as a certain boolean condition is met. Picking up the above example we can formulate the following loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "seqSum = 0\n",
    "i = 10\n",
    "while i >= 1:\n",
    "    seqSum = seqSum + i\n",
    "    i = i - 1  # Also: i -= 1\n",
    "    \n",
    "print(seqSum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "Functions come into play when either a task needs to be performed more than once or when it helps to reduce the complexity of a code. \n",
    "\n",
    "Following up on our play examples from above, let us assume we are tasked to write a function which sums up all even and all odd integers of a vector. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd:  2500 ,  Even:  2550\n"
     ]
    }
   ],
   "source": [
    "def sumOddEven(vector):\n",
    "    \"\"\"Calculates sum of odd and even numbers in array.\n",
    "    \n",
    "    Args:\n",
    "        vector: NumPy array of length n\n",
    "        \n",
    "    Returns:\n",
    "        odd: Sum of odd numbers\n",
    "        even: Sum of even numbers\n",
    "    \"\"\"\n",
    "    \n",
    "    # Initiate values\n",
    "    odd = 0\n",
    "    even = 0\n",
    "    \n",
    "    # Loop through values of array; check for each\n",
    "    # value whether it is odd or even and add to \n",
    "    # previous total.\n",
    "    for value in vector:\n",
    "        if (value % 2) == 0:\n",
    "            even = even + value\n",
    "        else:\n",
    "            odd = odd + value\n",
    "    \n",
    "    return odd, even\n",
    "\n",
    "# Initiate array [1, 2, ..., 99, 100]\n",
    "seq = np.arange(1, 101, 1)\n",
    "\n",
    "# Apply function and print results\n",
    "odd, even = sumOddEven(seq)\n",
    "print('Odd: ', odd, ', ', 'Even: ', even)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Commenting\n",
    "\n",
    "Above code snippet not only shows how functions are set up but also displays the importance of comments. Comments are preceeded by a hash sign (#), such that the interpreter will not parse what follows the hash.  When programming, you should always comment your code to notate your work. This details your steps/thoughts/ideas not only for other developers but also for you when you pick up your code some time after writing it. Good programmers make heavy use of commenting and I strongly encourage the reader to follow this standard. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slowness of Loops\n",
    "\n",
    "It is at this point important to note that loops should only be used as a last resort. Below we show why. The first code runs our previously defined function. The second code uses NumPy's built-in function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.42 ms ± 782 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "seq = np.arange(1,10001, 1)\n",
    "sumOddEven(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.9 µs ± 940 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "seq[(seq % 2) == 0].sum()\n",
    "seq[(seq % 2) == 1].sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above timing results show what was hinted before: In 9'999 out of a 10'000 cases it is significantly faster using already built in functions compared to loops. The simple reason is that modules such as NumPy or Pandas use (at their core) optimized compile code to calculate the results and this is most certainly faster than a loop. \n",
    "\n",
    "So in summary: Above examples helped introduce if statements, loops and functions. In real life, however, you should check if Python does not already offer a built-in function for your task. If yes, make sure to use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "### Computations on Arrays\n",
    "\n",
    "In closing this chapter we briefly introduce NumPy's broadcasting functionality. Rules for matrix arithmetic apply to NumPy arrays as one would expect and it is left to the reader to explore it. Broadcasting, however, goes one step further in that it allows for element-by-element operations on arrays (and matrices) of different dimensions - which under normal rules would not be compatible. An example shows this best."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 3., 4.],\n",
       "       [2., 3., 4.],\n",
       "       [2., 3., 4.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.ones(shape=(3, 3))\n",
    "v = np.array([1, 2, 3])\n",
    "M + v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6] \n",
      "\n",
      "[[2 3 4]\n",
      " [3 4 5]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Notice the difference\n",
    "vecAdd = v + v\n",
    "broadAdd = v.reshape((3, 1)) + v\n",
    "\n",
    "print(vecAdd, '\\n')\n",
    "print(broadAdd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Resources\n",
    "\n",
    "The following ressources, which were consulted to write this notebook, are recommended to better acquaint yourself with Python and NumPy:\n",
    "\n",
    "* Vanderplas, Jake, 2016, *Python Data Science Handbook* (O'Reilly Media, Sebastopol, CA).\n",
    "* Sheppard, Kevin, 2017, Introduction to Python for Econometrics, Statistics and Data Analysis from Website https://www.kevinsheppard.com/images/b/b3/Python_introduction-2016.pdf, 07/07/2017.\n",
    "* Paarsch, Harry J., and Golyaev, Konstantin, 2016, *A Gentle Introduction to Effective Computing in Quantitative Research: What Every Research Assistant Should Know*, MIT Press, Cambridge, MA."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}