presentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## Collaborative Software Development\n",
    "\n",
    "\n",
    "---\n",
    "Originally by Graeme Stewart, EP-SFT for the INSIGHTS Workshop, 2018-09-17\n",
    "\n",
    "[GitHub](https://github.com/graeme-a-stewart/python-introduction), [CC-BY-4.0](http://creativecommons.org/licenses/by/4.0/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What is Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Python is an open-source high-level interpreted language\n",
    "* It's an easy language\n",
    "  * Easy to code in, with many useful modules\n",
    "  * Easy to read\n",
    "* It's object oriented\n",
    "* It's dynamic\n",
    "* It's portable and it's popular\n",
    "![Logo](images/python-logo.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Popularity\n",
    "\n",
    "![PYPL Language Popularity](images/python-pypl-popularity.png)\n",
    "\n",
    "From [PopularitY of Programming Languages](https://pypl.github.io/PYPL.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Popularity\n",
    "\n",
    "![Google Trends in Data Science](images/python-r-cpp-googletrends-data.png)\n",
    "\n",
    "![Google Trends in Machine Learning](images/python-r-cpp-googletrends-machinelearning.png)\n",
    "\n",
    "(thanks to [Jim Pivarski](https://github.com/codas-hep/scientific-python-ecosystem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# What's driving this?\n",
    "\n",
    "All of the deep learning libraries have a Python interface,\n",
    "in many cases the primary interface.\n",
    "\n",
    "![Python ML Interfaces](images/python-ml-interfaces.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Python Ecosystem](images/python-ecosystem.png)\n",
    "\n",
    "Python has a very rich ecosystem of packages and plugins (taken from Jake VanderPlas, [*The Unexpected Effectiveness of Python in Science*](https://speakerdeck.com/jakevdp/the-unexpected-effectiveness-of-python-in-science) at PyCon 2017)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# But wait, an interpreted language for (big) scientific data...?\n",
    "\n",
    "Isn't that crazy slow?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Developer productivity is also important  \n",
    "* Python is often used as a **glue** between advanced tools, e.g.\n",
    "  * [NumPy](https://www.numpy.org/): Numerical calculations in Python\n",
    "    * Removes much of Python's runtime overheads, to run *really* fast \n",
    "      (in many cases a lot faster than a naive code implementations in C or C++)\n",
    "  * [Numba](https://numba/pydata.org/): Compile parts of python\n",
    "  * [ROOT](https://root.cern.ch): Everything in ROOT can be done via python.\n",
    "  \n",
    "* Python provides the **logic**, other libraries the computation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python - let's go!\n",
    "\n",
    "<img style=\"float: right;\" src=\"images/googles.jpg\">\n",
    "\n",
    "How do we get python going?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "On most computers it should be simple - just execute `python`...\n",
    "\n",
    "```py\n",
    "teal:~$ python\n",
    "Python 3.6.5 |Anaconda, Inc.| (default, Apr 26 2018, 08:42:37) \n",
    "[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> print(\"hello, world!\")\n",
    "hello, world!\n",
    ">>>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Here we started python in its interpreter mode - we can then type commands and Python immediately executes them for us and gives the results (also called the *Read Evaluate Print Loop*, **REPL**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# ipython - a better shell\n",
    "\n",
    "The normal `python` shell is fine, but there is a better option, the `ipython` shell:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```py\n",
    "teal:~$ ipython\n",
    "Python 3.6.5 |Anaconda, Inc.| (default, Apr 26 2018, 08:42:37) \n",
    "Type 'copyright', 'credits' or 'license' for more information\n",
    "IPython 6.4.0 -- An enhanced Interactive Python. Type '?' for help.\n",
    "\n",
    "In [1]: print(\"hello, world!\")\n",
    "hello, world!\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# ipython \n",
    "\n",
    "What's great about `ipython`?\n",
    "\n",
    "* Getting help on anything with `?`\n",
    "  * Type `?` on it's own for some overview\n",
    "* Jump to the code definition with `??`\n",
    "* `TAB` completion for modules and methods\n",
    "* Easy access to history of inputs and outputs (e.g., `_` is the output of the last command)\n",
    "* Keyboard shortcuts\n",
    "* Run shell commands easily, using `!cmd`\n",
    "* Magic commands\n",
    "  * Try `%magic` for an overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# notebooks - ipython on steroids\n",
    "\n",
    "<img style=\"float: right;\" src=\"images/jupyter-logo-300.png\">\n",
    "\n",
    "Actually, the most useful and coolest way to run Python interactively is in a [*Jupyter Notebook*](https://jupyter.org/).\n",
    "\n",
    "This is a web based \"shell\" for running Python interactively. It can do everything that `ipython` can do in a console, but it can do a lot more as well:\n",
    "* Notebooks can be saved, preserving your work\n",
    "* Notebooks can be shared with others\n",
    "* Cells can contain markdown for better annotation of the code\n",
    "* Notebooks can run lots of languages (R, C++, ROOT)\n",
    "* Notebooks can be interfaces to much more powerful facilities (SWAN)\n",
    "\n",
    "See the backup slides for some getting started links for notebooks\n",
    "\n",
    "(This entire [presentation](https://github.com/graeme-a-stewart/python-introduction) is written as a Jupyter notebook, using the [RISE extension](https://github.com/damianavila/RISE))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The nuts and bolts...\n",
    "\n",
    "<img style=\"float: right;\" src=\"images/nuts-and-bolts.jpg\">\n",
    "\n",
    "Like any other programming language, we need to have some understanding of the syntax of Python to be able to program in it. So let's look at some of the basic building blocks...\n",
    "\n",
    "* Variables\n",
    "  * Numbers, Strings, ...\n",
    "* Compound objects\n",
    "  * Lists, Dictionaries, Tuples\n",
    "* Control Flow\n",
    "  * Context Manager\n",
    "  * Loops and Iterating\n",
    "  * Conditionals\n",
    "* Functions\n",
    "* Classes\n",
    "* Errors and Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Numbers\n",
    "\n",
    "* There are two fundamental number types in Python, integers and floats.\n",
    "  * These behave pretty much as you expect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "i=7 \n",
    "f=9.0\n",
    "print(\"My integer is\", i, \"and my float is\", f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "(i*3) + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "(f*3) + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `int` is effectively unbounded (but for reasonable numbers it's the word size, usually 64bits)\n",
    "* `float` maps to the C-type `double`, i.e., a usually a 64 bit floating point type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operators\n",
    "\n",
    "All the normal arithmetic operators are available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "i + 2 - 3 # Addition and subtraction <- Look - we introduced you to the Python comment character here!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f * 3.0 / 9.0 # Multiplication and divisionn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i / 2 # Note that integer division returns a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i // 2 # But the // operator does an integer divide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i % 2 # Remainder for integer division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f**3 # Power operator (also pow(f,3) works)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Conversions and casts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "i * f # Mixed mode arithmetic \"upcasts\" to float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = i * f + 0.5\n",
    "int(g) # Cast the float result into an integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(i) # Cast an int into a float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\"Normal\" precedence rules apply: power then unary minus then mult/div then add/sub (remember, parentheses are your friends!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "-f**2*-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Complex\n",
    "\n",
    "Complex numbers are a Python basic type too, formed of a real and imaginary floating point pair\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "2.0+21j # Compose with \"j\" for the complex part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "complex(7, -9) # Or pass two arguments to the \"complex\" function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 1+2j\n",
    "c * f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.imag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Strings\n",
    "\n",
    "For storing text in Python we use *strings*, which are just immutable sequences of characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "s=\"this is a dead parrot string\"; t=str(\"it's Norwegian Blue\") # single quotes are fine too\n",
    "print(s, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s + \" it has ceased to be!\" # Use \"+\" to concatenate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Strings are unicode in Python3 (but watch out, they aren't in Python2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "s2=str(\"this parrot \" + '\\U0001F600' + \" wouldn't go Voom! if you put a million volts though it\")\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_s='''this is a long\n",
    "string split over a few lines and has it's own \"quotes\" and 'quotes'\n",
    "so using the triple quote syntax is pretty useful'''\n",
    "print(long_s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## String Operations and Maniplulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "str(3.14159) # The str() function will also convert something to a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mp=\"the Monty Python show\"\n",
    "len(mp) # This is the length of the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mp.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mp.title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mp.find(\"Python\") # This gives the character index where the substring starts (or -1 if not found)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'   one very useful manipulation is to remove leading/trailing whitespace    '.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'# or to see if a string starts with a particular character'.startswith(\"#\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## ipython help\n",
    "\n",
    "Let's try using ipython's help and tab completion to get documentation on strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "str?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Bool\n",
    "\n",
    "Python has a built in *boolean* type as well, which can be `True` or `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "t=True; f=bool(False)\n",
    "print(t, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A boolean is the output of the comparison operator, `==`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(t==f, 7==3+4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "And Python has the usual suite of Boolean operators (do use parentheses!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1==1) and (7>9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(1==1) or (7>9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Boolean curiosities...\n",
    "\n",
    "Booleans will cast into the numbers 1 (`True`) and 0 (`False`)\n",
    "\n",
    "This leads to some occasionally unexpected behaviour ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(9==True, 0.0==False) # Numnbers are False if zero, True otherwise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "The `bool()` function will cast it's argument into a truth value, but it's not really recommended to do this, e.g., although strings will cast to `True` if non-zero length, it's not really obvious or clear..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "s=\"the naked truth\"\n",
    "print(bool(s)) # Not clear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(len(s) > 0) # Much clearer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Null Value\n",
    "\n",
    "Python has an explicit *null* value, which can be assigned to any variable using `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "not_here = None\n",
    "print(not_here)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`None` is used to explicitly signal that a value is unset or missing\n",
    "\n",
    "It's a common idiom in Python to use the fact that a `None` value is considered `False`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Compound Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists\n",
    "\n",
    "Lists are Python's way of grouping objects together - with lists we start to see some of the power of python as a dynamic language"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Define a list using square brackets and commas to separate elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "my_list = [2, 3, 5, 7, 11, 13]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lists are ordered and indexed from zero\n",
    "\n",
    "Use the [] operator to access a specific list element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[2] # N.B. This is the third element!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If a negative index is given, the list is accessed counting from the right, with -1 as the last element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-3] # Third element from the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(my_list) # len() gives the total number of elements in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Lists are also mutable, you can change elements as you like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[0] = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[-1] = \"bicycle repair man\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add elements to a list using `append`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And delete them with the `del` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del my_list[0]\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, Python is more than happy to have mixed object types in a list!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## List Slices\n",
    "\n",
    "For for extracting ranges out of lists, `[i:j]`, gets the elements of the list from `i` up to **but not including** `j`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst=list(range(10))\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[5:-1] # Negative indexes act as before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[:4] # Missing the first index means \"start at the beginning\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[7:] # Missing the last index means \"stop at the end\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[0:7:2] # A third paramater is a \"stride\" value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[:] # What use is this...?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The answer is that slices are always copies, so this made a *new copy* of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are used to hold unordered arrays of *keys* and *values*\n",
    "\n",
    "Python dictionaries can have pretty much anything for the values; keys are restricted to immutable objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d={\"straight\" : \"Graham Chapman\",\n",
    "   \"curved\" : \"John Cleese\",\n",
    "   \"drawn\" : \"Terry Gilliam\",\n",
    "   \"mild\" : \"Michael Palin\"}\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d[\"curved\"] # Accessor uses [], like lists, but with the key and returns the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d[\"extra\"] = \"Graeme Stewart\" # Add or mutate values just by setting them\n",
    "d[\"curved\"] = \"some other guy\"\n",
    "print(d[\"extra\"], \"and\", d[\"curved\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "del d[\"extra\"] # Use the del operator to remove entries\n",
    "\"extra\" in d   # This is the notation to ask if a certain key exists in the dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Container merging\n",
    "\n",
    "We saw how to add single items to containers, but there are also useful methods that merge containers into one another"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For lists, you can `extend` one list with another"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst_1=[\"cats\", \"lizards\", \"parrots\"]; lst_2=[\"beetles\", \"worms\", \"spiders\"]\n",
    "lst_1.extend(lst_2)\n",
    "print(lst_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "For dictionaries use `update` (N.B. existing keys get overwritten)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "art={\"picasso\": \"Guernica\", \"blanchard\": \"Mujer con abanico\", \"miro\": \"Mai 1968\"}\n",
    "more_art={\"macdonald\": \"A Paradox\", \"pollock\": \"Full Fathom Five\", \"miro\": \"Miss Chicago\"}\n",
    "art.update(more_art)\n",
    "print(art, len(art))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tuples\n",
    "\n",
    "As well as lists, Python supports *tuples*, which are like lists but *immutable*\n",
    "\n",
    "Tuples are defined by using commas to separate the different items in the tuple sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "tup = (7, \"bannanas\", True, None)\n",
    "print(tup)\n",
    "tup2 = \"the\", \"parentheses\", \"are\", \"optional\"\n",
    "print(tup2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Tuples can be assigned to separate variables like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a1, a2, a3, a4 = tup\n",
    "print(a2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a very common way to return multiple values from functions (you have to provide the same number of variables as the length of the tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Other Container Types\n",
    "\n",
    "Just to mention other containers that we didn't have time to look at here:\n",
    "\n",
    "* `set` - mutable unordered container of distinct objects\n",
    "* `frozenset` - as above, but immutable\n",
    "\n",
    "And the `collections` module defines some other containers that can be useful, like ordered dictionaries\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Context Managers\n",
    "\n",
    "sometimes you need a resource only for a limited time, like opening a file. Context managers allow to automatize this and make sure the resource is closed at the end of the block, no matter what\n",
    "\n",
    "```python\n",
    "with resource_allocation() as variable:\n",
    "    # use resource\n",
    "    variable.something()\n",
    "# resource will be freed\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"src/macbeth.txt\") as macbeth:\n",
    "    print(macbeth.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterators and Loops\n",
    "\n",
    "We met container types in the last section and very often we want to have an action performed repetitively on the contents of a container, or we want to loop over some other pieces of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "lst_1=[\"cats\", \"lizards\", \"parrots\"];\n",
    "for animal in lst_1:\n",
    "    print(\"Today I was bitten by\", animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The Pythonic idiom here is very common: `for ITEM in COLLECTION`.\n",
    "\n",
    "But in fact it would be better to describe what the `ITEM` runs over as an **iterator**. In Python an iterator is anything that can produce a sequence of values. e.g., if it is a file then it's each line of the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"src/macbeth.txt\") as macbeth:\n",
    "    for line in macbeth:\n",
    "        print(line, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For iterating over a list (or a file) what we iterate over is clear, but what about a dictionary?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The *default* iterator on the dictionary are the keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in art:\n",
    "    print(k, \"painted\", art[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "But there is also a `values` iterator and a (key, value) iterator, called `items`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "for v in art.values():\n",
    "    print(v.upper(), \"is a great painting\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "for k,v in art.items():    # The return value of each iteration is a two value tuple\n",
    "    print(v.upper(), \"is a great painting by\", k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Syntactic Excursion\n",
    "\n",
    "Now that we touched on iterators, there's another thing we should highlight, *Python's indentation syntax* that marks out *code blocks*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Unlike other languages that might use some braces, `{` and `}`, to mark pieces of code which are in the same block, python uses indentation\n",
    "\n",
    "Any lines of code that have the same indentation are in the same block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = list()\n",
    "for k in art:                    # Note the use of the \":\" here, also used in control flow\n",
    "    l.append(k)                  # This line is in the indented code block, so it's executed each time\n",
    "    l.append(art[k].swapcase())  # So is this one\n",
    "print(l)                         # This one is not, so the code block ends on the previous line, this is outside"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Depending on your mood you can view this as a wonderful exercise in uncluttered efficiency or as a painful nightmare where it becomes really hard to work out which lines are in the same block\n",
    "\n",
    "\n",
    "The [very strong advice](https://www.python.org/dev/peps/pep-0008/#tabs-or-spaces) is to always use spaces, never tabs; use a good editor to help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional Control Flow\n",
    "\n",
    "Python can execute code conditionally, using an `if ... elif ... else` syntax that will not really surprise you"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for number in range(10):\n",
    "    print(\"Oh,\", number, \"- \", end='')\n",
    "    if number < 3:\n",
    "        print(\"that's small\")\n",
    "    elif number < 7:\n",
    "        print(\"that's medium\")\n",
    "    else:\n",
    "        print(\"that's big\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evidently this also shows how loops and control statements are naturally nested"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Ternary operator\n",
    "\n",
    "Python has a compact version of `if ... then ... else ...` called a *ternary operator*\n",
    "\n",
    "In Python this has a nice natural syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "st = \"it's the truth, Ruth\" if len(art) == 5 else \"it's a lie, Sky\"\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Loop Control\n",
    "\n",
    "You can write a C-style conditional control loop in Python with `while (CONDITION) ...`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "i=0\n",
    "while (i<5):\n",
    "    print(i)\n",
    "    i+=1          # Note this nice syntax for adding to a number (it's the same as \"i=i+1\")\n",
    "                  # Also supported are \"-=\", \"*=\", \"/=\" - they do what you would expect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Better Loop Control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Usually a nicer way to get control in loops is to use the keywords `continue` and `break`:\n",
    "* `continue` stops this iteration and jumps back to the start to get the next value\n",
    "* `break` exits the loop immediately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "words = ['bark', 'nothing', 'roll over', 'die', 'eat']\n",
    "for cmd in words:\n",
    "    if cmd == 'nothing':\n",
    "        continue\n",
    "    if cmd == 'die':\n",
    "        break\n",
    "    print(cmd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Bonus feature: Python supports a `else` clause for loops. Any idea what this will do?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "for cmd in words:\n",
    "    if cmd == \"die\":\n",
    "        break\n",
    "else:\n",
    "    print(\"didn't die\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Comprehensions\n",
    "\n",
    "Python has a rather lovely syntax for generating output lists and dictionaries from other iterables\n",
    "\n",
    "It's very commonly used and replaces a many things that would require short loops with a compact single line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[ x**2 for x in [1, 3, 5, 7, 11, 13, 17] ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read this as `OUTPUT for ITEM in ITERABLE`, and enclosing it within the `[]`s lets Python know this is a *list comprehension*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[ x**2 for x in range(1,100) if x%10 == 0 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we also added a condition that selected only certain elements of the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Dictionary comprehensions are very similar to those for lists, just that the output is specified as `key: value` and the syntax for a dictionary comprehension is an expression enclosed in `{}`s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{ x: x**2 for x in range(1,100) if x%10 == 0 }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "Now we know enough of the nuts and bolts of Python to start building some more interesting things\n",
    "\n",
    "![Meccano toy](images/meccano.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions are how we start to encapsulate behaviour in our programs, so that tasks can be isolated from one another and different parts of the program don't interfere\n",
    "\n",
    "Functions normally take some inputs and give back outputs, although skipping one or the other is quite common"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python we define a function with the `def` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def double_and_more(i, j):\n",
    "    '''A trivial function'''\n",
    "    k = i*2\n",
    "    k += j\n",
    "    return k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "help(double_and_more) # This is the same as double_and_more? in ipython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "double_and_more(7, 5) # Call a function with its name, followed by (), with any arguments inside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def double_and_more(i, j):\n",
    "    '''A trivial function'''\n",
    "    k = i*2\n",
    "    k += j\n",
    "    return k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The arguments are given in parentheses after the name of the function\n",
    "* The string immediately after the `def` is called the *docstring* and is printed when the user asks for help\n",
    "  * Excepting trivial functions, do always write a docstring\n",
    "* The `return` value exits the function, returning any values given (can be as many as you like, as a tuple)\n",
    "  * If there's no return value at the end of the function it implicitly returns `None`\n",
    "* Variables defined in the scope of the function block are local and not visible outside of it (this is a *good thing*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Parameters that get passed to a function in Python are *named* and it's usually clearer if the client calls them using that name, e.g.,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maths_circus(num, message):\n",
    "    '''A noisy cuber'''\n",
    "    print(\"We are shouting, '\", message, \"', for you\", sep=\"\")\n",
    "    n = num**3\n",
    "    return n\n",
    "maths_circus(num=-4, message=\"pancakes\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "This also means that parameters can be given in any order..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maths_circus(message=\"I love clowns\", num=9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Parameters can also be given default values, then they can be skipped by the client unless they wish to override the default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def maths_circus(num=7, message=\"what have the Romans ever done for us?\"):\n",
    "    '''A noisy cuber, with defaults'''\n",
    "    print(\"We are shouting, '\", message, \"', for you\", sep=\"\")\n",
    "    n = num**3\n",
    "    return n\n",
    "maths_circus() # Both parameters skipped - use defaults"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "maths_circus(num=-2) # message skipped - use default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maths_circus(message=\"roads, vineculture, public baths, ...\") # num skipped - use default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maths_circus(message=\"confuse a cat\", num=-4) # Both parameters specified - defaults overridden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Optional Arguments\n",
    "\n",
    "Sometimes functions need to be able to take *arbitrary* numbers of arguments, which Python can allow using the `*args` and the `**kwargs` parameters\n",
    "\n",
    "If a function defines these special argument types then\n",
    "\n",
    "* `args` will be a list of all positional parameters (in the order given)\n",
    "* `kwargs` will be a dictionary of named arguments, with the key being the name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def mill(debug, *args, mesg=\"starting\", **kwargs):\n",
    "    '''Process all arguments'''\n",
    "    print(\"debug:\", debug)\n",
    "    print(mesg)\n",
    "    print(\"These are the positional arguments\", args)\n",
    "    print(\"These are the named arguments\", kwargs)\n",
    "\n",
    "mill(True, 1, 2, 4, mesg=\"hello\", alice=\"good\", bob=\"good\", eve=\"spy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do not use these argument types to be lazy - it can be very difficult to debug functions that support arbitrary arguments (e.g., misspelling an argument name is a bugbear here)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# Keyword Only Arguments\n",
    "\n",
    "sometimes you want to force a user to supply the argument by name to help avoid errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def keyword_only(arg, *, keyword=None):\n",
    "    print(arg, keyword)\n",
    "    \n",
    "keyword_only(\"something\", keyword=\"else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "keyword_only(\"something\", \"else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Scripts\n",
    "\n",
    "So far we have worked in the Python interpreter\n",
    "\n",
    "This is a fantastic way to explore python and work interactively, but in many cases we want to work in a *hands off* manner\n",
    "\n",
    "In this case, we would rather save our work in a file and get the Python interpreter to execute it for us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!cat src/hello.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python src/hello.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!ls -l src/hello.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!./src/hello.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```py\n",
    "#!/usr/bin/env python\n",
    "print(\"hello, world!\")\n",
    "```\n",
    "\n",
    "* Execute the script directly with python by giving it as the argument, `python hello.py`\n",
    "* On Linux / OS X we can\n",
    "  * Use the magic shebang `#!` at the start of the file so that the loader invokes python for us\n",
    "  * Use `/usr/bin/env python` so that the version of Python is found from `PATH`\n",
    "  * The script also needs to be marked as executable: `chmod a+x hello.py`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Passing arguments to scripts\n",
    "\n",
    "Let's look at another version of our hello script:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!cat src/hello-args.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "!python src/hello-args.py --name Brian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python src/hello-args.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!python src/hello-args.py --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Modules\n",
    "\n",
    "There was a lot there! The first thing in the script was to import a Python *module*: `import argparse`\n",
    "\n",
    "Modules are the way that Python extends functionality - it's one of the huge advantages of Python that it has such a rich set of modules that provide well written and easy to use extensions to the core language\n",
    "\n",
    "In this case we imported the `argparse` module, which is a standard Python module provided by all Python installations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "argparse?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python modules usually provide well written interfaces with additional functionality - you might write your own parser for arguments passed in to your script, but making it robust and providing functionality like the `--help` option would take a lot of time\n",
    "\n",
    "The Python documentation lists the many, many [modules that are available](https://docs.python.org/3/py-modindex.html) in every standard Python installation\n",
    "\n",
    "In addition many other modules come packaged with, e.g., the [Anaconda Python distribution](https://www.anaconda.com/) or through the standard [*PyPI*](https://pypi.org/) (Python Package Index) repository, installed with `pip`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Importing from modules\n",
    "\n",
    "When we import from a module by default, the module name is added to the namespace and the module's functions and other members (attributes) become available to us under that name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import os            # Import the os module (this is a really common one as it allows many core interactions with \n",
    "                     # the underlying system)\n",
    "os.environ[\"PATH\"]   # environ is a dictionary with the current envionment set, and it's not in the os part of the namespace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "However, we can also import pieces of a module directly into the top level of the namespace, or import a module or member with a different name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sys import executable\n",
    "print(executable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as maths # The British would have called it maths...\n",
    "maths.sqrt(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi as half_tau\n",
    "tau = 2.0 * half_tau\n",
    "print(tau)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's possible to import everything from a module into the top namespace in Python, using `from module import *`; this is really dangerous as it becomes extremely hard to know how the namespace was populated. **Try to avoid this**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Writing your own modules\n",
    "\n",
    "Of course once you know modules can be written, you'd probably like to know how to do it yourself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Note this - \"!\" is an ipython special that allows us to execute a shell command\n",
    "!cat mymod.py "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import mymod\n",
    "print(mymod.modvar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mymod.modvar+=1\n",
    "print(mymod.modvar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is pretty easy - any python file found in the current directory can be imported as a module, then it becomes available, using the filename as the namespace entry\n",
    "\n",
    "Actually, the files don't need to live in the current directory, `$PYTHONPATH` gets searched (from the shell), or `sys.path` inside Python itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Classes\n",
    "\n",
    "Classes are at the core of all object oriented programming languages, and Python is no exception\n",
    "\n",
    "A **class** is a logical group of properties (variables and functions)\n",
    " \n",
    " * encapsulation: allows to define behavior of certain objects and group everything logically\n",
    " * inheritance: classes can be based on other classes and just extend/modify the behavior\n",
    "\n",
    "\n",
    "Python has a very natural way of defining and expressing classes - let's look at a simple example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class CounterClass:\n",
    "    def __init__(self):\n",
    "        self.counter = 0\n",
    "        \n",
    "    def add(self):\n",
    "        self.counter += 1\n",
    "        \n",
    "    def reset(self):\n",
    "        self.counter = 0\n",
    "        \n",
    "    def get(self):\n",
    "        return self.counter\n",
    "    \n",
    "c = CounterClass()\n",
    "c.add(); c.add()\n",
    "print(c.get())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c.reset()\n",
    "print(c.get())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Some of the key features to note:\n",
    "```py\n",
    "class CounterClass:\n",
    "    def __init__(self):\n",
    "        self.counter = 0\n",
    "        \n",
    "    def add(self):\n",
    "        self.counter += 1\n",
    "...```\n",
    "\n",
    "* The keyword `class` introduces a class definition in its following code clock\n",
    "  * The class will define a new type in the current scope\n",
    "* Class methods are defined very like functions, using `def`\n",
    "  * The first parameter is the class instance itself, by convention always called `self`\n",
    "* The special method `__init__` is called when an instance of the class is created (a.k.a. a constructor)\n",
    "  * (BTW, there are lots of these [special `__FOO__` attributes](https://docs.python.org/3/reference/datamodel.html#special-method-names) in Python, e.g., `__del__` is your destructor)\n",
    "* All data members of the class are referenced via the object instance, `self`\n",
    "  * `self.counter` is a *data member* of the class\n",
    "  * `counter` would be a plain local variable (watch out!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Just as an aside, when we say that Python is a dynamic language, it means that even classes can be modified dynamically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def set(self, n):\n",
    "    self.counter = n\n",
    "\n",
    "# Add the \"set\" function as a new method to the class\n",
    "CounterClass.set = set\n",
    "c.set(7)\n",
    "print(c.get())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "CounterClass.msg = \"we just added a new data member as well\"\n",
    "print(c.msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Classes, Scopes and Namespaces\n",
    "\n",
    "Python implements classes as a new data type, which means that they have their own scope and namespace\n",
    "\n",
    "To find out what attributes are defined in a scope we can use the Python builtin `dir` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "dir(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Subclasses and Inheritance\n",
    "\n",
    "Python classes can also inherit from other classes, becoming subclasses - this allows objects which extend or specialize the classes that they inherit from in the usual object oriented way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Poly2:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "class Rectangle(Poly2):\n",
    "    def area(self):\n",
    "        return self.x*self.y\n",
    "        \n",
    "class Triangle(Poly2):\n",
    "    def area(self):\n",
    "        return self.x*self.y/2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "rect=Rectangle(3,5)\n",
    "print(rect.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tri=Triangle(10,4)\n",
    "print(tri.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "picasso=Poly2()\n",
    "'area' in dir(picasso) # This is a way to ask the object if it has an attribute of that name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So much for extending classes, we can override methods from the base classes as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Square(Rectangle):\n",
    "    def __init__(self, x=0):\n",
    "        self.x = x\n",
    "        \n",
    "    def area(self):\n",
    "        return self.x**2\n",
    "\n",
    "sq=Square(4)\n",
    "print(sq.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way that Python searches for attributes in a derived class is to search the derived class first, then any parent classes, so the derived class's definition wins out\n",
    "\n",
    "The derived class can call methods in the parent class - have a look at [`super()`](https://docs.python.org/3/library/functions.html#super)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Class Introspection\n",
    "\n",
    "On point that might be coming clear to you now is that Python is quite happy to pass *any* objects into function calls of methods\n",
    "\n",
    "If the passed object has the right properties to work with the call, it works; if not, then something will fail (this is known in the trade as *Duck Typing*)\n",
    "\n",
    "Two useful functions can be used to inspect a class's providence\n",
    "* `isinstance(obj, classinfo)` returns `True` if the object is an instance of, or derived from, the classinfo class\n",
    "* `issubclass(class, classinfo)` returns `True` if the object is a subclass of the classinfo class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(isinstance(sq, Poly2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(issubclass(Triangle, Poly2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(issubclass(Triangle, Rectangle))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "While we're on the subject, note that the builtin `type` function will return an object's type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "print(type(Triangle), type(\"python\"), type(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Class data members\n",
    "\n",
    "Data members of Python classes are pretty exposed - they can be accessed and *modified* by clients\n",
    "\n",
    "This would usually be rather dangerous as it would be easy to violate an invariant of the class this way"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python there is a convention that methods starting with an underscore (`_`) are not to be accessed directly by clients (this is by convention, members called `__name` get additionally mangled by Python to prevent accidents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle2:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def area(self):\n",
    "        return self._x*self._y\n",
    "\n",
    "rec=Rectangle2(2,8)\n",
    "print(rec.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Although this still works\n",
    "rec._x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Getters and setters\n",
    "\n",
    "You should usually then write getters and setters for your \"public\" data members"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class Rectangle3:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    def area(self):\n",
    "        return self._x*self._y\n",
    "    \n",
    "    def x(self):\n",
    "        return self._x\n",
    "    \n",
    "    def set_x(self, x):\n",
    "        if x >= 0.0:\n",
    "            self._x = x\n",
    "    \n",
    "rec=Rectangle3(2,4)\n",
    "print(rec.area())\n",
    "rec.set_x(9)\n",
    "print(rec.x(), rec.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Hmmm, but that `()` syntax is a bit of ugly boilerplate, right?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Decorators and Properties\n",
    "\n",
    "Python has a very neat way to turn getters and setters into much more natural feeling *properties* like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle4:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self._x = x\n",
    "        self._y = y\n",
    "    \n",
    "    @property\n",
    "    def area(self):\n",
    "        return self._x*self._y\n",
    "    \n",
    "    @property\n",
    "    def x(self):\n",
    "        return self._x\n",
    "    \n",
    "    @x.setter\n",
    "    def x(self, value):\n",
    "        if value >= 0.0:\n",
    "            self._x = value\n",
    "    \n",
    "rec=Rectangle4(2,4)\n",
    "print(rec.area, rec.x)\n",
    "rec.x=9\n",
    "rec.x=-5\n",
    "print(rec.x, rec.area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the recommended way of getting and setting data members, with the functions wrapped up feel more natural\n",
    "\n",
    "The syntax of `@property` is what's known as a *decorator* in Python - think of it like a way of wrapping up a function to change some of its exposed interfaces or behaviours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Errors and Exceptions\n",
    "\n",
    "So far all of the simple examples we looked at here have worked as expected - real life isn't like that and things are definitely going to go wrong\n",
    "\n",
    "So how do we deal with errors in Python?\n",
    "\n",
    "When something mis-fires in Python an *exception* is raised:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "st=\"bring out your dead\"\n",
    "st.fnd(\"dead\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    },
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "x=7; y=5\n",
    "print(x/(y-5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Handling exceptions\n",
    "\n",
    "The way to handle exceptions in Python is to use a `try... except...` block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    x=7; y=5\n",
    "    print(x/(y-5))\n",
    "except ZeroDivisionError:\n",
    "    print(\"please don't divide by zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There can be multiple `except` blocks, for handling different errors that might happen:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    f=open(\"/tmp-file.txt\", \"w\")\n",
    "    print(\"some text\", file=f)\n",
    "except OSError:\n",
    "    print(\"Failure opening file\")\n",
    "except IOError:\n",
    "    print(\"Error writing to file\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If you want to handle multiple exceptions with one piece of code, you can use `as` to set a local variable with one of a few exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    f=open(\"/tmp-file.txt\", \"w\")\n",
    "    print(\"some text\", file=f)\n",
    "except (OSError, IOError) as e:\n",
    "    print(\"Failure during file handling:\", e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice also that exceptions are printable, and provide some normally helpful text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Exceptions are code blocks and can nest other exception handlers inside themselves, so it's possible to structure your error handling and (possible) recovery in fairly sophisticated ways"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def divider(x, y):\n",
    "    try:\n",
    "        a = x/y\n",
    "    except ZeroDivisionError:\n",
    "        a = 0\n",
    "    return a\n",
    "\n",
    "try:\n",
    "    f=open(\"tmp-file.txt\", \"w\")\n",
    "    print(divider(7,0), file=f)\n",
    "except (OSError, IOError) as e:\n",
    "    print(\"Failure during file handling:\", e)\n",
    "\n",
    "!cat tmp-file.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If your own code needs to generate an exception, use `raise`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [],
   "source": [
    "def buy(price, money):\n",
    "    if money < price:\n",
    "        raise RuntimeError(\"Not enough money to buy\")\n",
    "    money -= price\n",
    "\n",
    "buy(100.0, 50.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you are writing anything other than trivial code, you will want to define exception classes for you own program, which Python makes it easy to do, as you can just inherit from the built in `Exception` class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TutorialException(Exception):\n",
    "    pass # pass is a very handy bit of python syntax used for supporting an empty code block"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## LBYL and EAFP\n",
    "\n",
    "Programming life could be divided into two strategies for dealing with errors\n",
    "\n",
    "* *Look Before You Leap* - check that things are going to be ok first\n",
    "* *Easier to Ask Forgiveness than Permission* - go for it and clean up if you need to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_dict={\"k\": \"v\"}\n",
    "\n",
    "# Easier to Ask Forgiveness than Permission\n",
    "try:\n",
    "    x = my_dict[\"key\"]\n",
    "except KeyError:\n",
    "    pass # in real life handle missing key (EAFP)\n",
    "\n",
    "# Look Before You Leap\n",
    "if \"key\" in my_dict:\n",
    "    x = my_dict[\"key\"]\n",
    "else:\n",
    "    pass # in real life handle missing key (LBYL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general Python prefers EAFP - there are a few advantages (like avoiding some race conditions, avoid double data accesses) and generally the code looks rather cleaner\n",
    "\n",
    "However, don't get so carried away that you start to use exceptions as control flow (really, keep them for *exceptional* situations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The Python Ecosystem\n",
    "\n",
    "One important aspect of python is its very healthy ecosystem of packages for different tasks. \n",
    "\n",
    "* [numpy](http://www.numpy.org/) - The high performance core of all serious Python numerics\n",
    "* [pandas](https://pandas.pydata.org/) - Python data analysis package for importing and working with bulk data\n",
    "* [scipy](https://www.scipy.org/) - Lots of common scientific routines, such as minimization\n",
    "* [xarray](http://xarray.pydata.org/en/stable/why-xarray.html#core-data-structures) - Pandas for multi-dimensional structures\n",
    "* [matplotlib](https://matplotlib.org/) - The most popular Python plotting package\n",
    "* [seaborn](https://seaborn.pydata.org/) - Statistical data visualization\n",
    "* [scikit-learn](http://scikit-learn.org/stable/index.html) - Easy to use machine learning for Python\n",
    "* ...\n",
    "\n",
    "If you think you need it, someone probably already did it: **Use the tools**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy - Numerical computations for Python\n",
    "\n",
    "Numpy offers a general library for numeric computations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "matrix = np.arange(100, dtype=np.float).reshape(10,10)\n",
    "matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "matrix[2:5,4:7] = 0\n",
    "matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Pandas - Data Analysis Library\n",
    "\n",
    "High level interface to bulk data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv(\"src/small-training.csv\")\n",
    "\n",
    "df[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "df[[\"PRI_jet_num\", \"PRI_jet_leading_pt\", \"PRI_jet_leading_phi\"]].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Of course pandas can also present the data visually using the `matplotlib` library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "df[df[\"PRI_jet_num\"]>0].plot.hexbin(x=\"PRI_jet_leading_eta\", y=\"PRI_jet_leading_phi\", gridsize=25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mass_mmc = df[df[\"DER_mass_MMC\"]>0]\n",
    "df_mass_mmc.plot.scatter(x=\"DER_mass_MMC\", y=\"DER_mass_vis\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Seaborn - statistical visualization library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "sns.jointplot(df_mass_mmc[\"DER_mass_MMC\"], df_mass_mmc[\"DER_mass_vis\"], \n",
    "              kind=\"reg\", line_kws={\"color\": \"red\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Few Last Python Pointers\n",
    "\n",
    "Let's close this tutorial session going back to core Python and picking up on a few things that are rather important, but quite easy to overlook\n",
    "\n",
    "Obviously it takes quite a lot of practice to get really comfortable in Python, but the following slides tell you about some key features that will save you a lot of pain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Some notable useful loop utilities\n",
    "\n",
    "We looked at loops and how Python happily will run the same code over every item it gets back from an iterator - in general you just don't need to care how far through the sequence you are\n",
    "\n",
    "However, what if you *do* need to know this, e.g., something special needs to happen at the beginning or the end?\n",
    "\n",
    "The solution is `enumerate` that produces a counter that runs along with the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for i, animal in enumerate([\"dog\", \"cat\", \"giraffe\", \"toad\"]):\n",
    "    print(animal, \"was number\", i, \"in my list\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you have multiple lists that you want to march over in sync, then use `zip` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "forename=[\"Michael\", \"Terry\", \"Graham\", \"John\", \"Eric\"]\n",
    "surname=[\"Palin\", \"Gilliam\", \"Chapman\", \"Cleese\", \"Idle\"]\n",
    "alive=[True, True, False, True, True]\n",
    "for fn, sn, al in zip(forename, surname, alive):\n",
    "    print(fn, sn, \"is\", \"alive\" if al else \"dead\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the clever use of the ternary operator there!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Parameter passing - bindings and object references\n",
    "\n",
    "In Python the `=` operator does not copy objects, instead it makes a new binding to them; this means that the same object can have multiple bindings and if the object changes both bindings will reflect that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_list = list(range(5))\n",
    "your_list = my_list\n",
    "your_list[2] = \"stuck in the middle\"\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "This also behaviour also applies to function calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sillyMiddle(l):\n",
    "    l[len(l)//2] = \"silly\"\n",
    "    \n",
    "my_list = list(range(5))\n",
    "your_list = my_list\n",
    "sillyMiddle(your_list)\n",
    "print(my_list, your_list) # Both refer to the same, modified object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "But beware of a subtlety here..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setToSeven(x, s, d):\n",
    "    x=7                 # We just created a *local* variable x, bound to 7; but the caller binding remains unchanged\n",
    "    s=\"inner\"           # Ditto for the string s\n",
    "    d[\"inner\"] = True   # Here the object is updated, but the binding remains the same\n",
    "    print(\"Set to\", x)\n",
    "    \n",
    "x=5; s=\"outer\"; d=dict()\n",
    "print(\"Start\", x, s, d)\n",
    "setToSeven(x, s, d)\n",
    "print(\"End\", x, s, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python does not pass by C++ style *value* or *reference*, but by object. So mutable objects changed within a function call will be seen as changed by their caller (as the object binding itself did not change); however, immuatable objects, like numbers, strings and tuples, cannot be changed and so assigning to creates a new local binding - the outside binding remains unchanged."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If you do need to really make a new copy of an object, use the *copy* module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from copy import deepcopy # Deep copy copies the container and copies all objects recursively\n",
    "her_list = deepcopy(my_list)\n",
    "her_list.append(\"this is the end\")\n",
    "print(my_list[-1], \"--\", her_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth reminding you here that slicing a list in normal Python does produce a copy - if you want to modify a list during a loop you'd better do that"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# First class functions\n",
    "\n",
    "One of Python's great features is that functions are *first class objects*, which means that they can be generated on the fly and returned from other functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addText(s):\n",
    "    def addSomeText(f):\n",
    "        f=f+s\n",
    "        return f\n",
    "    return addSomeText\n",
    "\n",
    "sw=addText(\"swallow\")\n",
    "print(type(sw))\n",
    "sw(\"good lord it's an unladen \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ne=addText(\"newt\")\n",
    "print(ne(\"she turned me into a \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A little bit more about printing and formatting...\n",
    "\n",
    "We deliberately kept our use of the `print` function quite basic so far, although we did toss in a few of it's extra parameters:\n",
    "* `end` - string to print at the end of the output (default, `\\n`)\n",
    "* `sep` - separator between output elements (default a space)\n",
    "* `file` - target output file stream (default `sys.stdout`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To format things in a little more easily with Python strings, you can use the [*f-string*](https://docs.python.org/3/reference/lexical_analysis.html#f-strings) notation, which allows you to write variable names in `{}`s and they will be substituted in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bird=\"swallow\"\n",
    "state=\"unladen\"\n",
    "print(f\"Look! It's an {state} {bird}\") # N.B. String is prefixed with \"f\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers can take format specifiers to control how they are printed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "hx=0xdeadbeef\n",
    "f1=math.pi\n",
    "print(f\"The number is {hx} (or {hx:#0x}); we love {math.pi}, or {math.pi:.3} if we are in a hurry\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Some standard module highlights\n",
    "\n",
    "There is an absolute wealth of useful code inside Python's own [standard modules](https://docs.python.org/3/py-modindex.html); a few of the most important and useful modules are:\n",
    "\n",
    "* `argparse` - for parsing script options passed on the command line\n",
    "* `configparser` - for reading settings from standard INI files\n",
    "* `datetime`, `time` - functions for date and time manipulation\n",
    "* `fnmatch`, `glob` - shell style matching of files and strings\n",
    "* `logging` - powerful utility for writing log messages from programs\n",
    "* `math` - maths functions (though for large amounts of data use `numpy`!)\n",
    "* `os` - operating system interfaces (including the filesystem)\n",
    "* `re` - regular expressions\n",
    "* `sys` - system parameters and functions\n",
    "* `unittest` - xUnit testing framework for Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Python2 and Python3\n",
    "\n",
    "* Python is currently finishing a major version transition, from 2 to 3\n",
    "  * Python2 support [stops quite soon](https://pythonclock.org/), on 1 January 2020\n",
    "* Almost every major useful Python module now runs in Python 3, so it's the recommended way to start any new project\n",
    "* Python 3...\n",
    "  * Introduces a new `print()` function instead of the old Python2 `print` *statement*\n",
    "  * Integer division (`3/2`) will return a float (use `3//2` if you want pure rounded int division)\n",
    "  * Strings in Python3 are all *unicode* and pure data should be stored in `bytes` or `bytearray`\n",
    "  * `range` becomes an iterator by default and there is no `xrange` (use `list(range(...))` to get a list if you need it)\n",
    "  * Exceptions are raised more consistently (`raise IOError(\"disk drive on fire\")`)\n",
    "    * And handled more easily using `as` (`except NameError as err`)\n",
    "  * Oh, and Python3 is often a lot faster as well"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## Python3 and HEP\n",
    "\n",
    "* However... although Python3 is now the standard, in the HEP community we are a bit behind\n",
    "  * You may therefore find you have to use Python2 for some HEP use cases\n",
    "  * In which case you should definitely take a look at the `__future__` module that can allow you to write Python2 code using a lot of Python3 syntax in advance\n",
    "  * But there are a few things you just don't have - sorry, no f-strings!\n",
    "\n",
    "```py\n",
    "lxplus015:~$ python\n",
    "Python 2.7.5 (default, Jul 13 2018, 13:06:57) \n",
    "[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> print(\"hello, world!\") # Actually this is also ok in Python2.7\n",
    "hello, world!\n",
    ">>> 3/2\n",
    "1\n",
    ">>> from __future__ import division, print_function\n",
    ">>> print(3/2)\n",
    "1.5\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "# Final Words\n",
    "\n",
    "In case you didn't yet realize it, **Python is pretty amazing**\n",
    "\n",
    "It's a highly productive language that's easy to learn and opens a world of possibility for effective and efficient programming\n",
    "\n",
    "This introduction was as much of a taster as could be managed in the time we had, but there are now many avenues that you could explore from here:\n",
    "\n",
    "* The Python tutorial is a nice introduction that covers a lot of the basic ground for Python\n",
    "* The LHCb *StarterKit* provides grounded training for physicists with nice exercises to do on the way\n",
    "* The [HEP Software Foundation](https://hepsoftwarefoundation.org/) is compiling a list of [Python resources](https://github.com/hsf-training/PyHEP-resources) for our community\n",
    "\n",
    "You can find many more resources by searching the internet and sites like *Stack Overflow* contain a wealth of answers to common problems\n",
    "\n",
    "Last, but not least, your colleagues and fellow Pythonistas will be a source of help, advice, fixes and, if all else fails, solace\n",
    "\n",
    "**Enjoy Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python IDEs\n",
    "\n",
    "Of course you can develop all this in a normal text editor, but there are highly sophisticated integrated development environments out there\n",
    "\n",
    "* [PyCharm](https://www.jetbrains.com/pycharm/)\n",
    "* [Visual Studio Code](https://code.visualstudio.com/) (yes, also under Linux and on [GitHub](https://github.com/Microsoft/vscode).\n",
    "* Eclipse + PyDev\n",
    "* KDevelop\n",
    "* Atom, Sublime, Emacs, Vim ...\n",
    "\n",
    "Or with an data analysis focus:\n",
    "* [Spyder](https://www.spyder-ide.org/) (comes with Anaconda)\n",
    "* [Rodeo](https://rodeo.yhat.com/)\n",
    "* [Jupyterlab](https://jupyterlab.readthedocs.io/en/stable/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Backup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Getting notebooks up and running\n",
    "\n",
    "We pointed out some of the great features of notebooks at the start, here are some pointers...\n",
    "\n",
    "* The [Project Jupyter website](https://jupyter.org/) (see [install](https://jupyter.org/install))\n",
    "\n",
    "The easy ways to install are through the Anaconda python distribution or using pip\n",
    "\n",
    "Then you can clone this lecture and start the notebook server...\n",
    "\n",
    "```\n",
    "git clone ...\n",
    "jupyter notebook\n",
    "[I 18:55:02.119 NotebookApp] Serving notebooks from local directory: /Users/graemes/docs\n",
    "[I 18:55:02.120 NotebookApp] The Jupyter Notebook is running at:\n",
    "[I 18:55:02.120 NotebookApp] http://localhost:8888/?token=bd9fb3599d7b4f7bf23a53efd8987cf3cc8dc1fe4d358eb6\n",
    "```\n",
    "\n",
    "...and navigate to the notebook link given (usually it starts automatically)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Acknowledgements\n",
    "\n",
    "Many thanks to all my colleagues who helped provide pieces of material that got sliced, diced and re-assembled into this tutorial\n",
    "\n",
    "Particular thanks to \n",
    "\n",
    "* the LHCb StarterKit team (Arthur, Chris, Violeene, Dario in particular) who wrote a great \"follow-along\" tutorial\n",
    "* Jim Pivarski who has a deep understanding of all things Python and how they fit for HEP\n",
    "* Eduardo Rodrigues, who was the driving force behind our new HSF PyHEP group\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}