V2/university/T00000-Using-Python-with-LUSID/Basic Python scripting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Basic Python scripting\n",
    "This section of the tutorial serves as a brief introduction to Python and writing some Python code. We'll cover:\n",
    "- What is Python\n",
    "- Assigning variables and built-in types\n",
    "- Python Sequence types\n",
    "- Python Mapping types\n",
    "- Decision statements\n",
    "- Loops\n",
    "- Functions\n",
    "- Classes and objects\n",
    "- Using libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### What is Python?\n",
    "Guido Van Rossum began developing Python in 1989 as a programming language that should be:\n",
    "- An easy and intuitive language just as powerful as major competitors\n",
    "- Open source, so anyone can contribute to its development\n",
    "- Code that is as understandable as plain English\n",
    "- Suitability for everyday tasks, allowing for short development times\n",
    "\n",
    "Python is interpreted, which means that there is no complex build process for running your code, so you can write your code interactively. In Jupyter, you can write your code in a code cell and execute it by clicking the run button - its as simple as that!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Assigning variables and built-in types\n",
    "Here we'll learn how to create some variables, and some of the built-in types that Python provides\n",
    "#### Assigning variables\n",
    "Python is dynamically typed, so you don't have to declare the type of a variable before using it. By [convention](https://peps.python.org/pep-0008/#function-and-variable-names), multi-word variables are lower case, and seperated by underscores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# This is a comment, it is ignored by the interpreter\n",
    "\n",
    "# Assigning hello world to the variable x\n",
    "# in other languages you would have to declare that x is a string before doing this\n",
    "x = 'hello world'\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we've assigned x the string 'hello world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assigning 7 to the variable y\n",
    "# in other languages you would have to declare that y is an integer before doing this\n",
    "y = 7\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've assigned y the integer 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'not just a number'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In Python types are dynamic\n",
    "y = 'not just a number'\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can assign y a different type, here a string. Python is dynamically typed, so doesn't care if we reuse variable names with different types of data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Built-in types\n",
    "Here we'll introduce some of the built-in types that are provided out-of-the-box with Python:\n",
    "- Numeric types - `int`, `float`\n",
    "- The Text Sequence type - `str`\n",
    "- Boolean Values - `bool`\n",
    "- The Null Object - `None`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Numeric types - int, float\n",
    "In Python, integers are zero, positive or negative whole numbers without a fractional part and having unlimited precision.\\\n",
    "Floats are made to represent floating-point numbers with the same precision as the double type in other common languages.\n",
    "You can use common mathematical operations with both floats and integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Some integers\n",
    "a = 1\n",
    "b = 2000\n",
    "c = 0\n",
    "d = -99\n",
    "\n",
    "# Some floats\n",
    "e = 0.1\n",
    "f = -25.972"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Just some examples of creating numeric variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2001"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# adding ints\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "As you'd expect, we can add two ints together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-25.872"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# adding floats\n",
    "e + f\n",
    "# as f is negative its subtracted from e, as you would expect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can also add two floats together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40020.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# some more complex math\n",
    "2*(a+b)/e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "And even do more complex operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### The Text Sequence type - str\n",
    "Strings represent text data. In Python strings are immutable sequences of unicode characters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So\n",
      "many\n",
      "lines!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Assigning the string hello world to the variable x\n",
    "x = 'hello world'\n",
    "# Also assigning the string hello world to the variable x\n",
    "x = \"hello world\"\n",
    "\n",
    "single_quotes ='allows embedded \"double\" quotes'\n",
    "\n",
    "double_quotes = \"allows embedded 'single' quotes\"\n",
    "\n",
    "# There are also multi-line strings:\n",
    "y = '''So\n",
    "many\n",
    "lines!\n",
    "''' \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here's the 3 main ways of creating strings - we can use single and double quotes interchangably"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Strings have many useful functions that can be used to manipulate them, here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n",
      "HELLO WORLD\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 'hello world'\n",
    "# Return a copy of the string with its first character capitalized and the rest lowercased.\n",
    "print(x.capitalize())\n",
    "# Return a copy of the string with all the cased characters converted to uppercase\n",
    "print(x.upper())\n",
    "# Return True if all cased characters in the string are lowercase and there is at least one cased character, False otherwise.\n",
    "print(x.islower())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can capitalize, lower-case, and check if a word is lower case super easily in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "f-strings are also pretty useful, allowing us to interpolate values into our strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "They call him Brian\n"
     ]
    }
   ],
   "source": [
    "name = 'Brian'\n",
    "print(f'They call him {name}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we've interpolated the value of the variable name into our string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### Boolean Values\n",
    "Python boolean values are either `True` or `False` (capitalized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# assigning true to a variable\n",
    "booleans_are_capitalized = True\n",
    "booleans_are_capitalized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "An idiosyncrasy of Python, boolean values are always capitalized - see [PEP285](https://peps.python.org/pep-0285/) for the rationale."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##### The Null object - `None`\n",
    "`None` is a special object returned by functions (explained later) that don't explicitly return a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "x = None\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "x is null - None is always capitalized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Python sequence types\n",
    "Here we'll describe some of the Python types used to store collections of data:\n",
    "- Lists\n",
    "- Tuples\n",
    "- Sets\n",
    "- Range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Lists\n",
    "Lists are the easiest way to store collections of values. Lists can accept heterogenous values, are variable in length, and are mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 'three', True]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# declaring a list\n",
    "sample_list = [1,2,\"three\", True]\n",
    "sample_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "`sample_list` is a list with 4 values, of different types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can access elements in most Python sequences by slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "sample_list = [1,2,\"three\", True]\n",
    "# Get the value at index 0\n",
    "print(sample_list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we create a list with 4 items.\n",
    "\n",
    "We get the first item in the list - or the item at the `0` index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'three']\n"
     ]
    }
   ],
   "source": [
    "sample_list = [1,2,\"three\", True]\n",
    "# Get the values from index 0 to index 2\n",
    "print(sample_list[0:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We then get a slice of items, from the 0th index to the 3rd index(exclusive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "sample_list = [1,2,\"three\", True]\n",
    "# Get the value at the last index\n",
    "print(sample_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We use negative indexing to get the last item in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, 'three', 2, 1]\n"
     ]
    }
   ],
   "source": [
    "sample_list = [1,2,\"three\", True]\n",
    "# Get all values in reverse order\n",
    "print(sample_list[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We get all values in the list, with step `-1`. Read more about creating slices [here](https://docs.python.org/3/library/functions.html#slice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Tuples\n",
    "Tuples are similar to lists, but they are immutable. Tuples can also be unpacked into several variables in a single line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,True)\n",
    "print(x[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "First we create a tuple with 3 items.\n",
    "We then grab the item at index 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "# If a tuple has only one element it must have a comma\n",
    "y = (1,)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "\n",
    "We create another tuple with only one item - we must use this special syntax to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'tuple' object does not support item assignment\n"
     ]
    }
   ],
   "source": [
    "x = (1,2,True)\n",
    "# Cannot change element in tuple as its immutable\n",
    "try:\n",
    "    x[1] = 7\n",
    "except TypeError as exception:\n",
    "    print(exception)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "If we try to change anything in a tuple, Python throws an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# tuple unpacking\n",
    "tpl =  (1,2,3)\n",
    "a,b,c = tpl\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Conveniently, we can unpack tuples into variables in one line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Sets\n",
    "Sets are also similar to lists, they just won't contain any duplicate values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "# Creating a set with duplicate 2 values:\n",
    "x = {1,2,2,3}\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "In this tuple, we only have 3 values in the set, as Python recognises the duplicate 2s and discards one of them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Range\n",
    "`range` is a sequence type that represents an immutable sequence of numbers. Its normally used to generate numbers used in for loops:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# from 0 to 9\n",
    "print(list(range(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We create a list of the natural numbers from 0 to 9."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "# even numbers to 10\n",
    "print(list(range(2, 10, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Then we generate the numbers from 2 to 9 by specifying a step of 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# from 9 to 0\n",
    "print(list(range(9, -1, -1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Then we generate the numbers from 9 to -1, using a -1 step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Python Mapping Types\n",
    "`dict` is Python's built-in mapping type. Dicts store key-value pairs where keys must be [hashable](https://docs.python.org/3/glossary.html#term-hashable), and values can be any type. It is usually much easier, and more efficient to save and fetch values from dictionaries than from Sequence types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'banana': True, 7: 'hello_world'}\n"
     ]
    }
   ],
   "source": [
    "dictionary = {'banana':True, 7:'hello_world'}\n",
    "print(dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we create a dictionary containing two key - value pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "dictionary = {'banana':True, 7:'hello_world'}\n",
    "print(dictionary['banana'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can access the value stored with the key 'banana'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'banana': True, 7: 'hello_world', 'apple': False}\n"
     ]
    }
   ],
   "source": [
    "dictionary = {'banana':True, 7:'hello_world'}\n",
    "dictionary['apple'] = False\n",
    "print(dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can upsert key-value pairs using the indexing notation.\n",
    "\n",
    "Our dictionary now has an extra key-value pair."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sensible default value\n"
     ]
    }
   ],
   "source": [
    "dictionary = {'banana':True, 7:'hello_world'}\n",
    "# and provide a default value if key doesn't exist.\n",
    "print(dictionary.get('pear', 'sensible default value'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can pass a second parameter to the get method, which serves as a default value. If the key isn't in the dictionary, the default is returned instead.\n",
    "\n",
    "There's also the [defaultdict](https://docs.python.org/3/library/collections.html#defaultdict-objects) mapping type, which is outside the scope of this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Decision statements\n",
    "Python allows you to control the flow of the program - the simplist way by using `if` statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# try changing the value of expression to see what this code does!\n",
    "expression = True\n",
    "# if expression evaluates to True then print hello world\n",
    "# otherwise do nothing\n",
    "if expression:\n",
    "    print('hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "The expression in our if statement evaluates to `True`, so hello world is printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# try changing the value of expression to see what this code does!\n",
    "value = 7\n",
    "# if expression evaluates to True then print value is 0\n",
    "# otherwise continue to elif statement\n",
    "if value == 0:\n",
    "    print('value is 0')\n",
    "# if the value is 1\n",
    "# print value is 1\n",
    "elif value == 1:\n",
    "    print('value is 1')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we have two branches to our `if` statement. if value is 0, then 'value is 0' is printed. Otherwise, if value is 1, 'value is 1' is printed.\n",
    "if we pass any other value in, nothing will happen!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n"
     ]
    }
   ],
   "source": [
    "# try changing the value of expression to see what this code does!\n",
    "value = 'banana'\n",
    "# if expression evaluates to True then print value is 0\n",
    "# otherwise continue to elif statement\n",
    "if value == 0:\n",
    "    print('value is 0')\n",
    "# if the value is 1\n",
    "# print value is 1\n",
    "# otherwise continue to next elif statement or else statement if no more elifs.\n",
    "elif value == 1:\n",
    "    print('value is 1')\n",
    "else:\n",
    "    print('banana')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We handle the issue where the value can be anything other than 0 or 1. In that case, we print 'banana'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Loops\n",
    "\n",
    "Python has 2 main types of loop:\n",
    " - For loops.\\\n",
    "For loops work by iterating over a sequence of values. Its common to combine the range sequence type with a for loop, but any sequence type can be used.\n",
    "- While loops\n",
    "While loops check an expression every iteration, and only break out of the loop when the expression evaluates to false."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For loops\n",
    "For loops work by iterating over any Python sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# print the numbers 0 - 9\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "One-by one, we print the values from our range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cow\n",
      "sheep\n",
      "alligator\n"
     ]
    }
   ],
   "source": [
    "animals = ['cow', 'sheep', 'alligator']\n",
    "for animal in animals:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "we print the animals in our list, one-by one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "cow\n",
      "1\n",
      "sheep\n",
      "2\n",
      "alligator\n"
     ]
    }
   ],
   "source": [
    "# tuple unpacking is commonly used in for loops:\n",
    "# here enumerate returns a sequence of tuples\n",
    "# where each tuple contains an animal and its index in the list\n",
    "for index, animal in enumerate(animals):\n",
    "    print(index)\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we print the position of the animal in our list, followed by the value stored in our list. Enumerate helpfully returns a tuple of the index and value of each item in an iterable, so we can set them to variables in our loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cow\n",
      "farms\n",
      "sheep\n",
      "fields\n",
      "alligator\n",
      "swamps\n"
     ]
    }
   ],
   "source": [
    "habitats = ['farms', 'fields', 'swamps']\n",
    "# zip can be used to loop over two lists simultaneously:\n",
    "for animal, habitat in zip(animals, habitats):\n",
    "    print(animal)\n",
    "    print(habitat)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "we can use the zip funtion to combine two iterables, and loop over them together. Neat!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### While loops\n",
    "While loops check an expression every iteration, and only break out of the loop when the expression evaluates to false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running\n",
      "0\n",
      "running\n",
      "1\n",
      "running\n",
      "2\n",
      "running\n",
      "3\n",
      "running\n",
      "4\n",
      "running\n",
      "5\n",
      "running\n",
      "6\n",
      "running\n",
      "7\n",
      "running\n",
      "8\n",
      "running\n",
      "9\n",
      "stopped\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "# print the numbers 0 - 9 then stop \n",
    "while(i<10):\n",
    "    print('running')\n",
    "    print(i)\n",
    "    i+=1\n",
    "print('stopped')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We set a variable i to 0.\n",
    "\n",
    "The expression `i < 10` is evaluated, and is `True`, so we enter our first iteration of the loop.\n",
    "\n",
    "We print 'running',  then print the value of `i`, then set `i` to `i + 1`.\n",
    "\n",
    "Then the `i < 10` expression is evaluated, and we enter the next iteration of the loop.\n",
    "\n",
    "when i is not less than 10 (ie 10), the `i < 10` evaluates to `False`. We then continue executing code after the loop, here printing 'stopped'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Common to both for loops and while loops are the `break` and `continue` keywords.\n",
    "`break` causes the program to exit the loop.\n",
    "`continue` causes the current iteration of the loop to end, and the next to begin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "stopped\n"
     ]
    }
   ],
   "source": [
    "# print 0 - 3 then exit loop\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        break\n",
    "print('stopped')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "In this for loop, we evaluate whether i is equal to 3. If it is, the break statement is encountered by the Python interpreter, and we exit the loop, printing 'stopped'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "stopped\n"
     ]
    }
   ],
   "source": [
    "      \n",
    "# print 0 - 9 , but skip the number 3\n",
    "for i in range(10):\n",
    "    if i==3:\n",
    "        continue\n",
    "    print(i)\n",
    "    \n",
    "print('stopped')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "In this for loop, we evaluate whether i is equal to 3. If it is, the continue statement is encountered by the Python interpreter, and we jump to the next iteration, skipping the print statement. we can see that 3 is never printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Sequence and mapping comprehensions\n",
    "Commonly, the outcome of looping over a sequence is to generate a new sequence with calculated values. It's more efficient and readable to use a sequence comprehension to acheive this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "doubles = [i * 2 for i in numbers]\n",
    "doubles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created a new list from our list numbers, where each number is doubled."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "doubles = [i * 2 for i in numbers if i < 3]\n",
    "doubles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We can filter in our list comprehension using this syntax."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can also use mapping comprehensions to create a mapping from a sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 2, 2: 4, 3: 6, 4: 8, 5: 10}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "doubles_map = {i: i * 2 for i in numbers}\n",
    "doubles_map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created a map where each key is a value from our numbers array, and each value is the number multiplied by 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Functions\n",
    "Functions are a great way of re-using code.\n",
    "\n",
    "In Python, you can declare \"arguments\", which are variables which the function uses. Functions will also return a value, using the return statement, which allows you to use the result of some function call later in your code.\n",
    "If you don't provide a `return` statement, the function returns `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Roads? Where we’re going, we don’t need roads.\n"
     ]
    }
   ],
   "source": [
    "# a fairly useless function that just prints something to the terminal\n",
    "def print_flux_capacitor():\n",
    "    print('Roads? Where we’re going, we don’t need roads.')\n",
    "    \n",
    "# call the function\n",
    "print_flux_capacitor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "here, we've defined a flux capacitor function, which just prints a memorable quote. We then call this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# print the sum of 2 numbers:\n",
    "def print_sum(a, b):\n",
    "    print(a+b)\n",
    "\n",
    "# prints 3\n",
    "print_sum(1,2)\n",
    "\n",
    "# pass a predefined variable to a function\n",
    "x = 7\n",
    "# prints 8\n",
    "print_sum(1, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created a nice re-usable function that sums two numbers for us, and prints the result. We then call that function with 1 and 2, which prints 3!\n",
    "\n",
    "We then re-use the function, passing it the x variable and 1, getting the value 8 printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# return the sum of two numbers\n",
    "def return_sum(a, b):\n",
    "    return a + b\n",
    "    \n",
    "# store result of function in a variable\n",
    "result = return_sum(1,2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we return some information from a function. Instead of printing the result of our sum, we return it for future use - assinging it to the result variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The special syntax `*args` in function definitions in python is used to pass a variable number of arguments to a function. It is used to pass a variable-length argument list. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The special syntax `**kwargs` in function definitions in python is used to pass a keyworded argument list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first arg is: x\n",
      "kwarg fruit is: apple\n",
      "args: ('x', 1, 2)\n",
      "kwargs: {'fruit': 'apple', 'a': 'b'}\n"
     ]
    }
   ],
   "source": [
    "# prints args and kwargs\n",
    "def fancy_func(*args, **kwargs):\n",
    "    print(f'first arg is: {args[0]}')\n",
    "    print(f'kwarg fruit is: {kwargs[\"fruit\"]}')\n",
    "    print(f'args: {args}')\n",
    "    print(f'kwargs: {kwargs}')\n",
    "    \n",
    "fancy_func('x', 1, 2, fruit = 'apple', a = 'b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created a function that takes any number of arguments and keyword arguments, prints the first arg and the \"fruit\" kwarg, and then prints all args and kwargs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can also unpack a list or dictionary to pass them as arguments to a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: 1\n",
      "b: 2\n",
      "c: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum(a, b, c):\n",
    "  print(f'a: {a}')\n",
    "  print(f'b: {b}')\n",
    "  print(f'c: {c}')\n",
    "  return a + b + c\n",
    "\n",
    "first_nums = [1,2]\n",
    "last_nums = {'c':3}\n",
    "sum(*first_nums, **last_nums)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created a function which takes three parameters a, b and c, prints them, then returns the sum of those arguments.\n",
    "We've created a list of numbers to pass to the function `first_nums`. We use the special syntax `*first_nums` to pass the contents of this list in order to our function.\n",
    "We also create a dictionary called `last_nums` which we pass to the `sum` function using the special syntax `**last_nums`. Python matches keys in this dictionary with the names of arguments in the function, passing the value of `c` into the correct argument in the `sum` function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Classes and objects\n",
    "Generally, in larger peices of code, we model things as \"objects\" which use \"attributes\" to hold the state of the object, and behaviours(functions) that the objects express.\n",
    "\n",
    "Classes define what attributes and behaviours an object can have. For example, we might define a Person class, which says that people have heights, eye colours and can walk. An object in this example would be my friend Shawn, who is 180cm tall, has blonde hair and will walk to the local cafe every so often.\n",
    "\n",
    "Let's create a person class, and some people objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# defining our class\n",
    "class Person:\n",
    "    # __init__ function is an initializer in python - it's how we initialise our Person object and set initial attribute values\n",
    "    # All object functions will include a self parameter, which allows use to access attributes and behaviours of our object\n",
    "    # When an object is created, th object itself is passed to the initialiser, along with any parameters the user has entered.\n",
    "    def __init__(self, height_in_cm, hair_colour):\n",
    "        self.height_in_cm = height_in_cm\n",
    "        self.hair_colour = hair_colour\n",
    "        # we'll also set a current location attribute that defaults to home\n",
    "        self.location = 'home'\n",
    "    # lets say our people can walk to a location\n",
    "    def walk(self, location):\n",
    "        self.location = location\n",
    "    # We'll also add a function that tells Python how to print our object in a human readable way\n",
    "    # this is called a dunder function, which is outside of the scope of this course.\n",
    "    def __repr__(self):\n",
    "        return f'Person(height_in_cm:{self.height_in_cm}, hair_colour:{self.hair_colour}, location:{self.location})'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Here we've created the class `Person` - also known as a non-basic type. We've defined that people have a height and a hair colour which is defined by the creator when initialising the object. We've also added a `location` attribute that is set to 'home' by default.\n",
    "\n",
    "We've created a seperate `walk` function that allows us to change the location of an object of type Person.\n",
    "\n",
    "`__repr__` is a special function called by the Python interpreter when an object is printed. We've created this function so we can get a nicer output when we print any Person objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person(height_in_cm:180, hair_colour:blonde, location:home)\n"
     ]
    }
   ],
   "source": [
    "# Let's model my friend Shawn:\n",
    "shawn = Person(180, 'blonde')\n",
    "\n",
    "# let's see what shawn looks like:\n",
    "print(shawn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created a `Person` who's 180cm tall, with blonde hair, and assigned them to the variable `shawn`. We can then take a look at shawns attributes by printing the shawn variable, and see that they are also at home."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Person(height_in_cm:180, hair_colour:blonde, location:cafe)\n",
      "cafe\n"
     ]
    }
   ],
   "source": [
    "# we'll send shawn to grab a coffee - he should move to the cafe:\n",
    "shawn.walk('cafe')\n",
    "print(shawn)\n",
    "\n",
    "# we can also access attributes individually \n",
    "print(shawn.location)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've made `shawn` walk to the cafe!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dean is a Person(height_in_cm:195, hair_colour:brunette, location:home)\n"
     ]
    }
   ],
   "source": [
    "# or create someone else:\n",
    "dean = Person(195, 'brunette')\n",
    "print(f'Dean is a {dean}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "We've created another, different, `Person` who's a tall brunette."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using libraries\n",
    "We can leverage functions and classes that have been created and maintained by others in our own Python code by using libraries.\n",
    "To install libraries, you must use a Python package manager, such as pip or conda.\n",
    "\n",
    "Once libraries are installed, you can import them into your Python scripts using import statements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy\n",
    "numpy.zeros((2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Import NumPy library and use one of the functions contained in the NumPy library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.zeros((2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Import NumPy library, assigning it alias \"np\" and use one of the functions contained in the library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import zeros\n",
    "zeros((2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Import specific function from NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import zeros, ones\n",
    "zeros((2,3))\n",
    "ones((2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "Import multiple specific functions from NumPy"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  },
  "vscode": {
   "interpreter": {
    "hash": "7f19c980252f6c6774679d1d4ca92b8bb77765f259e722f8690d6bb5bc9454fd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}