classes_class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why do we need them?\n",
    "\n",
    "We'll use a common modelling task as an example to show why classes are useful.  \n",
    "\n",
    "You have some model that requires imagery and meteorological data as inputs. The data requires processing before it can be used by the model. At first you're content with one combination of data and parameters so you don't bother with functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# general parameters\n",
    "time_start = ___ \n",
    "time_end = ___ \n",
    "geographic_extent = ___ \n",
    "folder_output  = ___\n",
    "\n",
    "# imagery parameters\n",
    "folder_images = ___ \n",
    "resolution = ___ \n",
    "bands = ___ \n",
    "\n",
    "# meteorology parameters\n",
    "folder_met = ___ \n",
    "met_columns = ___\n",
    "\n",
    "# model parameters\n",
    "grid_type = ___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How most scripts start out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load images\n",
    "# code\n",
    "\n",
    "# process images\n",
    "# code\n",
    "\n",
    "# load met\n",
    "# code\n",
    "\n",
    "# run model\n",
    "# code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if you want to compare several datasets?\n",
    "\n",
    "At this point you'd take your code and throw it in a function, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_pipeline(\n",
    "    time_start, time_end, geographic_extent, # general parameters\n",
    "    folder_images, resolution, bands, # imagery parameters\n",
    "    folder_met, met_columns, # meteorology parameters\n",
    "    grid_type): # model parameters\n",
    "    \n",
    "    # load images\n",
    "    # code\n",
    "\n",
    "    # process images\n",
    "    # code\n",
    "\n",
    "    # load met\n",
    "    # code\n",
    "\n",
    "    # run model\n",
    "    # code\n",
    "    return result\n",
    "\n",
    "# dataset 1\n",
    "result1 = run_pipeline(\n",
    "    time_start, time_end, geographic_extent,\n",
    "    folder_images1, resolution, bands,\n",
    "    folder_met1, met_columns,\n",
    "    grid_type)\n",
    "\n",
    "# dataset 2\n",
    "result2 = run_pipeline(\n",
    "    time_start, time_end, geographic_extent,\n",
    "    folder_images2, resolution, bands,\n",
    "    folder_met2, met_columns,\n",
    "    grid_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But what if you want to compare several grid types without reloading all the data?\n",
    "\n",
    "Now you'd consider breaking up your function into smaller functions so you can avoid repeating parts unnecessarily:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_images(folder_images, time_start, time_end, geographic_extent):\n",
    "    # code\n",
    "    return images\n",
    "\n",
    "def process_images(images, resolution, bands):\n",
    "    # code\n",
    "    return images\n",
    "\n",
    "def load_met(folder_met, time_start, time_end, geographic_extent, met_columns):\n",
    "    # code\n",
    "    return met\n",
    "\n",
    "def run_model(images, met, time_start, time_end, geographic_extent, grid_type):\n",
    "    # code\n",
    "    return result\n",
    "\n",
    "# load and process data\n",
    "images = load_images(folder_images, time_start, time_end, geographic_extent)\n",
    "images = process_images(images, resolution, bands)\n",
    "met = load_met(folder_met, time_start, time_end, geographic_extent, met_columns)\n",
    "\n",
    "# grid type 1\n",
    "result1 = run_model(images, met, time_start, time_end, geographic_extent, grid_type1)\n",
    "\n",
    "# grid type 2\n",
    "result2 = run_model(images, met, time_start, time_end, geographic_extent, grid_type2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, it starts getting messy to pass variables between many small functions. This can get out of hand quickly when you have several permutations of every parameter. It becomes increasingly difficult to keep track of all your data, parameters and results. The solution in this case is to use classes. \n",
    "\n",
    "Classes are like \"blueprints\" for a set of functions and variables. They are useful when you need to work with variations on a set of operations. Here's how a class might look and be used for the problems we faced:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pipeline:\n",
    "    def __init__(self, time_start, time_end, geographic_extent):\n",
    "        # code\n",
    "            \n",
    "    def load_images(self, folder_images):\n",
    "        # code\n",
    "        \n",
    "    def process_images(self, resolution, bands):\n",
    "        # code\n",
    "        \n",
    "    def load_met(self, folder_met):\n",
    "        # code\n",
    "        \n",
    "    def run_model(self, grid_type):\n",
    "        # code\n",
    "\n",
    "# run pipeline with grid type 1\n",
    "pipeline1 = Pipeline(time_start, time_end, geographic_extent)\n",
    "pipeline1.load_images(folder_images)\n",
    "pipeline1.process_images(resolution, bands)\n",
    "pipeline1.load_met(folder_met)\n",
    "pipeline1.run_model(grid_type1)\n",
    "print(pipeline1.result)\n",
    "\n",
    "# try with grid type 2, but don't reload data\n",
    "pipeline2 = Pipeline(time_start, time_end, geographic_extent)\n",
    "pipeline2.images = pipeline1.images\n",
    "pipeline2.met = pipeline1.met\n",
    "pipeline2.run_model(grid_type2)\n",
    "print(pipeline2.result)\n",
    "\n",
    "# add a note to pipeline1\n",
    "pipeline1.note = 'this was an interesting model run'\n",
    "\n",
    "# see a single attribute of a pipeline\n",
    "print(pipeline1.grid_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`'grid_type1'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# see all attributes of a pipeline\n",
    "print(vars(pipeline1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{'time_start': ___, \n",
    " 'time_end': ___, \n",
    " 'geographic_extent': ___, \n",
    " 'folder_images': ___, \n",
    " 'resolution': ___, \n",
    " 'bands': ___, \n",
    " 'folder_met': ___, \n",
    " 'grid_type': 'grid_type1',\n",
    " 'note': 'this was an interesting model run'}```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another useful feature of using classes is that you can pass your class instances (e.g. a pipeline) around as a package. \n",
    "\n",
    "The advantage of doing this is they then bring with them all of their attributes, so you don't need to think about it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_pipelines(pipelines):\n",
    "    # code\n",
    "    return pipelines_merged\n",
    "\n",
    "# \"merge\" two pipelines\n",
    "pipelines_merged = merge_pipelines([pipeline1, pipeline2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes also make it very easy to save and load your data as a package including attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "# save your entire pipeline, data and all\n",
    "pickle.dump(pipeline, open(\"pipeline.pickle\", \"wb\"))\n",
    "    \n",
    "# save your pipeline without data\n",
    "del pipeline.images\n",
    "del pipeline.met\n",
    "pickle.dump(pipeline, open(\"pipeline_nodata.pickle\", \"wb\"))\n",
    "    \n",
    "# load your pipeline\n",
    "pipeline = pickle.load(open(\"pipeline.pickle\", \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### You're already using classes!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most common packages you're familiar with make liberal use of classes. You've been using them for years without realising.\n",
    "\n",
    "For example, pandas' `DataFrame` is a class that has associated functions, such as `describe`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>150.000000</td>\n",
       "      <td>150.000000</td>\n",
       "      <td>150.000000</td>\n",
       "      <td>150.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>5.843333</td>\n",
       "      <td>3.057333</td>\n",
       "      <td>3.758000</td>\n",
       "      <td>1.199333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.828066</td>\n",
       "      <td>0.435866</td>\n",
       "      <td>1.765298</td>\n",
       "      <td>0.762238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>4.300000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>5.100000</td>\n",
       "      <td>2.800000</td>\n",
       "      <td>1.600000</td>\n",
       "      <td>0.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>5.800000</td>\n",
       "      <td>3.000000</td>\n",
       "      <td>4.350000</td>\n",
       "      <td>1.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>6.400000</td>\n",
       "      <td>3.300000</td>\n",
       "      <td>5.100000</td>\n",
       "      <td>1.800000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>7.900000</td>\n",
       "      <td>4.400000</td>\n",
       "      <td>6.900000</td>\n",
       "      <td>2.500000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       sepal_length  sepal_width  petal_length  petal_width\n",
       "count    150.000000   150.000000    150.000000   150.000000\n",
       "mean       5.843333     3.057333      3.758000     1.199333\n",
       "std        0.828066     0.435866      1.765298     0.762238\n",
       "min        4.300000     2.000000      1.000000     0.100000\n",
       "25%        5.100000     2.800000      1.600000     0.300000\n",
       "50%        5.800000     3.000000      4.350000     1.300000\n",
       "75%        6.400000     3.300000      5.100000     1.800000\n",
       "max        7.900000     4.400000      6.900000     2.500000"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# load and descibe the classic 'iris' dataset\n",
    "df =  pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv')\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another nice thing about classes is we can see which functions they contain. \n",
    "\n",
    "We know these functions are specifically designed to work with the data the class holds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list all functions within the pd.DataFrame class\n",
    "[func for func in dir(pd.DataFrame) if callable(getattr(pd.DataFrame, func))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, you can always pull up the documentation of any of these functions that take your interest.\n",
    "\n",
    "You can do this by prepending a function with `?` or by pressing `shift + tab` with your cursor anywhere in the name. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?pd.DataFrame.sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can treat a dataframe the same way you would any other class instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_is_copy': None,\n",
       " '_mgr': BlockManager\n",
       " Items: Index(['sepal_length', 'sepal_width', 'petal_length', 'petal_width',\n",
       "        'species'],\n",
       "       dtype='object')\n",
       " Axis 1: RangeIndex(start=0, stop=150, step=1)\n",
       " FloatBlock: slice(0, 4, 1), 4 x 150, dtype: float64\n",
       " ObjectBlock: slice(4, 5, 1), 1 x 150, dtype: object,\n",
       " '_item_cache': {},\n",
       " '_attrs': {},\n",
       " 'note': 'I love dataframes'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.note = 'I love dataframes'\n",
    "vars(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is getting a bit more advanced, but you can even go further and extend classes with more functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MagicDataFrame(pd.DataFrame):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "        \n",
    "    def magic(self):\n",
    "        print(f\"You're a wizard, {self.wizards[0]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>wizards</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Harry</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  wizards\n",
       "0   Harry"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_magic = MagicDataFrame({'wizards':['Harry']})\n",
    "df_magic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're a wizard, Harry\n"
     ]
    }
   ],
   "source": [
    "df_magic.magic()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![harry](https://i.ytimg.com/vi/vUN7yu7zvz8/hqdefault.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to use classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a copy of the code on: https://www.w3schools.com/python/python_classes.asp\n",
    "\n",
    "Python is an object oriented programming language. Almost everything in Python is an object, with its properties and methods. A Class is like an object constructor, or a \"blueprint\" for creating objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a class\n",
    "\n",
    "To create a class, use the keyword `class`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    x = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an object\n",
    "\n",
    "Now we can use the class named `MyClass` to create objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "p1 = MyClass()\n",
    "print(p1.x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `__init__()` function\n",
    "\n",
    "The examples above are classes and objects in their simplest form, and are not really useful in real life applications. To understand the meaning of classes we have to understand the built-in `__init__()` function. All classes have a function called `__init__()`, which is always executed when the class is being initiated. Use the `__init__()` function to assign values to object properties, or other operations that are necessary to do when the object is being created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "p1 = Person(\"John\", 36)\n",
    "\n",
    "print(p1.name)\n",
    "print(p1.age) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'John', 'age': 36}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object methods\n",
    "\n",
    "Objects can also contain methods. Methods in objects are functions that belong to the object. Let us create a method in the Person class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello my name is John\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "    def myfunc(self):\n",
    "        print(\"Hello my name is \" + self.name)\n",
    "\n",
    "p1 = Person(\"John\", 36)\n",
    "p1.myfunc() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `self` parameter\n",
    "\n",
    "The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class. It does not have to be named \"self\", you can call it whatever you like, but it has to be the first parameter of any function in the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello my name is John\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(mysillyobject, name, age):\n",
    "        mysillyobject.name = name\n",
    "        mysillyobject.age = age\n",
    "        \n",
    "        \n",
    "    def myfunc(abc):\n",
    "        print(\"Hello my name is \" + abc.name)\n",
    "\n",
    "p1 = Person(\"John\", 36)\n",
    "p1.myfunc() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modify object properties\n",
    "\n",
    "You can modify properties on objects like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1.age = 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Append object properties\n",
    "\n",
    "You can append properties to objects like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1.height = 180"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete object properties\n",
    "\n",
    "You can delete properties on objects by using the `del` keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "del p1.age "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python inheritance\n",
    "\n",
    "Inheritance allows us to define a class that inherits all the methods and properties from another class. Parent class is the class being inherited from, also called base class. Child class is the class that inherits from another class, also called derived class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a parent class\n",
    "\n",
    "Any class can be a parent class, so the syntax is the same as creating any other class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Doe\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, fname, lname):\n",
    "        self.firstname = fname\n",
    "        self.lastname = lname\n",
    "        \n",
    "    def printname(self):\n",
    "        print(self.firstname, self.lastname)\n",
    "\n",
    "# Use the Person class to create an object, and then execute the printname method:\n",
    "\n",
    "x = Person(\"John\", \"Doe\")\n",
    "x.printname() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a child class\n",
    "\n",
    "To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "    pass "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the Student class has the same properties and methods as the Person class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mike Olsen\n"
     ]
    }
   ],
   "source": [
    "x = Student(\"Mike\", \"Olsen\")\n",
    "x.printname() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add the `__init__()` function\n",
    "\n",
    "So far we have created a child class that inherits the properties and methods from its parent. We want to add the `__init__()` function to the child class (instead of the pass keyword)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, fname, lname):\n",
    "    # add properties etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you add the `__init__()` function, the child class will no longer inherit the parent's `__init__()` function.\n",
    "\n",
    "Note: The child's `__init__()` function overrides the inheritance of the parent's `__init__()` function.\n",
    "\n",
    "To keep the inheritance of the parent's `__init__()` function, add a call to the parent's `__init__()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, fname, lname):\n",
    "        Person.__init__(self, fname, lname) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have successfully added the `__init__()` function, and kept the inheritance of the parent class, and we are ready to add functionality in the `__init__()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use the `super()` function\n",
    "\n",
    "Python also has a `super()` function that will make the child class inherit all the methods and properties from its parent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, fname, lname):\n",
    "        super().__init__(fname, lname) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By using the `super()` function, you do not have to use the name of the parent element, it will automatically inherit the methods and properties from its parent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add properties"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extend the `Person` class with a `year` property. To do this we add another parameter in the `__init__()` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019\n"
     ]
    }
   ],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, fname, lname, year):\n",
    "        super().__init__(fname, lname)\n",
    "        self.graduationyear = year\n",
    "\n",
    "x = Student(\"Mike\", \"Olsen\", 2019) \n",
    "print(x.graduationyear)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can go a step further and extend the `Person` class with more methods, as below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Mike Olsen to the class of 2019\n"
     ]
    }
   ],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, fname, lname, year):\n",
    "        super().__init__(fname, lname)\n",
    "        self.graduationyear = year\n",
    "\n",
    "    def welcome(self):\n",
    "        print(\"Welcome\", self.firstname, self.lastname, \"to the class of\", self.graduationyear) \n",
    "        \n",
    "x = Student(\"Mike\", \"Olsen\", 2019) \n",
    "x.welcome()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create your own class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Rewrite the pipeline code below into a class\n",
    "2. Initialise two class instances using the parameters given\n",
    "3. Run the class method(s) of each instance to display two processed images\n",
    "4. Create a function to combine the two processed images into a 2-channel image (don't forget the 2-channel nodata mask)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The old way of doing things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# parameters 1\n",
    "dims1 = (100, 80, 3)\n",
    "chan_dim1 = 2\n",
    "bit_depth1 = 14\n",
    "nodata_value1 = -1\n",
    "\n",
    "# parameters 2\n",
    "dims2 = (1, 100, 80)\n",
    "chan_dim2 = 0\n",
    "bit_depth2 = 8\n",
    "nodata_value2 = -9999\n",
    "\n",
    "## pipeline 1\n",
    "# create image\n",
    "img = np.random.randint(low=0, high=2**bit_depth1, size=dims1)\n",
    "# rearrange image array for consistent channel ordering\n",
    "img = np.swapaxes(img, axis1=chan_dim1, axis2=0)\n",
    "# create mask for nodata values\n",
    "nodata = img == nodata_value\n",
    "# convert brightness values to 0-1 range\n",
    "img = img.astype(float) / 2**bit_depth1\n",
    "# convert to panchromatic image if not already\n",
    "img = np.mean(img, axis=0)\n",
    "# plot image\n",
    "plt.imshow(img); plt.colorbar(); plt.show()\n",
    "\n",
    "## pipeline 2\n",
    "# ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The classy way of doing things:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "### your code here!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practise inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you've got the hang of creating your own classes, here's a final exercise to build on previously defined classes:\n",
    "\n",
    "1. Create a new class that inherits from the one you wrote above.\n",
    "2. Create a class method that clips the processed image to a maximum of `clip_value3`.\n",
    "2. Initialise this new class with the 3rd set of parameters below.\n",
    "3. Display the processed, clipped image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameters 3\n",
    "dims3 = (100, 80, 3)\n",
    "chan_dim3 = 2\n",
    "bit_depth3 = 12\n",
    "nodata_value3 = -100\n",
    "clip_value3 = 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "### your code here!"
   ]
  }
 ],
 "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.8.5"
  },
  "toc-autonumbering": true,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}