src/main/ipynb/intro-python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ipub": {
     "ignore": true
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": false
   },
   "source": [
    "# Overview of Python\n",
    "\n",
    "(c) 2019 [Steve Phelps](mailto:sphelps@sphelps.net) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python is interpreted\n",
    "\n",
    "- Python is an _interpreted_ language, in contrast to Java and C which are compiled languages.\n",
    "\n",
    "- This means we can type statements into the interpreter and they are executed immediately.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Groups of statements are all executed one after the other:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "y = 'Hello There'\n",
    "z = 10.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can visualize the above code using [PythonTutor](http://pythontutor.com/visualize.html#code=x%20%3D%205%0Ay%20%3D%20'Hello%20There'%0Az%20%3D%2010.5&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assignments versus equations\n",
    "\n",
    "- In Python when we write `x = 5` this means something different from an equation $x=5$.\n",
    "\n",
    "- Unlike variables in mathematical models, variables in Python can refer to different things as more statements are interpreted.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of x is 1\n",
      "Now the value of x is 2.5\n",
      "Now it is  hello there\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "print('The value of x is', x)\n",
    "\n",
    "x = 2.5\n",
    "print('Now the value of x is', x)\n",
    "\n",
    "x = 'hello there'\n",
    "print('Now it is ', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Calling Functions\n",
    "\n",
    "We can call functions in a conventional way using round brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types\n",
    "\n",
    "- Values in Python have an associated _type_.\n",
    "\n",
    "- If we combine types incorrectly we get an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello There\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-b85a2dbb3f6a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "y + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The type function\n",
    "\n",
    "- We can query the type of a value using the `type` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Null values\n",
    "\n",
    "- Sometimes we represent \"no data\" or \"not applicable\".  \n",
    "\n",
    "- In Python we use the special value `None`.\n",
    "\n",
    "- This corresponds to `Null` in Java or SQL.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- When we fetch the value `None` in the interactive interpreter, no result is printed out.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Testing for Null values\n",
    "\n",
    "- We can check whether there is a result or not using the `is` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "x is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Converting values between types\n",
    "\n",
    "- We can convert values between different types.\n",
    "\n",
    "### Converting to floating-point\n",
    "\n",
    "- To convert an integer to a floating-point number use the `float()` function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = float(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Converting to integers\n",
    "\n",
    "- To convert a floating-point to an integer use the `int()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables are not typed\n",
    "\n",
    "- _Variables_ themselves, on the other hand, do not have a fixed type.\n",
    "- It is only the values that they refer to that have a type.\n",
    "- This means that the type referred to by a variable can change as more statements are interpreted.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The type of the value referred to by y is  <class 'str'>\n",
      "And now the type of the value is  <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "y = 'hello'\n",
    "print('The type of the value referred to by y is ', type(y))\n",
    "y = 5.0\n",
    "print('And now the type of the value is ', type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": false
   },
   "source": [
    "## Polymorphism\n",
    "\n",
    "- The meaning of an operator depends on the types we are applying it to.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' + 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'11'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'1' + '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": false
   },
   "source": [
    "## Conditional Statements and Indentation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The syntax for control structures in Python uses _colons_ and _indentation_.\n",
    "\n",
    "- Beware that white-space affects the semantics of Python code.\n",
    "\n",
    "- Statements that are indented using the Tab key are grouped together."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is strictly positive.\n",
      "5\n",
      "finished.\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if x > 0:\n",
    "    print('x is strictly positive.')\n",
    "    print(x)\n",
    "    \n",
    "print('finished.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above on [PythonTutor](http://pythontutor.com/visualize.html#code=x%20%3D%205%0Aif%20x%20%3E%200%3A%0A%20%20%20%20print%28'x%20is%20strictly%20positive.'%29%0A%20%20%20%20print%28x%29%0A%20%20%20%20%0Aprint%28'finished.'%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing indentation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "finished.\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "if x > 0:\n",
    "    print('x is strictly positive.')\n",
    "print(x)\n",
    "    \n",
    "print('finished.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above on [PythonTutor](http://pythontutor.com/visualize.html#code=x%20%3D%200%0Aif%20x%20%3E%200%3A%0A%20%20%20%20print%28'x%20is%20strictly%20positive.'%29%0Aprint%28x%29%0A%20%20%20%20%0Aprint%28'finished.'%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `if` and `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting.\n",
      "x is zero.\n",
      "finished.\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "print('Starting.')\n",
    "if x > 0:\n",
    "    print('x is strictly positive.')\n",
    "else:\n",
    "    if x < 0:\n",
    "        print('x is strictly negative.')\n",
    "    else:\n",
    "        print('x is zero.')\n",
    "print('finished.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above on [PythonTutor](http://pythontutor.com/live.html#code=x%20%3D%200%0Aprint%28'Starting.'%29%0Aif%20x%20%3E%200%3A%0A%20%20%20%20print%28'x%20is%20strictly%20positive.'%29%0Aelse%3A%0A%20%20%20%20if%20x%20%3C%200%3A%0A%20%20%20%20%20%20%20%20print%28'x%20is%20strictly%20negative.'%29%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28'x%20is%20zero.'%29%0Aprint%28'finished.'%29&cumulative=false&curInstr=6&heapPrimitives=nevernest&mode=display&origin=opt-live.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `elif`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting.\n",
      "x is zero\n",
      "finished.\n"
     ]
    }
   ],
   "source": [
    "print('Starting.')\n",
    "if x > 0:\n",
    "    print('x is strictly positive')\n",
    "elif x < 0:\n",
    "    print('x is strictly negative')\n",
    "else:\n",
    "    print('x is zero')\n",
    "print('finished.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use _lists_ to hold an ordered sequence of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['first', 'second', 'third']\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can contain different types of variable, even in the same list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third', 1, 2, 3]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "another_list = ['first', 'second', 'third', 1, 2, 3]\n",
    "another_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Mutable Datastructures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are _mutable_; their contents can change as more statements are interpreted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third', 'fourth']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.append('fourth')\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## References\n",
    "\n",
    "- Whenever we bind a variable to a value in Python we create a *reference*.\n",
    "\n",
    "- A reference is distinct from the value that it refers to.\n",
    "\n",
    "- Variables are names for references.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "X = [1, 2, 3]\n",
    "Y = X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Side effects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The above code creates two different references (named `X` and `Y`) to the *same* value `[1, 2, 3]`\n",
    "\n",
    "- Because lists are mutable, changing them can have side-effects on other variables.\n",
    "\n",
    "- If we append something to `X` what will happen to `Y`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.append(4)\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above on [PythonTutor](http://pythontutor.com/visualize.html#code=X%20%3D%20%5B1,%202,%203%5D%0AY%20%3D%20X%0AX.append%284%29%0Aprint%28Y%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## State and identity\n",
    "\n",
    "- The state referred to by a variable is *different* from its identity.\n",
    "\n",
    "- To compare *state* use the `==` operator.\n",
    "\n",
    "- To compare *identity* use the `is` operator.\n",
    "\n",
    "- When we compare identity we check equality of references.\n",
    "\n",
    "- When we compare state we check equality of values.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example\n",
    "\n",
    "- We will create two *different* lists, with two associated variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "X = [1, 2]\n",
    "Y = [1]\n",
    "Y.append(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above code on [PythonTutor](http://pythontutor.com/visualize.html#code=X%20%3D%20%5B1,%202%5D%0AY%20%3D%20%5B1%5D%0AY.append%282%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X == Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing identity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X is Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copying data prevents side effects\n",
    "\n",
    "- In this example, because we have two different lists we avoid side effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.append(3)\n",
    "X\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X == Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X is Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## Iteration\n",
    "\n",
    "- We can iterate over each element of a list in turn using a `for` loop:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first\n",
      "second\n",
      "third\n",
      "fourth\n"
     ]
    }
   ],
   "source": [
    "my_list = ['first', 'second', 'third', 'fourth']\n",
    "for i in my_list:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above on [PythonTutor](http://pythontutor.com/visualize.html#code=my_list%20%3D%20%5B'first',%20'second',%20'third',%20'fourth'%5D%0Afor%20i%20in%20my_list%3A%0A%20%20%20%20print%28i%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Including more than one statement inside the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The next item is:\n",
      "first\n",
      "\n",
      "The next item is:\n",
      "second\n",
      "\n",
      "The next item is:\n",
      "third\n",
      "\n",
      "The next item is:\n",
      "fourth\n",
      "\n"
     ]
    }
   ],
   "source": [
    "my_list = ['first', 'second', 'third', 'fourth']\n",
    "for i in my_list:\n",
    "    print(\"The next item is:\")\n",
    "    print(i)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Visualize the above code on [PythonTutor](http://pythontutor.com/visualize.html#code=my_list%20%3D%20%5B'first',%20'second',%20'third',%20'fourth'%5D%0Afor%20i%20in%20my_list%3A%0A%20%20%20%20print%28%22The%20next%20item%20is%3A%22%29%0A%20%20%20%20print%28i%29%0A%20%20%20%20print%28%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Looping a specified number of times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- To perform a statement a certain number of times, we can iterate over a list of the required size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "Hello!\n",
      "Hello!\n",
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "for i in [0, 1, 2, 3]:\n",
    "    print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The `range` function\n",
    "\n",
    "- To save from having to manually write the numbers out, we can use the function `range()` to count for us.  \n",
    "\n",
    "- We count starting at 0 (as in Java and C++)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `for` loops with the `range` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "Hello!\n",
      "Hello!\n",
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    print(\"Hello!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Indexing\n",
    "\n",
    "- Lists can be indexed using square brackets to retrieve the element stored in a particular position.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third', 'fourth']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'first'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'second'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Slicing\n",
    "\n",
    "- We can also a specify a _range_ of positions.  \n",
    "\n",
    "- This is called _slicing_.\n",
    "\n",
    "- The example below indexes from position 0 (inclusive) to 2 (exclusive).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second']"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing from the start or end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If we leave out the starting index it implies the beginning of the list:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If we leave out the final index it implies the end of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['third', 'fourth']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Copying a list\n",
    "\n",
    "- We can conveniently copy a list by indexing from start to end:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = my_list[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third', 'fourth']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list is my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list == my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Negative Indexing\n",
    "\n",
    "- Negative indices count from the end of the list:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fourth'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['first', 'second', 'third']"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": false
   },
   "source": [
    "## Collections\n",
    "\n",
    "- Lists are an example of a *collection*.\n",
    "\n",
    "- A collection is a type of value that can contain other values.\n",
    "\n",
    "- There are other collection types in Python:\n",
    "\n",
    "    - `tuple`\n",
    "    - `set`\n",
    "    - `dict`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Tuples\n",
    "\n",
    "- Tuples are another way to combine different values.\n",
    "\n",
    "- The combined values can be of different types.\n",
    "\n",
    "- Like lists, they have a well-defined ordering and can be indexed.\n",
    "\n",
    "- To create a tuple in Python, use round brackets instead of square brackets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(50, 'hello')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 = (50, 'hello')\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tuple1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Tuples are immutable\n",
    "\n",
    "- Unlike lists, tuples are *immutable*.  Once we have created a tuple we cannot add values to it.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-46e3866e32ee>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtuple1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "tuple1.append(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sets\n",
    "\n",
    "- Lists can contain duplicate values.\n",
    "\n",
    "- A set, in contrast, contains no duplicates.\n",
    "\n",
    "- Sets can be created from lists using the `set()` function.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = set([1, 2, 3, 3, 4])\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Alternatively we can write a set literal using the `{` and `}` brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = {1, 2, 3, 4}\n",
    "type(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Sets are mutable\n",
    "\n",
    "- Sets are mutable like lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.add(5)\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Duplicates are automatically removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.add(5)\n",
    "X\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Sets are unordered\n",
    "\n",
    "- Sets do not have an ordering.\n",
    "\n",
    "- Therefore we cannot index or slice them:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-70-19c40ecbd036>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "X[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Operations on sets\n",
    "\n",
    "- Union: $X \\cup Y$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = {1, 2, 3}\n",
    "Y = {4, 5, 6}\n",
    "X | Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Intersection: $X \\cap Y$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = {1, 2, 3, 4}\n",
    "Y = {3, 4, 5}\n",
    "X & Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Difference $X - Y$:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X - Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Dictionaries\n",
    "\n",
    "- A dictionary contains a mapping between *keys*, and corresponding *values*.\n",
    "    \n",
    "    - Mathematically it is a one-to-one function with a finite domain and range.\n",
    "    \n",
    "- Given a key, we can very quickly look up the corresponding value.\n",
    "\n",
    "- The values can be any type (and need not all be of the same type).\n",
    "\n",
    "- Keys can be any immutable (hashable) type.\n",
    "\n",
    "- They are abbreviated by the keyword `dict`.\n",
    "\n",
    "- In other programming languages they are sometimes called *associative arrays*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Creating a dictionary\n",
    "\n",
    "- A dictionary contains a set of key-value pairs.\n",
    "\n",
    "- To create a dictionary:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = { 107564: 'Xu', 108745: 'Ian', 102567: 'Steve' }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The above initialises the dictionary students so that it contains three key-value pairs.\n",
    "\n",
    "- The keys are the student id numbers (integers).\n",
    "\n",
    "- The values are the names of the students (strings).\n",
    "\n",
    "- Although we use the same brackets as for sets, this is a different type of collection:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Accessing the values in a dictionary\n",
    "\n",
    "- We can access the value corresponding to a given key using the same syntax to access particular elements of a list: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ian'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students[108745]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Accessing a non-existent key will generate a `KeyError`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "123",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-77-26e887eb0296>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mstudents\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m123\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 123"
     ]
    }
   ],
   "source": [
    "students[123]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Updating dictionary entries\n",
    "\n",
    "- Dictionaries are mutable, so we can update the mapping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fred\n"
     ]
    }
   ],
   "source": [
    "students[108745] = 'Fred'\n",
    "print(students[108745])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also grow the dictionary by adding new keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n"
     ]
    }
   ],
   "source": [
    "students[104587] = 'John'\n",
    "print(students[104587])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Dictionary keys can be any immutable type\n",
    "\n",
    "- We can use any immutable type for the keys of a dictionary\n",
    "\n",
    "- For example, we can map names onto integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = { 'John':21, 'Steve':47, 'Xu': 22 }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "47"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age['Steve']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Creating an empty dictionary\n",
    "\n",
    "- We often want to initialise a dictionary with no keys or values.\n",
    "\n",
    "- To do this call the function `dict()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- We can then progressively add entries to the dictionary, e.g. using iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    result[i] = i**2\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Iterating over a dictionary\n",
    "\n",
    "- We can use a for loop with dictionaries, just as we can with other collections such as sets.\n",
    "- When we iterate over a dictionary, we iterate over the *keys*.\n",
    "- We can then perform some computation on each key inside the loop.\n",
    "- Typically we will also access the corresponding value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Xu\n",
      "Fred\n",
      "Steve\n",
      "John\n"
     ]
    }
   ],
   "source": [
    "for id in students:\n",
    "    print(students[id])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The size of a collection\n",
    "\n",
    "- We can count the number of values in a collection using the `len` (length) function.\n",
    "\n",
    "- This can be used with any type of collection (list, set, tuple etc.).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(['one', 'two'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len({'one', 'two', 'three'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Empty collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Empty collections have a size of zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_list = []\n",
    "len(empty_list) == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Arrays\n",
    "\n",
    "- Python also has arrays which contain a *single* type of value.\n",
    "\n",
    "- i.e. we *cannot* have different types of value within the same array.   \n",
    "\n",
    "- Arrays are mutable like lists; we can modify the existing elements of an array.\n",
    "\n",
    "- However, we typically do not change the size of the array; i.e. it has a fixed length."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc-hr-collapsed": true,
    "toc-nb-collapsed": true
   },
   "source": [
    "## The `numpy` module\n",
    "\n",
    "- Arrays are provided by a separate _module_ called numpy.  Modules correspond to packages in e.g. Java.\n",
    "\n",
    "- We can import the module and then give it a shorter _alias_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can now use the functions defined in this package by prefixing them with `np`.  \n",
    "\n",
    "- The function `array()` creates an array given a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Creating an array\n",
    "\n",
    "- We can create an array from a list by using the `array()` function defined in the `numpy` module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([0, 1, 2, 3, 4])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Functions over arrays\n",
    "\n",
    "- When we use arithmetic operators on arrays, we create a new array with the result of applying the operator to each element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = x * 2\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The same goes for functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([-1, 2, 3, -4])\n",
    "y = abs(x)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Populating Arrays\n",
    "\n",
    "- To populate an array with a range of values we use the `np.arange()` function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(0, 10)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also use floating point increments.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "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": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(0, 1, 0.1)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Basic Plotting\n",
    "\n",
    "- We will use a module called `matplotlib` to plot some simple graphs.\n",
    "\n",
    "- This module provides functions which are very similar to MATLAB plotting commands.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "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": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "y = x*2 + 5\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Plotting a sine curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "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": [
    "from numpy import pi, sin\n",
    "\n",
    "x = np.arange(0, 2*pi, 0.01)\n",
    "y = sin(x)\n",
    "plt.plot(x, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Plotting a histogram\n",
    "\n",
    "- We can use the `hist()` function in `matplotlib` to plot a histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "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": [
    "# Generate some random data\n",
    "data = np.random.randn(1000)\n",
    "\n",
    "ax = plt.hist(data)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Computing histograms as matrices\n",
    "\n",
    "- The function `histogram()` in the `numpy` module will count frequencies into bins and return the result as a 2-dimensional array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 14,  41, 128, 178, 243, 203, 109,  66,  14,   4]),\n",
       " array([-2.81515826, -2.19564948, -1.57614071, -0.95663193, -0.33712315,\n",
       "         0.28238562,  0.9018944 ,  1.52140318,  2.14091195,  2.76042073,\n",
       "         3.3799295 ]))"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.histogram(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defining new functions\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def squared(x):\n",
    "    return x ** 2\n",
    "\n",
    "squared(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Local Variables\n",
    "\n",
    "- Variables created inside functions are _local_ to that function.\n",
    "\n",
    "- They are not accessable to code outside of that function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def squared(x):\n",
    "    temp = x ** 2\n",
    "    return temp\n",
    "\n",
    "squared(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'temp' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-102-da77557ed0c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtemp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'temp' is not defined"
     ]
    }
   ],
   "source": [
    "temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functional Programming\n",
    "\n",
    "- Functions are first-class citizens in Python.\n",
    "\n",
    "- They can be passed around just like any other value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.squared(x)>"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.squared(x)>"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = squared\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mapping the elements of a collection\n",
    "\n",
    "- We can apply a function to each element of a collection using the built-in function `map()`.\n",
    "\n",
    "- This will work with any collection: list, set, tuple or string.\n",
    "\n",
    "- This will take as an argument _another function_, and the list we want to apply it to.\n",
    "\n",
    "- It will return the results of applying the function, as a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(squared, [1, 2, 3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List Comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Because this is such a common operation, Python has a special syntax to do the same thing, called a _list comprehension_.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[squared(i) for i in [1, 2, 3, 4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If we want a set instead of a list we can use a set comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 9, 16}"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{squared(i) for i in [1, 2, 3, 4]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Cartesian product using list comprehensions\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figs/220px-Cartesian_Product_qtl1.svg.png\"> <sup>image courtesy of [Quartl](https://commons.wikimedia.org/wiki/User:Quartl)</sup>\n",
    "\n",
    "The [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of two collections $X = A \\times B$ can be expressed by using multiple `for` statements in a comprehension.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('x', 1),\n",
       " ('x', 2),\n",
       " ('x', 3),\n",
       " ('y', 1),\n",
       " ('y', 2),\n",
       " ('y', 3),\n",
       " ('z', 1),\n",
       " ('z', 2),\n",
       " ('z', 3)}"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {'x', 'y', 'z'}\n",
    "B = {1, 2, 3}\n",
    "{(a,b) for a in A for b in B}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Cartesian products with other collections\n",
    "\n",
    "- The syntax for Cartesian products can be used with any collection type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Steve', 'Smith'),\n",
       " ('Steve', 'Doe'),\n",
       " ('Steve', 'Rabbit'),\n",
       " ('John', 'Smith'),\n",
       " ('John', 'Doe'),\n",
       " ('John', 'Rabbit'),\n",
       " ('Peter', 'Smith'),\n",
       " ('Peter', 'Doe'),\n",
       " ('Peter', 'Rabbit')]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_names = ('Steve', 'John', 'Peter')\n",
    "surnames = ('Smith', 'Doe', 'Rabbit')\n",
    "\n",
    "[(first_name, surname) for first_name in first_names for surname in surnames]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Joining collections using a zip\n",
    "\n",
    "- The Cartesian product pairs every combination of elements.\n",
    "\n",
    "- If we want a 1-1 pairing we use an operation called a zip.\n",
    "\n",
    "- A zip pairs values at the same position in each sequence.\n",
    "\n",
    "- Therefore:\n",
    "    - it can only be used with sequences (not sets); and\n",
    "    - both collections must be of the same length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Steve', 'Smith'), ('John', 'Doe'), ('Peter', 'Rabbit')]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(first_names, surnames))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Anonymous Function Literals\n",
    "\n",
    "- We can also write _anonymous_ functions.\n",
    "- These are function literals, and do not necessarily have a name.\n",
    "- They are called _lambda expressions_ (after the $\\lambda-$calculus)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: x ** 2, [1, 2, 3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Filtering data\n",
    "\n",
    "- We can filter a list by applying a _predicate_ to each element of the list.\n",
    "\n",
    "- A predicate is a function which takes a single argument, and returns a boolean value.\n",
    "\n",
    "- `filter(p, X)` is equivalent to $\\{ x : p(x) \\; \\forall x \\in X \\}$ in set-builder notation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 1]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x > 0, [-5, 2, 3, -10, 0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can use both `filter()` and `map()` on other collections such as strings or sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x > 0, {-5, 2, 3, -10, 0, 1}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Filtering using a list comprehension\n",
    "\n",
    "- Again, because this is such a common operation, we can use simpler syntax to say the same thing.\n",
    "\n",
    "- We can express a filter using a list-comprehension by using the keyword `if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 1]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = [-5, 2, 3, -10, 0, 1]\n",
    "[x for x in data if x > 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can also filter and then map in the same expression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.4142135623730951, 1.7320508075688772, 1.0]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import sqrt\n",
    "[sqrt(x) for x in data if x > 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The reduce function\n",
    "\n",
    "- The `reduce()` function recursively applies another function to pairs of values over the entire list, resulting in a _single_ return value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "reduce(lambda x, y: x + y, [0, 1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Big Data\n",
    "\n",
    "- The `map()` and `reduce()` functions form the basis of the map-reduce programming model.\n",
    "\n",
    "- [Map-reduce](https://en.wikipedia.org/wiki/MapReduce) is the basis of modern highly-distributed large-scale computing frameworks.\n",
    "\n",
    "- It is used in BigTable, Hadoop and Apache Spark. \n",
    "\n",
    "- See [these examples in Python](https://spark.apache.org/examples.html) for Apache Spark."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "ipub": {
   "customcss": "fitch.css",
   "titlepage": {
    "author": "(c) Steve Phelps 2019",
    "email": "sphelps@sphelps.net",
    "logo": "figs/fitch-logo.jpeg",
    "title": "Scientific Computing for Finance using Python"
   }
  },
  "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.3"
  },
  "latex_metadata": {
   "chapter": {
    "setcounter": 2
   },
   "title": "Overview of Python"
  },
  "toc": {
   "base_numbering": "1",
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "295.4px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "toc-autonumbering": true,
  "toc-showmarkdowntxt": true,
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}