06_Advanced_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/JamesFergusson/Research-Computing/blob/master/06_Advanced_Python.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we will look at two advanced features of Python that can be useful, Classes and Decorators\n",
    "\n",
    "## Classes\n",
    "Classes are the building blocks of object oriented programming languages like Python.  They are simply a way to bundle data and methods specific to that data together.  We have been using classes lots already. A simple example is a string like:\n",
    "\n",
    "`str1 = \"Hello\"`\n",
    "\n",
    "We originally just referred to this as a data type but it's actually a class as there are a lot of functions that can operate on `str1` which we access with the `.` notation, for example: `str.capitalize`.\n",
    "\n",
    "Classes are a useful way of keeping your code understandable by keeping functions and the data they operate on together so functions can't be misused.  You can think of it being a bit like modules for data.\n",
    "\n",
    "Let's look at some examples:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass1:\n",
    "    \"\"\" My First Class \"\"\"\n",
    "    one = 1\n",
    "    \n",
    "    def greet(self):\n",
    "        return \"Hello\"\n",
    "\n",
    "test1 = MyClass1()\n",
    "\n",
    "print(test1.one)\n",
    "print(test1.greet())\n",
    "\n",
    "test1.one = 2\n",
    "print(test1.one)\n",
    "test1.one = \"abc\"\n",
    "print(test1.one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is fairly useless but you can see that you have created a class with one data object called `one` and one method called `greet` (functions in classes are called methods).  The word `self` is there as the first argument of any function is the class object which is called `self` by convention (you are free to use anything you want but there are no good reasons not to use it).\n",
    "\n",
    "Generally we want to be able to create an object where we can initialise it's data to specific values.  To do this we use the inbuilt function `__init__()`  This is always called when the class is created and has a specific format which is best seen from example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "class CelObj1:\n",
    "    \"\"\" Class for celestial object  \"\"\"\n",
    "    def __init__(self, mass, position, velocity):\n",
    "        self.mass = mass\n",
    "        self.position = position\n",
    "        self.velocity = velocity\n",
    "        \n",
    "    def grav_pot(self, location):\n",
    "        x = location[0] - self.position[0]\n",
    "        y = location[1] - self.position[1]\n",
    "        z = location[2] - self.position[2]\n",
    "        dist = math.sqrt(x*x + y*y + z*z)\n",
    "        return 6.67e-11 * self.mass / dist\n",
    "\n",
    "        \n",
    "earth = CelObj1(6e24, [0,0,0], [3e4,0,0])\n",
    "print(earth.mass)\n",
    "print(earth.position)\n",
    "print(earth.velocity)\n",
    "print(earth.grav_pot([0,4e5,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the format is simply to have `def __init__(self,` followed by the arguments you want to assign.  You may not want to assign all values when you initialise an object so you can make the arguments optional with the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "class CelObj2:\n",
    "    \"\"\" Class for celestial object \"\"\"\n",
    "    def __init__(self, mass=None, position=None, velocity=None):\n",
    "        self.mass = mass or 0.\n",
    "        self.position = position or [0.,0.,0.]\n",
    "        self.velocity = velocity or [0.,0.,0.]\n",
    "        \n",
    "    def grav_pot(self, location):\n",
    "        x = location[0] - self.position[0]\n",
    "        y = location[1] - self.position[1]\n",
    "        z = location[2] - self.position[2]\n",
    "        dist = math.sqrt(x*x + y*y + z*z)\n",
    "        return 6.67e-11 * self.mass / dist\n",
    "\n",
    "        \n",
    "earth = CelObj2(6e24)\n",
    "print(earth.mass)\n",
    "print(earth.position)\n",
    "print(earth.velocity)\n",
    "venus = CelObj2(position=[1.,2.,3.])\n",
    "print(venus.mass)\n",
    "print(venus.position)\n",
    "print(venus.velocity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `or` construct is just a short version of:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (mass):\n",
    "    self.mass = mass\n",
    "else:\n",
    "    self.mass = 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we have used `position=None` to avoid the issues with assigning empty lists for functions.  The `or` construct is nice and compact but not perfect as it just tests the object to see if it evaluates to `True` or `False` so the following will also fail. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "class CelObj2:\n",
    "    \"\"\" Class for celestial object \"\"\"\n",
    "    def __init__(self, mass=None, position=None, velocity=None):\n",
    "        self.mass = mass or 9999.\n",
    "        self.position = position or [0.,0.,0.]\n",
    "        self.velocity = velocity or [0.,0.,0.]\n",
    "        \n",
    "    def grav_pot(self, location):\n",
    "        x = location[0] - self.position[0]\n",
    "        y = location[1] - self.position[1]\n",
    "        z = location[2] - self.position[2]\n",
    "        dist = math.sqrt(x*x + y*y + z*z)\n",
    "        return 6.67e-11 * self.mass / dist\n",
    "\n",
    "        \n",
    "earth = CelObj2(6e24)\n",
    "print(earth.mass)\n",
    "earth = CelObj2(0)\n",
    "print(earth.mass)\n",
    "earth = CelObj2(False)\n",
    "print(earth.mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For these cases we should write:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "class CelObj2:\n",
    "    \"\"\" Class for celestial object \"\"\"\n",
    "    def __init__(self, mass=None, position=None, velocity=None):\n",
    "        if (mass is not None):\n",
    "            self.mass = mass\n",
    "        else:\n",
    "            self.mass = 9999.\n",
    "        self.position = position or [0.,0.,0.]\n",
    "        self.velocity = velocity or [0.,0.,0.]\n",
    "        \n",
    "    def grav_pot(self, location):\n",
    "        x = location[0] - self.position[0]\n",
    "        y = location[1] - self.position[1]\n",
    "        z = location[2] - self.position[2]\n",
    "        dist = math.sqrt(x*x + y*y + z*z)\n",
    "        return 6.67e-11 * self.mass / dist\n",
    "\n",
    "        \n",
    "earth = CelObj2(6e24)\n",
    "print(earth.mass)\n",
    "earth = CelObj2(0)\n",
    "print(earth.mass)\n",
    "earth = CelObj2(False)\n",
    "print(earth.mass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above we had to do three `print` statements to find out what the data associated with each planet object was.  It would be much nicer if we could just do something like `print(earth)` and get it all.  We can do this with the special method `__str__` which returns a string and is called whenever you use print on the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "class CelObj3:\n",
    "    \"\"\" Class for celestial object  \"\"\"\n",
    "    def __init__(self, mass=None, position=None, velocity=None):\n",
    "        self.mass = mass or 0.\n",
    "        self.position = position or [0.,0.,0.]\n",
    "        self.velocity = velocity or [0.,0.,0.]\n",
    "        \n",
    "    def grav_pot(self, location):\n",
    "        x = location[0] - self.position[0]\n",
    "        y = location[1] - self.position[1]\n",
    "        z = location[2] - self.position[2]\n",
    "        dist = math.sqrt(x*x + y*y + z*z)\n",
    "        return 6.67e-11 * self.mass / dist\n",
    "    \n",
    "    def __str__(self):\n",
    "        mas = '{:.2e}'.format(self.mass)\n",
    "        pos = '({0[0]:.2e},{0[1]:.2e},{0[2]:.2e})'.format(self.position)\n",
    "        vel = '({0[0]:.2e},{0[1]:.2e},{0[2]:.2e})'.format(self.velocity)\n",
    "        return 'Mass: ' + mas + '  Position: ' + pos + '  Velocity: '+vel\n",
    "        \n",
    "        \n",
    "earth = CelObj3(6e24)\n",
    "print(earth)\n",
    "earth = CelObj3(False)\n",
    "print(earth)\n",
    "venus = CelObj3(position=[1.,2.,3.])\n",
    "print(venus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many, many of these special methods that allow you to do all sorts of cool things.  Here are some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "class Vector3D:\n",
    "    \"\"\" Vector Class \"\"\"\n",
    "    def __init__(self, x=None, y=None, z=None):\n",
    "        self.x = x or 0\n",
    "        self.y = y or 0\n",
    "        self.z = z or 0\n",
    "        \n",
    "    def __add__(self, obj):\n",
    "        x = self.x + obj.x\n",
    "        y = self.y + obj.y\n",
    "        z = self.z + obj.z\n",
    "        return Vector3D(x,y,z)\n",
    "        \n",
    "    def __sub__(self, obj):\n",
    "        x = self.x - obj.x\n",
    "        y = self.y - obj.y\n",
    "        z = self.z - obj.z\n",
    "        return Vector3D(x,y,z)\n",
    "    \n",
    "    def size(self):\n",
    "        return math.sqrt(self.x*self.x + self.y*self.y + self.z*self.z)\n",
    "        \n",
    "    def __lt__(self, obj):\n",
    "        l1 = self.size()\n",
    "        l2 = obj.size()\n",
    "        return l1<l2\n",
    "    \n",
    "    def __str__(self):\n",
    "        return '({0},{1},{2})'.format(self.x,self.y,self.z)\n",
    "    \n",
    "vec1 = Vector3D(1,2,3)\n",
    "vec2 = Vector3D(4,5,6)\n",
    "vec3 = Vector3D(0,1,2)\n",
    "vec4 = Vector3D(-1,0,1)\n",
    "print(vec1+vec2)\n",
    "print(vec3-vec4)\n",
    "list1 = [vec1,vec2,vec3,vec4]\n",
    "print(vec1)\n",
    "print(list1[0])\n",
    "list1.sort() # this works as we have defined a less than operator, __lt__, which is used by sort.\n",
    "print(list1[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you would expect there is also all binary operations:\n",
    "\n",
    "`object.__add__(self, other)\n",
    "object.__sub__(self, other)\n",
    "object.__mul__(self, other)\n",
    "object.__truediv__(self, other)\n",
    "object.__floordiv__(self, other)\n",
    "object.__mod__(self, other)\n",
    "object.__divmod__(self, other)\n",
    "object.__pow__(self, other[, modulo])\n",
    "object.__lshift__(self, other)\n",
    "object.__rshift__(self, other)\n",
    "object.__and__(self, other)\n",
    "object.__xor__(self, other)\n",
    "object.__or__(self, other)`\n",
    "\n",
    "and all comparators\n",
    "\n",
    "`object.__lt__(self, other)\n",
    "object.__le__(self, other)\n",
    "object.__eq__(self, other)\n",
    "object.__ne__(self, other)\n",
    "object.__gt__(self, other)\n",
    "object.__ge__(self, other)`\n",
    "\n",
    "There are also things like `__len__` which returns an integer when the `len()` function is used and `__iter__` and `__next__` which make the class work as an iterator, see below for an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FibPair:\n",
    "        def __init__(self, a=None, b=None):\n",
    "            self.a = a or 0\n",
    "            self.b = b or 1\n",
    "        \n",
    "        def __iter__(self):\n",
    "            return self\n",
    "        \n",
    "        def __next__(self):\n",
    "            self.a,self.b = self.b,self.a+self.b\n",
    "            return self\n",
    "        \n",
    "        def __str__(self):\n",
    "            return '({0},{1})'.format(self.a,self.b)\n",
    "\n",
    "pair1 = FibPair(0,1)\n",
    "print(next(pair1))\n",
    "print(next(pair1))\n",
    "print(next(pair1))\n",
    "print(next(pair1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inheritance\n",
    "\n",
    "You can define subclasses which inherit characteristics from classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import math\n",
    "class CelObj:\n",
    "    \"\"\" Class for celestial object  \"\"\"\n",
    "    def __init__(self, mass=None, position=None, velocity=None):\n",
    "        self.mass = mass or 0.\n",
    "        self.position = position or [0.,0.,0.]\n",
    "        self.velocity = velocity or [0.,0.,0.]\n",
    "        \n",
    "    def grav_pot(self, location):\n",
    "        x = location[0] - self.position[0]\n",
    "        y = location[1] - self.position[1]\n",
    "        z = location[2] - self.position[2]\n",
    "        dist = math.sqrt(x*x + y*y + z*z)\n",
    "        return 6.67e-11 * self.mass / dist\n",
    "    \n",
    "    def __lt__(self, obj):\n",
    "        l1 = self.mass\n",
    "        l2 = obj.mass\n",
    "        return l1<l2\n",
    "    \n",
    "    def __str__(self):\n",
    "        mas = '{:.2e}'.format(self.mass)\n",
    "        pos = '({0[0]:.2e},{0[1]:.2e},{0[2]:.2e})'.format(self.position)\n",
    "        vel = '({0[0]:.2e},{0[1]:.2e},{0[2]:.2e})'.format(self.velocity)\n",
    "        return 'Mass: ' + mas + '  Position: ' + pos + '  Velocity: '+vel\n",
    "\n",
    "class Star(CelObj):\n",
    "    def __init__(self, mass=None, position=None, velocity=None, age=None):\n",
    "        CelObj.__init__(self,mass,position,velocity)\n",
    "        self.age = age or 0.\n",
    "    \n",
    "    def __lt__(self, obj):\n",
    "        l1 = self.age\n",
    "        l2 = obj.age\n",
    "        return l1<l2\n",
    "        \n",
    "    def __str__(self):\n",
    "        std = CelObj.__str__(self)\n",
    "        age = '  Age: {:.2e}'.format(self.age)\n",
    "        return std+age\n",
    "    \n",
    "class Planet(CelObj):\n",
    "    def __init__(self, mass=None, position=None, velocity=None, name=None):\n",
    "        CelObj.__init__(self,mass,position,velocity)\n",
    "        self.name = name or 'Unknown'\n",
    "        \n",
    "    def __str__(self):\n",
    "        std = CelObj.__str__(self)\n",
    "        nme = '  Name: {}'.format(self.name)\n",
    "        return std+nme\n",
    "        \n",
    "earth = Planet(6e24, [1,5e9,0,0], [0,3e4,0], name=\"Earth\")\n",
    "asteroid = CelObj(6e5, [2e10,1e9,3e6], [4e6,2e4,1e5])\n",
    "sun = Star(2e30, age=4.6e9)\n",
    "print(earth)\n",
    "print(asteroid)\n",
    "print(sun)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorators\n",
    "\n",
    "Another advanced feature in Python which can be useful are decorators.  Decorators are functions for functions and they takes a little bit of getting used too.  They are not used so much in scientific programming but I'll cover them as there are a couple of good use cases and also so if you come across them in other peoples code you know what is going on.\n",
    "\n",
    "All functions in python can take functions (or any object) as arguments.  Here is a simple example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_sign(func,x):\n",
    "    return -func(x)\n",
    "\n",
    "def times_two(x):\n",
    "    return 2e0*x\n",
    "\n",
    "x=3e0\n",
    "\n",
    "print(change_sign(times_two,x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far so trivial. This isn't very generic as we had to specify the arguments for the function.  We could generalise it with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_sign(func,*args, **kwargs):\n",
    "    return -func(*args, **kwargs)\n",
    "\n",
    "def times_two(x):\n",
    "    return 2e0*x\n",
    "\n",
    "def product(x,y):\n",
    "    return x*y\n",
    "\n",
    "x=3e0\n",
    "y=4e0\n",
    "\n",
    "print(change_sign(times_two,x))\n",
    "print(change_sign(product,x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have a generic function that can change the sign of the output of any function you pass it.  This is still a bit clunky.  We would really like a function that changed the way the input function actually worked. We can do this by making `change_sign` return a function rather than the output of a function. To do this we need to create a wrapping function inside `change_sign`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_sign(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        return -func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "def times_two(x):\n",
    "    return 2e0*x\n",
    "\n",
    "def product(x,y):\n",
    "    return x*y\n",
    "\n",
    "x=3e0\n",
    "y=4e0\n",
    "\n",
    "times_minus_two = change_sign(times_two)\n",
    "\n",
    "print(times_minus_two(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have a function that will modify any function to output the opposite.  It's still a bit of a pain to have to redefine all of our functions like above, luckily Python has a great shorthand for this: decorators!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def change_sign(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        return -func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@change_sign\n",
    "def times_two(x):\n",
    "    return 2e0*x\n",
    "\n",
    "@change_sign\n",
    "def product(x,y):\n",
    "    return x*y\n",
    "\n",
    "x=3e0\n",
    "y=4e0\n",
    "\n",
    "print(times_two(x))\n",
    "print(product(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one more thing to fix which is that currently both product and times_two are confused about their names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "help(times_two)\n",
    "help(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is corrected by adding a special command which makes sure functions keep their names after wrapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "def change_sign(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        return -func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@change_sign\n",
    "def times_two(x):\n",
    "    return 2e0*x\n",
    "\n",
    "@change_sign\n",
    "def product(x,y):\n",
    "    return x*y\n",
    "\n",
    "help(times_two)\n",
    "help(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorators are often used for things like controlling access to functions with decorators like `login_required` or `staff_only` which will ask for the user to login before running or check the users status before allowing access. It's easy to see how useful these are for general programming but what can scientists use them for?  One good use case is to use a decorator to output the input and output of functions for debugging.  It is useful to have this with a flag that turns it on and off so you can run the code in debug mode for any specific functions just by adding the decorator to their definitions.\n",
    "\n",
    "Debug decorator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "\n",
    "debug_flag = True\n",
    "\n",
    "def debug(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        if debug_flag:\n",
    "            arguments = [f\"{a}\" for a in args]\n",
    "            karguments = [f\"{k}={v}\" for k,v in kwargs.items()]\n",
    "            name = func.__name__\n",
    "            print(\"Calling \"+name+\" with args: \"+\", \".join(arguments)+\" and kwargs: \"+\", \".join(karguments))\n",
    "            value = func(*args, **kwargs)\n",
    "            print(\"Run function: \"+name+\", which output: \"+repr(value))\n",
    "            return value\n",
    "        else:\n",
    "            return func(*args, **kwargs)\n",
    "    return wrapper\n",
    "\n",
    "@debug\n",
    "def times_two(x):\n",
    "    return 2e0*x\n",
    "\n",
    "print(times_two(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful decorator would be one to time how long specific functions take. In numpy there are some built in decorators like `np.vectorize` which modify simple functions to take vector input. My solution for notebook 3 used the explicit version of it on my function `intmono`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "...\n",
    "\n",
    "# Vectorise just converts a scalar function to one that accepts vectors\n",
    "# Needed for numpy.fromfunction\n",
    "tmp = np.vectorize(intmono)\n",
    "\n",
    "# Creates an array with entries calculated from the function which takes array indexes as input\n",
    "M = np.fromfunction(tmp,(6,6))\n",
    "\n",
    "..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "here we could have used `@np.vectorize` on the definition of `intmono` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@np.vectorize\n",
    "def intmono(n,m):\n",
    "    \n",
    "...\n",
    "\n",
    "# Creates an array with entries calculated from the function which takes array indexes as input\n",
    "M = np.fromfunction(intmono,(6,6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "Build a class for fractions (python already has one of these but we'll pretend that it doesn't for now so don't call it \"fraction\"). The class should do the following:\n",
    "1. Store fractions as number pairs eg: 3/4 = (3,4)\n",
    "2. Have a definitions for +,-,*,/,<,>,=\n",
    "3. Have a function reduce that takes the fraction to its lowest terms, i.e. (2,4) -> (1,2)\n",
    "4. Returns a sensible expression to print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise:\n",
    "Design a decorator to time how long functions take to run and output it as a string.\n",
    "You will need commands from the built-in module `time`\n",
    "\n",
    "Another is to `cache` results for a function.  This just memorises the output for a specific input so if it's called again the function just returns the answer from memory.  This can help with performance but is a bit beyond this course, an example given in solutions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorators can be used to do some cool things but are fairly advanced and you'll need to spend some time to understand how they work in detail, they're not often covered in introductory books.  I think this is a good place to start:\n",
    "\n",
    "https://realpython.com/primer-on-python-decorators/\n",
    "\n",
    "If nothing else at least if you see the `@` line in some code you'll know what it's doing as otherwise it's not clear at all from context.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}