07-OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Object-oriented programming\n",
    "\n",
    "In this notebook, we'll encounter **objects** and their use in Python.\n",
    "\n",
    "### At the end of this notebook, you'll be able to:\n",
    "* Access attributes and execute methods of objects\n",
    "* Define classes and recognize class definition syntax\n",
    "* Understand how to manipulate instances of a class\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<font color='Red'><font size = 8>Everything in Python is an object.</font></font>\n",
    "\n",
    "<font color='Orange'><font size = \"10\">Everything in Python is an object.</font></font>\n",
    "\n",
    "<font color='Green'><font size = \"10\">Everything in Python is an object.</font></font>\n",
    "\n",
    "<font color='Blue'><font size = \"10\">Everything in Python is an object.</font></font>\n",
    "\n",
    "<font color='Purple'><font size = \"10\">Everything in Python is an object.</font></font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Objects** are an organization of data (**attributes**), with associated code to operate on that data (functions defined on the objects, called **methods**).\n",
    "\n",
    "Syntax:\n",
    "```\n",
    "obj.method()\n",
    "obj.attribute\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Question for consideration**: Given what we’ve discussed in this course so far, if you wanted to store information about a date, how would you do so?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store information about a date here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example object: Date\n",
    "Date is **class** module that we can import from the built-in **module** [datetime](https://docs.python.org/3/library/datetime.html). Modules can contain any combination of functions, classes, or variables, that become accessible once we import them.\n",
    "\n",
    "Let's use `date` to demonstrate the features of an object in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Import date from datetime module\n",
    "from datetime import date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Set the data we want to store in our date object\n",
    "day = 25\n",
    "month = 1\n",
    "year = 2000\n",
    "\n",
    "# Create a date object\n",
    "my_date = date(year, month, day)\n",
    "print(my_date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check what type of thing `my_date` is\n",
    "type(my_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can check what attributes and methods an object has by using `.` after your variable name. You can also check more generally for the object type by using `date.` Alternatively, you can use `dir()` to check.\n",
    "\n",
    "**Attributes** maintain the object's state, simply returning information about the object to you (e.g., day, time, year)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_date."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Methods** are functions that belong to and operate on the object directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Method to return what day of the week the date is\n",
    "# Note the parentheses for methods.\n",
    "my_date.weekday()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Many objects also have very useful operations associated with them. For example, date allows us to subtract to find the difference between two dates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Define a second date\n",
    "my_date2 = date(1980, 7, 29)\n",
    "\n",
    "# Calculate the difference between times\n",
    "time_diff = my_date - my_date2\n",
    "print(time_diff.days,  \"days\") #in days\n",
    "print(time_diff.days/365,\"years\") #in years"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Another useful module is `datetime`. We can use it to print today's date, for example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Datetime is from the same package as date\n",
    "from datetime import datetime\n",
    "\n",
    "now = datetime.today()\n",
    "\n",
    "now.microsecond"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Methods for strings and lists\n",
    "\n",
    "There are many methods for strings, [see a list here](https://www.w3schools.com/python/python_ref_string.asp).\n",
    "\n",
    "For example, we can make strings upper or lower case.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a string all lower case\n",
    "'IMMA LET YOU FINISH'.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make a string all upper case\n",
    "'wait a second'.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Check your understanding** What will the following code print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = ['fIx', 'tYpiNg', 'lIkE', 'tHiS']\n",
    "output = ''\n",
    "\n",
    "for element in inputs:\n",
    "    output = output + element.lower() + ' '\n",
    "\n",
    "output.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've already encountered several methods for lists, such as `append`. Another good one to know is `index`. [There are many list methods](https://www.w3schools.com/python/python_ref_list.asp)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.sort?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "my_list = ['cat','dog','oppossum','zebra']\n",
    "\n",
    "my_list.> **Check your understanding** What will the following code print out?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Check your understanding** What will the following code print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_string = ['a', 'c', 'd', 'b']\n",
    "list_string.sort()\n",
    "list_string.reverse()\n",
    "list_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modified \"in place\" or not?\n",
    "**Note**: Some methods update the object directly (in place), whereas others return an updated version of the input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reverse a list is in place\n",
    "my_list = ['a', 'b', 'c']\n",
    "my_list.reverse()\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionary keys is not in place\n",
    "car_dict = {'brand': 'BMW', 'model': 'M5', 'year': 2019}\n",
    "\n",
    "# Return the keys in the dictionary\n",
    "out = car.keys() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print keys\n",
    "print(type(out))\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# car has not changed\n",
    "print(type(car))\n",
    "print(car)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<hr>\n",
    "\n",
    "## Classes\n",
    "\n",
    "**Date** above is a class that Python has already defined for us. As it turns out, we can define classes too! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A class is defined almost like a function, but using the `class` keyword, and the class definition usually contains a number of class method definitions (a function in a class).\n",
    "* Each class method should have an argument `self` as its first argument. This object is a self-reference.\n",
    "* Some class method names have special meaning. For example, `__init__` is a method that is invoked when the object is first created.\n",
    "    * (Full list <a href=\"https://docs.python.org/2.0/ref/specialnames.html\">here</a>)\n",
    "    \n",
    "Let's create `Dog` as an example class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Define a class with `class`. \n",
    "class Dog():\n",
    "    \n",
    "    # Class attributes for all Dogs\n",
    "    sound = 'Woof'\n",
    "\n",
    "    # Class methods for objects of type Dog\n",
    "    # Self is a special parameter that refers to the object\n",
    "    def speak(self):\n",
    "        print(self.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# create an instance of Dog\n",
    "roger = Dog()\n",
    "\n",
    "# the Dog has a sound attribute\n",
    "roger.sound\n",
    "\n",
    "# the Dog has a speak method\n",
    "roger.speak() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a group of dogs\n",
    "pack_of_dogs = [Dog(), Dog(), Dog(), Dog()]\n",
    "\n",
    "for dog in pack_of_dogs:\n",
    "    dog.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can also create instance-specific attributes. Below, we've added an `init method` (the code below with `__init__`) which will create the attribute `name` whenever this class is initialized. This will allow each Dog instance to have its own name.\n",
    "\n",
    "**Note:** the order of methods and attributes does not matter, but it is conventional to have the init method first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    \n",
    "    sound = 'Woof'\n",
    "    \n",
    "    # Initializer, allows us to specificy instance-specific attributes\n",
    "    # leading and trailing double underscores indicates that this is special to Python\n",
    "    def __init__(self,name):\n",
    "        self.name = name\n",
    "\n",
    "    def speak(self):\n",
    "        print(self.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a dog\n",
    "# what goes in the parentheses is defined in the __init__\n",
    "my_dog = Dog('Roger')\n",
    "\n",
    "my_dog.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Task</b>: In the cell below, check the two attributes of our <code>my_dog</code> instance of the <code>Dog</code> class.</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check attributes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "We can also define methods that take inputs. These methods are written as functions!\n",
    "\n",
    "Below, `speak` has been modified to be proportional to the number of squirrels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    \n",
    "    # Class attributes for all Dogs\n",
    "    sound = 'Woof'\n",
    "    \n",
    "    # Initializer, allows us to specificy instance-specific attributes\n",
    "    # leading and trailing double underscores indicates that this is special to Python\n",
    "    def __init__(self,name):\n",
    "        self.name = name\n",
    "    \n",
    "    # Squirrels is a time series of # of squirrels, which our dog sums\n",
    "    def speak(self,squirrels):\n",
    "        self.barks = sum(squirrels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Try your dog here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class Inheritance\n",
    "Classes can also inherit other classes! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# First we define a broad class, Brain:\n",
    "class Brain(): \n",
    "    \n",
    "    def __init__(self, size = None, folded = None):\n",
    "        self.size = size\n",
    "        self.folded = folded\n",
    "        \n",
    "    def print_info(self):\n",
    "        folded_string = ''\n",
    "        if not self.folded:\n",
    "            folded_string = 'not'\n",
    "        print('This brain is ' + self.size + ' and is ' + folded_string + ' folded.')\n",
    "        \n",
    "        \n",
    "my_brain = Brain(size='large',folded=True)\n",
    "\n",
    "my_brain.print_info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Then, we can inherit an instance of Brain using this syntax: \n",
    "class SheepBrain(Brain):\n",
    "    \n",
    "    def __init__(self, size = 'medium', folded = False):\n",
    "        super().__init__(size, folded)\n",
    "        \n",
    "class HumanBrain(Brain):\n",
    "    def __init__(self, size = 'large', folded = True):\n",
    "        super().__init__(size, folded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "What will the following cell print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sheep = SheepBrain()\n",
    "human = HumanBrain()\n",
    "\n",
    "human.folded and sheep.folded"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Task</b>: Create a <code>Neuron</code> class. First, pseudocode your class on the whiteboard, and <i>then</i> work on it in the cell below.\n",
    "    \n",
    "The neuron should have two attributes that are specific to each instance of it: `diameter` and `neuron_type`.\n",
    "    \n",
    "The neuron should also have a method, <code>spike</code> which adds a list of input values given to it, and is stored in the attribute <code>firing_rate</code>.\n",
    "\n",
    "In addition, give the neuron an attribute `spontaneous_firing_rate`, which is different for each neuron. Create an `integrate` method that adds adds an input to this spontaneous firing rate to update the `firing_rate` attribute.\n",
    "\n",
    "If you're feeling bold, create two different classes that inherit <code>Neuron</code>: excitatory and inhibitory. Then, create a population of neurons!</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## About this notebook\n",
    "This notebook is largely derived from [UCSD COGS18 Materials](https://cogs18.github.io/materials/12-Classes.html#objects), created by Tom Donoghue & Shannon Ellis. \n",
    "\n",
    "Want to run this notebook as a slideshow? If you have Python (or Anaconda) follow <a href=\"http://www.blog.pythonlibrary.org/2018/09/25/creating-presentations-with-jupyter-notebook/\">these instructions</a> to setup your computer with the RISE plugin."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}