10-Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "update class size quarters in ProfCourses() example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Classes\n",
    "\n",
    "- objects\n",
    "- `class`\n",
    "    - attributes\n",
    "    - methods\n",
    "- instances\n",
    "    - `__init__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Objects\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "Objects are an organization of data (called <b>attributes</b>), with associated code to operate on that data (functions defined on the objects, called <b>methods</b>).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #1\n",
    "\n",
    "Given what we've discussed in this course so far, if you wanted to store information about a date, how would you do so?\n",
    "\n",
    "- A) string\n",
    "- B) dictionary\n",
    "- C) list\n",
    "- D) integers stored in separate variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Storing Dates (Motivation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# A date, stored as a string\n",
    "date_string = '29/09/1988'\n",
    "print(date_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# A date, stored as a list of number\n",
    "date_list = [29, 09, 1988]\n",
    "date_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# A date, stored as a series of numbers\n",
    "day = 29\n",
    "month = 9\n",
    "year = 1988\n",
    "\n",
    "print(day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# A date, stored as a dictionary\n",
    "date_dictionary = {'day': 29, 'month': 9, 'year': 1988}\n",
    "date_dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ways to organize data (variables) and functions together. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example Object: Date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Import a date object\n",
    "from datetime import date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "date?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Set the data we want to store in our date object\n",
    "day = 29\n",
    "month = 9\n",
    "year = 1988\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": [
    "## Accessing Attributes & Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Attributes and methods are accessed with a <code>.</code>, followed by the attribute/method name on the object. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Date - Attributes\n",
    "\n",
    "Attributes look up & return information about the object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**attributes** maintain the object's state, simply returning information about the object to you"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Get the day attribute\n",
    "my_date.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Get the month attribute\n",
    "my_date.month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Get the year attribute\n",
    "my_date.year"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Date - Methods\n",
    "\n",
    "These are _functions_ that *belong* to and operate on the object directly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**methods** modify the object's state"
   ]
  },
  {
   "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",
    "my_date.weekday()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Reminder: check documentation with '?'\n",
    "date.weekday?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It's also possible to carry out operations on multiple date objects."
   ]
  },
  {
   "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",
    "print(my_date, my_date2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# 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": [
    "### Listing Attributes & Methods : `dir`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# tab complete to access\n",
    "# methods and attributes\n",
    "my_date.\n",
    "\n",
    "# works to find attributes and methods\n",
    "# for date type objects generally\n",
    "date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "## dir ouputs all methods and attributes\n",
    "## we'll talk about the double underscores next lecture\n",
    "dir(my_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "#### Clicker Question #2\n",
    "\n",
    "Given the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "my_date = date(year = 1050, month = 12, day = 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Which is the best description:\n",
    "- A) `my_date` is an object, with methods that store data, and attributes that store procedures\n",
    "- B) `my_date` is variable, and can be used with functions\n",
    "- C) `my_date` is an attribute, with methods attached to it\n",
    "- D) `my_date` is a method, and also has attributes\n",
    "- E) `my_date` is an object, with attributes that store data, and methods that store procedures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #3\n",
    "\n",
    "For an object `lets` with a method `do_something`, how would you execute that method?\n",
    "\n",
    "- A) `do_something(lets)`\n",
    "- B) `lets.do_something`\n",
    "- C) `lets.do_something()`\n",
    "- D) `lets.do.something()`\n",
    "- E) ¯\\\\\\_(ツ)\\_/¯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #4\n",
    "\n",
    "For an object `lets` with an attribute `name`, how would you return the information stored in `name` for the object `lets`?\n",
    "\n",
    "- A) `name(lets)`\n",
    "- B) `lets.name`\n",
    "- C) `lets.name()`\n",
    "- D) lets.get.name()\n",
    "- E) ¯\\\\\\_(ツ)\\_/¯"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Objects Summary\n",
    "\n",
    "- Objects allow for data (attributes) and functions (methods) to be organized together\n",
    "    - methods operate on the object type (modify state)\n",
    "    - attributes store and return information (data) about the object (maintain state)\n",
    "- `dir()` returns methods & attributes for an object\n",
    "- Syntax:\n",
    "    - `obj.method()`\n",
    "    - `obj.attribute`\n",
    "- `date` and `datetime` are two types of objects in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Classes</b> define objects. The <code>class</code> keyword opens a code block for instructions on how to create objects of a particular type.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Think of classes as the _blueprint_ for creating and defining objects and their properties (methods, attributes, etc.). They keep related things together and organized."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Example Class: Dog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Define a class with `class`. \n",
    "# By convention, class definitions use CapWords (Pascal)\n",
    "class Dog():\n",
    "    \n",
    "    # Class attributes for objects of type Dog\n",
    "    sound = 'Woof'\n",
    "    \n",
    "    # Class methods for objects of type Dog\n",
    "    def speak(self, n_times=2):\n",
    "        return self.sound * n_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a dog object\n",
    "george = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# george, has 'sound' attribute(s) from Dog()\n",
    "george.sound"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# george, has 'Dog' method(s)\n",
    "# remember we used `self`\n",
    "george.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A reminder:\n",
    "- **attributes** maintain the object's state; they lookup information about an object\n",
    "- **methods** alter the object's state; they run a function on an object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**`class`** notes:\n",
    "\n",
    "- classes tend to use **CapWords** convention (Pascal Case)\n",
    "    - instead of snake_case (functions and variable names)\n",
    "- `()` after `Dog` indicate that this is callable\n",
    "    - like functions, Classes must be executed before they take effect\n",
    "- can define **attributes** & **methods** within `class`\n",
    "- `self` is a special parameter for use by an object\n",
    "    - refers to the thing (object) itself\n",
    "- like functions, a new namespace is created within a Class\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #5\n",
    "\n",
    "Which of the following statements is true about the example we've been using? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    \n",
    "    sound = 'Woof'\n",
    "    \n",
    "    def speak(self, n_times=2):\n",
    "        return self.sound * n_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) `Dog` is a Class, `sound` is an attribute, and `speak` is a method. \n",
    "- B) `Dog` is a function, `sound` is an attribute, and `speak` is a method. \n",
    "- C) `Dog` is a Class, `sound` is a method, and `speak` is an attribute. \n",
    "- D) `Dog` is a function, `sound` is an method, and `speak` is an attribute. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Using our Dog Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a group of dogs\n",
    "pack_of_dogs = [Dog(), Dog(), Dog(), Dog()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# take a look at this\n",
    "pack_of_dogs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# take a look at this\n",
    "type(pack_of_dogs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for dog in pack_of_dogs:\n",
    "    print(dog.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Instances & self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "An <b>instance</b> is particular instantiation of a class object. <code>self</code> refers to the current instance. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a dog object\n",
    "george = Dog()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "From our example above:\n",
    "\n",
    "- Dog is the Class we created\n",
    "- `george` was an _instance_ of that class\n",
    "- self just refers to whatever the _current_ instance is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Instance Attributes\n",
    "\n",
    "An instance attribute specific to the instance we're on. This allows different instances of the same class to be unique (have different values stored in attributes and use those in methods)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a group of dogs\n",
    "pack_of_dogs = [Dog(), Dog(), Dog(), Dog()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "This creates four different `Dog` type objects and stores them in a list. But, up until now...every `Dog` was pretty much the same."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "Instance attributes are attributes that we can make be different for each instance of a class. <code>__init__</code> is a special method used to define instance attributes. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example Class: Dog Revisited\n",
    "\n",
    "- Two trailing underscores (a `dunder`, or double underscore) is used to indicate something Python recognizes and knows what to do every time it sees it.\n",
    "- Here, we use `__init__` to execute the code within it every time you initialize an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Dog():\n",
    "    \n",
    "    # Class attributes for Dogs\n",
    "    sound = 'Woof'\n",
    "    \n",
    "    # Initializer, allows us to specify 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_times=2):\n",
    "        return self.sound * n_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Initialize a dog\n",
    "# what goes in the parentheses is defined in the __init__\n",
    "gary = Dog(name = 'Gary') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check gary's attributes\n",
    "print(gary.sound)    # This is an class attribute\n",
    "print(gary.name)     # This is a instance attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Check gary's methods\n",
    "gary.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #6\n",
    "\n",
    "Edit the code we've been using for the Class `Dog` to include information about the breed of the Class Dog in `NewDog`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# EDIT CODE HERE\n",
    "class NewDog():\n",
    "    \n",
    "    sound = 'Woof'\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def speak(self, n_times=2):\n",
    "        return self.sound * n_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "## We'll execute here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) I did it!\n",
    "- B) I think I did it!\n",
    "- C) So lost. -_-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class example: Cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Define a class 'Cat'\n",
    "class Cat():\n",
    "    \n",
    "    sound = \"Meow\"\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def speak(self, n_times=2):\n",
    "        return self.sound * n_times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Instances Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Define some instances of our objects\n",
    "pets = [Cat('Jaspurr'), Dog('Barkley'), \n",
    "        Cat('Picatso'), Dog('Ruffius')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for pet in pets:\n",
    "    print(pet.name, ' says:')\n",
    "    print(pet.speak())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Clicker Question #7\n",
    "\n",
    "What will the following code snippet print out?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass():\n",
    "    \n",
    "    def __init__(self, name, email, score):\n",
    "        self.name = name\n",
    "        self.email = email\n",
    "        self.score = score\n",
    "    \n",
    "    def check_score(self):        \n",
    "        if self.score <= 65:\n",
    "            return self.email\n",
    "        else:\n",
    "            return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "student = MyClass('Rob', 'rob@python.com', 62)\n",
    "student.check_score()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A) True\n",
    "- B) 'Rob'\n",
    "- C) False \n",
    "- D) 'rob@python.com'\n",
    "- E) None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Code Style: Classes\n",
    "\n",
    "- CapWords for class names\n",
    "- one blank line between methods/functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Good Code Style**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass():\n",
    "    \n",
    "    def __init__(self, name, email, score):\n",
    "        self.name = name\n",
    "        self.email = email\n",
    "        self.score = score\n",
    "    \n",
    "    def check_score(self):        \n",
    "        if self.score <= 65:\n",
    "            return self.email\n",
    "        else:\n",
    "            return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Code Style to Avoid**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class my_class(): # uses snake case for name\n",
    "    def __init__(self, name, email, score):\n",
    "        self.name = name\n",
    "        self.email = email\n",
    "        self.score = score   # no blank lines between methods  \n",
    "    def check_score(self):        \n",
    "        if self.score <= 65:\n",
    "            return self.email\n",
    "        else:\n",
    "            return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Example: `ProfCourses()`\n",
    "\n",
    "Let's put a lot of these concepts together in a more complicated example...\n",
    "\n",
    "What if we wanted some object type that would allow us to keep track of Professor Ellis' Courses? Well...we'd want this to work for any Professor, so we'll call it `ProfCourses`.\n",
    "\n",
    "We would likely want an object type and then helpful methods that allow us to add a class to the course inventory and to compare between courses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class ProfCourses():\n",
    "    \n",
    "    # create three instance attributes\n",
    "    def __init__(self, prof):\n",
    "        self.n_courses = 0\n",
    "        self.courses = []\n",
    "        self.prof = prof"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Ellis\n"
     ]
    }
   ],
   "source": [
    "ellis_courses = ProfCourses('Ellis')\n",
    "print(ellis_courses.n_courses)\n",
    "print(ellis_courses.prof)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**`add_class()` method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class ProfCourses():\n",
    "    \n",
    "    def __init__(self, prof):\n",
    "        self.n_courses = 0\n",
    "        self.courses = []\n",
    "        self.prof = prof\n",
    "    \n",
    "    # add method that will add courses as a dictionary\n",
    "    # to our attribute (courses)...which is a list\n",
    "    def add_course(self, course_name, quarter, n_students):\n",
    "        \n",
    "        self.courses.append({'course_name': course_name, \n",
    "                             'quarter' : quarter, \n",
    "                             'n_students': n_students})\n",
    "        # increase value store in n_courses\n",
    "        # by 1 any time a class is added\n",
    "        self.n_courses += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'course_name': 'COGS18', 'quarter': 'fa20', 'n_students': 363}]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create ellis_courses\n",
    "ellis_courses = ProfCourses('Ellis')\n",
    "\n",
    "# add a class\n",
    "ellis_courses.add_course('COGS18', 'fa20', 363)\n",
    "\n",
    "# see output\n",
    "print(ellis_courses.courses)\n",
    "ellis_courses.n_courses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**`compare()` method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class ProfCourses():\n",
    "    \n",
    "    def __init__(self, prof):\n",
    "        self.n_courses = 0\n",
    "        self.courses = []\n",
    "        self.prof = prof\n",
    "    \n",
    "    def add_course(self, course_name, quarter, n_students):\n",
    "        \n",
    "        self.courses.append({'course_name': course_name,\n",
    "                             'quarter' : quarter,\n",
    "                             'n_students': n_students})\n",
    "        self.n_courses += 1\n",
    "            \n",
    "    # add method to compare values in courses\n",
    "    def compare(self, attribute, direction='most'):\n",
    "    \n",
    "        fewest = self.courses[0]\n",
    "        most = self.courses[0] \n",
    "        \n",
    "        for my_course in self.courses:\n",
    "            if my_course[attribute] <= fewest[attribute]:\n",
    "                fewest = my_course\n",
    "            elif my_course[attribute] >= most[attribute]:\n",
    "                most = my_course\n",
    "                \n",
    "        if direction == 'most':\n",
    "            output = most\n",
    "        elif direction == 'fewest':\n",
    "            output = fewest\n",
    "\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'course_name': 'COGS18', 'quarter': 'fa20', 'n_students': 363},\n",
       " {'course_name': 'COGS108', 'quarter': 'fa20', 'n_students': 447},\n",
       " {'course_name': 'COGS18', 'quarter': 'su20', 'n_students': 88},\n",
       " {'course_name': 'COGS108', 'quarter': 'sp20', 'n_students': 469},\n",
       " {'course_name': 'COGS108', 'quarter': 'sp19', 'n_students': 825}]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create ellis_courses\n",
    "ellis_courses = ProfCourses('Ellis')\n",
    "\n",
    "# add a bunch of classes\n",
    "ellis_courses.add_course('COGS18', 'fa20', 363)\n",
    "ellis_courses.add_course('COGS108', 'fa20', 447)\n",
    "ellis_courses.add_course('COGS18', 'su20', 88)\n",
    "ellis_courses.add_course('COGS108', 'sp20', 469)\n",
    "\n",
    "# see the courses\n",
    "print(ellis_courses.n_courses)\n",
    "ellis_courses.courses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'course_name': 'COGS108', 'quarter': 'sp19', 'n_students': 825}"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# make comparison among all courses\n",
    "# returns the class with the most students\n",
    "ellis_courses.compare('n_students')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'course_name': 'COGS18', 'quarter': 'su20', 'n_students': 88}"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return the class with the fewest students\n",
    "ellis_courses.compare('n_students', 'fewest')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**extending the functionality of the `compare()` method**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class ProfCourses():\n",
    "    \n",
    "    def __init__(self, prof):\n",
    "        self.n_courses = 0\n",
    "        self.courses = []\n",
    "        self.prof = prof\n",
    "    \n",
    "    def add_course(self, course_name, quarter, \n",
    "                   n_students, n_exams, n_assignments):\n",
    "        \n",
    "        # add in additional key-value pairs\n",
    "        self.courses.append({'course_name': course_name,\n",
    "                             'quarter' : quarter,\n",
    "                             'n_students': n_students,\n",
    "                             'n_exams' : n_exams,\n",
    "                             'n_assignments' : n_assignments})\n",
    "        self.n_courses += 1\n",
    "             \n",
    "    def compare(self, attribute, direction='most'):\n",
    "    \n",
    "        fewest = self.courses[0]\n",
    "        most = self.courses[0] \n",
    "        \n",
    "        for my_course in self.courses:\n",
    "            if my_course[attribute] <= fewest[attribute]:\n",
    "                fewest = my_course\n",
    "            elif my_course[attribute] >= most[attribute]:\n",
    "                most = my_course\n",
    "                \n",
    "        if direction == 'most':\n",
    "            output = most\n",
    "        elif direction == 'fewest':\n",
    "            output = fewest\n",
    "\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "# create ellis_courses\n",
    "ellis_courses = ProfCourses('Ellis')\n",
    "\n",
    "# add a bunch of classes\n",
    "ellis_courses.add_course('COGS18', 'fa20', 363, 2, 5)\n",
    "ellis_courses.add_course('COGS108', 'fa20', 447, 0, 6)\n",
    "ellis_courses.add_course('COGS18', 'su20', 88, 3, 5)\n",
    "ellis_courses.add_course('COGS108', 'sp20', 469, 0, 6)\n",
    "ellis_courses.add_course('COGS108', 'sp19', 825, 0, 5)\n",
    "ellis_courses.add_course('COGS18', 'fa19', 301, 2, 4)\n",
    "ellis_courses.add_course('COGS18', 'wi22', 355, 2, 4)\n",
    "ellis_courses.add_course('COGS18', 'sp23', 355, 2, 4)\n",
    "\n",
    "# see the courses\n",
    "print(ellis_courses.n_courses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'course_name': 'COGS18',\n",
       " 'quarter': 'su20',\n",
       " 'n_students': 88,\n",
       " 'n_exams': 3,\n",
       " 'n_assignments': 5}"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return the class with the most exams\n",
    "ellis_courses.compare('n_exams', 'most')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'course_name': 'COGS18',\n",
       " 'quarter': 'fa19',\n",
       " 'n_students': 301,\n",
       " 'n_exams': 2,\n",
       " 'n_assignments': 4}"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return the class with the fewest assignments\n",
    "ellis_courses.compare('n_assignments', 'fewest')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Improving & updating this code**\n",
    "- account for ties in `compare()`\n",
    "- edit code in `compare()` to make the `for` loop and following conditional more intuitive\n",
    "- add a method to put dictionary in time order\n",
    "- etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "### Classes Review\n",
    "\n",
    "- `class` creates a new class type\n",
    "    - names tend to use CapWords case\n",
    "    - can have attributes (including instance attributes) and methods\n",
    "        - `obj.attribute` accesses data stored in attribute\n",
    "        - `obj.method()` carries out code defined within method \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "- instance attributes defined with `__init__`\n",
    "    - `__init__` is a reserved method in Python\n",
    "    - This \"binds the attributes with the given arguments\"\n",
    "    - `self` refers to current instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "notes"
    }
   },
   "source": [
    "- to create an object (instance) of a specified class type (`ClassType`):\n",
    "    - `object_name = ClassType(input1, input2)`\n",
    "    - `self` is not given an input when creating an object of a specified class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Everything in Python is an Object!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Data variables are objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(isinstance(True, object))\n",
    "print(isinstance(1, object))\n",
    "print(isinstance('word', object))\n",
    "print(isinstance(None, object))\n",
    "\n",
    "a = 3\n",
    "print(isinstance(a, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Functions are objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(isinstance(sum, object))\n",
    "print(isinstance(max, object))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Custom function are also objects\n",
    "def my_function():\n",
    "    print('yay Python!')\n",
    "    \n",
    "isinstance(my_function, object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Class definitions & instances are objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass():\n",
    "    def __init__(self):\n",
    "        self.data = 13\n",
    "\n",
    "my_instance = MyClass()\n",
    "\n",
    "print(isinstance(MyClass, object))\n",
    "print(isinstance(my_instance, object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Object-Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Object-oriented programming (OOP)</b> is a programming paradigm in which code is organized around objects. Python is an OOP programming langauge. \n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}