06-OOP_solutions.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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store information about a date here\n",
    "\n",
    "date_string = '01/30/2024'\n",
    "\n",
    "month = 1\n",
    "year = 2024\n",
    "\n",
    "date_dictionary = {month:'january',day:30}"
   ]
  },
  {
   "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": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Import date from datetime module\n",
    "from datetime import date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-01-30\n"
     ]
    }
   ],
   "source": [
    "# Set the data we want to store in our date object\n",
    "day = 30\n",
    "month = 1\n",
    "year = 2024\n",
    "\n",
    "# Create a date object\n",
    "\n",
    "my_date = date(year, month, day)\n",
    "\n",
    "print(my_date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_date.month"
   ]
  },
  {
   "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": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Method to return what day of the week the date is\n",
    "# Note the parentheses for methods.\n",
    "today = date(2020,1,28)\n",
    "today.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": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15890 days\n",
      "43.534246575342465 years\n"
     ]
    }
   ],
   "source": [
    "# Define a second date\n",
    "birthdate = date(1980, 7, 29)\n",
    "\n",
    "# Calculate the difference between times\n",
    "time_diff = my_date - birthdate\n",
    "\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": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Datetime is from the same package as date\n",
    "from datetime import datetime\n",
    "\n",
    "now = datetime.today()\n",
    "\n",
    "now.second"
   ]
  },
  {
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'imma let you finish'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a string all lower case\n",
    "'IMMA LET YOU FINISH'.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'WAIT A SECOND'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a string all upper case\n",
    "'wait a second'.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# We need to re-assign my_string to a variable when using upper\n",
    "\n",
    "my_string = 'hello'    # assign string\n",
    "\n",
    "my_string_cap = my_string.capitalize() # use capitalize method\n",
    "\n",
    "print(my_string)       # print my_string\n",
    "print(my_string_cap)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Check your understanding** What will the following code print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fIx\n",
      "fix \n",
      "tYpiNg\n",
      "fix typing \n",
      "lIkE\n",
      "fix typing like \n",
      "tHiS\n",
      "fix typing like this \n",
      "For loop is over\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Fix typing like this '"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = ['fIx', 'tYpiNg', 'lIkE', 'tHiS']\n",
    "output = ''\n",
    "\n",
    "for element in inputs:\n",
    "    print(element)\n",
    "    output = output + element.lower() + ' '\n",
    "    print(output)\n",
    "\n",
    "print('For loop is over')\n",
    "\n",
    "capitalized_list = output.capitalize()\n",
    "capitalized_list"
   ]
  },
  {
   "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": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ox', 'cat', 'zebra', 'oppossum']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = ['cat','oppossum','ox','zebra']\n",
    "\n",
    "my_list.sort(key=len,reverse=False)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check the documentation using this syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "list.sort?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Check your understanding** What will the following code print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['d', 'c', 'b', 'a']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['c', 'b', 'a']\n"
     ]
    }
   ],
   "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": 28,
   "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_dict.keys() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict_keys'>\n",
      "dict_keys(['brand', 'model', 'year'])\n"
     ]
    }
   ],
   "source": [
    "# print keys\n",
    "print(type(out))\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'brand': 'BMW', 'model': 'M5', 'year': 2019}\n"
     ]
    }
   ],
   "source": [
    "# car_dict has not changed\n",
    "print(type(car_dict))\n",
    "print(car_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'BMW'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pop is in place\n",
    "car_dict.pop('brand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'model': 'M5', 'year': 2019}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# car_dict has changed\n",
    "car_dict"
   ]
  },
  {
   "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! Writing your own classes isn't *necessary* but it is a useful way to create complex, custom objects with their own data & methods. \n",
    "\n",
    "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. You'll almost never see `self` outside of a class definition.\n",
    "    * Why do you need `self`? It's a little strange, but think of it this way: *an object always passes itself as the first argument to any of its own methods.*\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": 33,
   "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": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof\n"
     ]
    }
   ],
   "source": [
    "# create an instance of Dog\n",
    "yeti = Dog()\n",
    "\n",
    "# use speak method\n",
    "yeti.speak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof\n",
      "Woof\n",
      "Woof\n",
      "Woof\n"
     ]
    }
   ],
   "source": [
    "# Initialize a group of dogs\n",
    "pack_of_dogs = [Dog(), Dog(), Dog(), Dog()]\n",
    "\n",
    "# Write for loop so each dog can speak\n",
    "\n",
    "for dog in pack_of_dogs:\n",
    "    \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. The init method is called every time we create an instance of our class.\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": 41,
   "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": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof\n"
     ]
    }
   ],
   "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": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() missing 1 required positional argument: 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_195/574544720.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Now, we need to give dog an init argument 'name'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# If not, we will receive an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mmy_dog\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'name'"
     ]
    }
   ],
   "source": [
    "# Now, we need to give dog an init argument 'name'\n",
    "# If not, we will receive an error\n",
    "my_dog = Dog()"
   ]
  },
  {
   "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": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Roger\n",
      "Woof\n"
     ]
    }
   ],
   "source": [
    "# Check attributes\n",
    "print(my_dog.name)\n",
    "print(my_dog.sound)"
   ]
  },
  {
   "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": 52,
   "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)\n",
    "        \n",
    "        for i in range(self.barks):\n",
    "            print(self.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woof\n",
      "Woof\n",
      "Woof\n",
      "Woof\n"
     ]
    }
   ],
   "source": [
    "# Try your dog here\n",
    "lassie = Dog('Lassie')\n",
    "\n",
    "lassie.speak([1,2,0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class Inheritance\n",
    "Classes can also inherit other classes! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This brain is large and is  folded.\n"
     ]
    }
   ],
   "source": [
    "# First we define a parent 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": "markdown",
   "metadata": {},
   "source": [
    "Now that we've created our parent class, `Brain`, we can inherit it by placing it in the parentheses in our class definition. This is telling Python that a SheepBrain is a type of Brain. By doing this, SheepBrain has access to all of the data and methods defined in Brain.\n",
    "\n",
    "`super()` allows us to access the parent class data & methods. We need to use this when we are inheriting a class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class SheepBrain(Brain):\n",
    "    \n",
    "    def __init__(self, size = 'medium', folded = False):\n",
    "        super().__init__(size, folded)\n",
    "        \n",
    "class HumanBrain(Brain):\n",
    "    \n",
    "    def __init__(self, size = 'large', folded = True):\n",
    "        super().__init__(size, folded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "> **Check your understanding**: What will the following cell print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This brain is large and is  folded.\n"
     ]
    }
   ],
   "source": [
    "sheep = SheepBrain()\n",
    "human = HumanBrain()\n",
    "\n",
    "human.folded and sheep.folded\n",
    "\n",
    "human.print_info()"
   ]
  },
  {
   "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, 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>count_spikes</code> which:\n",
    "\n",
    "1. adds a list of input values provided as one second samples of the spike (e.g. <code>[False,True,False,False]</code>) given to it\n",
    "2. divides by the number of input values to give spikes/second\n",
    "3. stores this spike rate 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 `spike_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": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create your Neuron class here\n",
    "\n",
    "class Neuron():\n",
    "    \n",
    "    def __init__(self, diameter = None, neuron_type = None):\n",
    "        \n",
    "        self.diameter = diameter \n",
    "        self.neuron_type = neuron_type\n",
    "        \n",
    "    def count_spikes(self,input_values):      \n",
    "        '''\n",
    "        Takes a list of boolean\n",
    "        input values provided as one second samples\n",
    "        and computes firing rate\n",
    "        '''\n",
    "        \n",
    "        sum_input = sum(input_values)\n",
    "        self.firing_rate = sum_input/len(input_values)\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diameter: 30\n",
      "Neuron type: excitatory\n",
      "Elicited firing rate:  0.4\n"
     ]
    }
   ],
   "source": [
    "my_neuron = Neuron(diameter=30,neuron_type='excitatory')\n",
    "print('Diameter:', my_neuron.diameter)\n",
    "print('Neuron type:' ,my_neuron.neuron_type)\n",
    "\n",
    "my_neuron.count_spikes([False,True,False,False,True])\n",
    "print('Elicited firing rate: ',my_neuron.firing_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<hr>\n",
    "\n",
    "## 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 (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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}