Tutorial_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Data Science at UCSB\n",
    "# Python for Data Science: Introduction\n",
    "## Jason Freeberg, Fall 2016\n",
    "\n",
    "Welcome to the first tutorial! Let's get started with the basic foundations of OOP (Object Oriented Programming) with Python and cover some useful functions. Specifically, we will go over *classes*, *objects*, *modules*, basic *data structures*, and the functions for getting information on them.\n",
    "\n",
    "Some helpful resources to come back to:\n",
    "- [Data Camp](https://www.datacamp.com) Where you'll be doing homework.\n",
    "- [Python for Data Analysis](http://shop.oreilly.com/product/0636920023784.do) Written by the creator of the pandas module. A free PDF is available online.\n",
    "- [Reddit Datasets](https://www.reddit.com/r/datasets/) A good place to get data for personal projects.\n",
    "- [Python Walkthrough](https://docs.python.org/3/tutorial/index.html) Covers the basics of Python at a low level, essentially a guided tour through the Python documentation.\n",
    "- [Stack Exchange](http://stackexchange.com/) Because why figure it out on your own when someone smarter already did?\n",
    "- [The solutions!](https://github.com/JasonFreeberg/PythonSolutions) I will upload the solutions to the exercises a few days after each Tutorial.\n",
    "- [Jason](https://www.linkedin.com/in/jfreeberg) I will share my email in lab (these notebooks are public on GitHub). \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes\n",
    "\n",
    "Have you taken an intro programming class? Congratulations, you already know what a class is.\n",
    "\n",
    "If not, ever been in a car? Congratulations, you already know what a class is.\n",
    "\n",
    "At a high level, classes are the instructions (or blueprints) for creating objects, their initial values, and the functions to manipulate them. Let's use an example that's not related to programming... Ford Motor Company has the schematics for building their trucks and cars, like the Ford F-150. The schematics tell the employees where to put each piece, the starting values for things like the speedometer, fluid tanks levels, and so on. The schematics can also tell the employees to change the truck based on input from consumer--think of trim options like fog lights and leather steering wheels. \n",
    "\n",
    "The cell below defines a class for Ford F-150 trucks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# This is a comment. Nothing happens on these lines.\n",
    "a = \"hello world\"\n",
    "class F150:\n",
    "    \"\"\"\n",
    "    A basic class definition. We have attributes that are numeric, logical, and strings.\n",
    "    \n",
    "    The methods are simple, they only update the attributes. \n",
    "    \"\"\"\n",
    "    # These are the shared attributes of the class. When an \n",
    "    # 'F150' object is created, it will have these values.\n",
    "    make = 'Ford'\n",
    "    year = 2016\n",
    "    \n",
    "    # This method defines the inital values when an object is created. \n",
    "    # Notice that the function parameters have default values.\n",
    "    def __init__(self, cyl=6, speedoTop=120, fluidsOK=True, \n",
    "                 SteeringWheel='Standard', fogLights=True):\n",
    "        self.cylinders = cyl # Number of cylinders in the engine, the standard is a V8\n",
    "        self.speedoTop = speedoTop # Top speed on the speedometer, in MPH\n",
    "        self.fuildLevelsOK = fluidsOK\n",
    "        self.SteeringWheel = SteeringWheel\n",
    "        self.fogLights = fogLights\n",
    "    \n",
    "    # And here are the methods...\n",
    "    # This method changes the type of steering wheel that will be built into the truck\n",
    "    # Use the \"self.\" operator to indicate that you are accessing the class's attributes\n",
    "    def updateWheel(self, NewWheelType):\n",
    "        self.SteeringWheel = NewWheelType\n",
    "    \n",
    "    # This updates the top speed that will be printer on the speedomter\n",
    "    def updateMeterTop(self, NewTop):\n",
    "        self.speedoMeterTop = NewTop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Note**: *In Python, we generally don't write functions to edit the private variables (cylinders, speedoMeterTop, etc.) we just access them directly. I defined updateWheel( ) and updateMeterTop( ) only to show the syntax for member function definition and preview the dot operator. *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objects\n",
    "\n",
    "Let's continue with our truck example and tie it back to a programming context. Now we have the blueprint (class) for making F150 trucks! In the physical world, we use blueprints and instructions to make *things*. We use the intructions in a Lego box to make the final building. Likewise, we can make *things* from our class and interact with them in our program, and we call them **objects**. We can make a an entire fleet of F150 truck obects and have them race... if we edit the above class definition to allow for a throttle and brakes ;).\n",
    "\n",
    "In this hypothetical, the blueprints also have the instructions for different trims, engines and other bells and whistles. So when we create a new truck object, we can change those attributes and use its methods/functions. To access the attributes of an object, or to use functions to edit those attributes, we use the **dot operator**. The syntax is: *object*.*attribute* or *object*.*method()*\n",
    "\n",
    "In the cell below we create two objects, **truck1** and **truck2**. Look closely at the print statements to see the dot operator for accessing object attributes.\n",
    "\n",
    "**FYI:** class instance == object of a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of cylinders in truck1 =  6\n",
      "The type of steering wheel in truck1 is Standard\n",
      "truck1 has fog lights\n",
      "------------------------------------------------------------\n",
      "The number of cylinders in truck1 =  4\n",
      "The type of steering wheel in truck1 is Leather\n",
      "truck2 does not have fog lights\n"
     ]
    }
   ],
   "source": [
    "# Here is the syntax for creating an instance of a class\n",
    "\n",
    "truck1 = F150()    # using the default parameters\n",
    "truck2 = F150(cyl=4, \n",
    "              speedoTop=100, \n",
    "              fluidsOK=False,    # using the default parameters \n",
    "              SteeringWheel='Leather', \n",
    "              fogLights=False)\n",
    "truck3 = F150(cyl = 4, fogLights = True)\n",
    "truck1.speedoTop = 420 \n",
    "\n",
    "print('The number of cylinders in truck1 = ', truck1.cylinders)\n",
    "print('The type of steering wheel in truck1 is', truck1.SteeringWheel)\n",
    "if truck1.fogLights == True:\n",
    "    print('truck1 has fog lights')\n",
    "else:\n",
    "    print('truck1 does not have fog lights')\n",
    "\n",
    "print('------------------------------------------------------------')\n",
    "\n",
    "print('The number of cylinders in truck1 = ', truck2.cylinders)\n",
    "print('The type of steering wheel in truck1 is', truck2.SteeringWheel)\n",
    "\n",
    "# Since .fogLights is a boolean, we don't actually need to check \"== True\"\n",
    "if truck2.fogLights:\n",
    "    print('truck2 has fog lights')\n",
    "else:\n",
    "    print('truck2 does not have fog lights')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "truck1's top speedo tick = 160 and it's new steering wheel is a Batmobile Steering Wheel\n",
      "truck2's top speedo tick = One Hundred and Thirty and it's new steering wheel is a GameCube Controller\n"
     ]
    }
   ],
   "source": [
    "# Adjusting the values\n",
    "\n",
    "truck1.updateMeterTop(160)\n",
    "truck1.updateWheel('Batmobile Steering Wheel')\n",
    "\n",
    "truck2.updateMeterTop('One Hundred and Thirty')\n",
    "truck2.updateWheel('GameCube Controller')\n",
    "\n",
    "# Print the new values\n",
    "\n",
    "print(\"truck1's top speedo tick =\", truck1.speedoMeterTop, \\\n",
    "\"and it's new steering wheel is a\", truck1.SteeringWheel)\n",
    "print(\"truck2's top speedo tick =\", truck2.speedoMeterTop, \\\n",
    "\"and it's new steering wheel is a\", truck2.SteeringWheel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules\n",
    "\n",
    "If you end up using Python in a data-related role, chances are that you won't often be defining your own classes... you will be using those defined by other people. NumPy and pandas are collections of data structures and classes all neatly packaged into modules\\*. Once the modules are downloaded onto your computer via pip or 'conda, you can quickly bring them into your script. Let's take a look.\n",
    "\n",
    "\\* Also known as libraries or packages if you come from an R background"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# These all accomplish the same task of importing the module, with slight differences. \n",
    "# For more information, look to the Python documentation. For this quarter's tutorial, \n",
    "# we will use the second convention.\n",
    "\n",
    "import numpy\n",
    "import numpy as np # np is the naming convention for importing numpy\n",
    "from numpy import *\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helpful Functions\n",
    "\n",
    "As stated above, you will often use modules created by other people. This begs the question: *how do I learn how to use the classes and functions?* Well that requires a two-part answer.\n",
    "\n",
    "* **Abstraction**: Assume we have a list and use a method called \"average(*list*)\" from the base Python library. We can safely assume that it will return the average of the list. Do we need to know exactly **how** it accomplishes this? Absolutely not! It would be a waste of time to learn and check the implementations of every function in the NumPy package.\n",
    "* **Inspection**: There are base Python functions to inspect classes, objects, and methods. This way we can get the attributes and methods of an object we're working with. Let's take a look at some."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output of dir() method:\n",
      "['SteeringWheel', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'cylinders', 'fogLights', 'fuildLevelsOK', 'make', 'speedoTop', 'updateMeterTop', 'updateWheel', 'year'] \n",
      "\n",
      "Output of getmembers() method called on class:\n",
      "('__class__', <class 'type'>)\n",
      "('__delattr__', <slot wrapper '__delattr__' of 'object' objects>)\n",
      "('__dict__', mappingproxy({'__module__': '__main__', 'make': 'Ford', 'updateWheel': <function F150.updateWheel at 0x103d52510>, '__weakref__': <attribute '__weakref__' of 'F150' objects>, '__dict__': <attribute '__dict__' of 'F150' objects>, '__doc__': '\\n    A basic class definition. We have attributes that are numeric, logical, and strings.\\n    \\n    The methods are simple, they only update the attributes. \\n    ', '__init__': <function F150.__init__ at 0x103d520d0>, 'year': 2016, 'updateMeterTop': <function F150.updateMeterTop at 0x103d526a8>}))\n",
      "('__dir__', <method '__dir__' of 'object' objects>)\n",
      "('__doc__', '\\n    A basic class definition. We have attributes that are numeric, logical, and strings.\\n    \\n    The methods are simple, they only update the attributes. \\n    ')\n",
      "('__eq__', <slot wrapper '__eq__' of 'object' objects>)\n",
      "('__format__', <method '__format__' of 'object' objects>)\n",
      "('__ge__', <slot wrapper '__ge__' of 'object' objects>)\n",
      "('__getattribute__', <slot wrapper '__getattribute__' of 'object' objects>)\n",
      "('__gt__', <slot wrapper '__gt__' of 'object' objects>)\n",
      "('__hash__', <slot wrapper '__hash__' of 'object' objects>)\n",
      "('__init__', <function F150.__init__ at 0x103d520d0>)\n",
      "('__le__', <slot wrapper '__le__' of 'object' objects>)\n",
      "('__lt__', <slot wrapper '__lt__' of 'object' objects>)\n",
      "('__module__', '__main__')\n",
      "('__ne__', <slot wrapper '__ne__' of 'object' objects>)\n",
      "('__new__', <built-in method __new__ of type object at 0x10022c5e0>)\n",
      "('__reduce__', <method '__reduce__' of 'object' objects>)\n",
      "('__reduce_ex__', <method '__reduce_ex__' of 'object' objects>)\n",
      "('__repr__', <slot wrapper '__repr__' of 'object' objects>)\n",
      "('__setattr__', <slot wrapper '__setattr__' of 'object' objects>)\n",
      "('__sizeof__', <method '__sizeof__' of 'object' objects>)\n",
      "('__str__', <slot wrapper '__str__' of 'object' objects>)\n",
      "('__subclasshook__', <built-in method __subclasshook__ of type object at 0x1038d3048>)\n",
      "('__weakref__', <attribute '__weakref__' of 'F150' objects>)\n",
      "('make', 'Ford')\n",
      "('updateMeterTop', <function F150.updateMeterTop at 0x103d526a8>)\n",
      "('updateWheel', <function F150.updateWheel at 0x103d52510>)\n",
      "('year', 2016)\n",
      "\n",
      " Output of getmembers() method called on class instance:\n",
      "('SteeringWheel', 'Standard')\n",
      "('__class__', <class '__main__.F150'>)\n",
      "('__delattr__', <method-wrapper '__delattr__' of F150 object at 0x11275ea90>)\n",
      "('__dict__', {'SteeringWheel': 'Standard', 'fuildLevelsOK': True, 'speedoTop': 120, 'cylinders': 6, 'fogLights': True})\n",
      "('__dir__', <built-in method __dir__ of F150 object at 0x11275ea90>)\n",
      "('__doc__', '\\n    A basic class definition. We have attributes that are numeric, logical, and strings.\\n    \\n    The methods are simple, they only update the attributes. \\n    ')\n",
      "('__eq__', <method-wrapper '__eq__' of F150 object at 0x11275ea90>)\n",
      "('__format__', <built-in method __format__ of F150 object at 0x11275ea90>)\n",
      "('__ge__', <method-wrapper '__ge__' of F150 object at 0x11275ea90>)\n",
      "('__getattribute__', <method-wrapper '__getattribute__' of F150 object at 0x11275ea90>)\n",
      "('__gt__', <method-wrapper '__gt__' of F150 object at 0x11275ea90>)\n",
      "('__hash__', <method-wrapper '__hash__' of F150 object at 0x11275ea90>)\n",
      "('__init__', <bound method F150.__init__ of <__main__.F150 object at 0x11275ea90>>)\n",
      "('__le__', <method-wrapper '__le__' of F150 object at 0x11275ea90>)\n",
      "('__lt__', <method-wrapper '__lt__' of F150 object at 0x11275ea90>)\n",
      "('__module__', '__main__')\n",
      "('__ne__', <method-wrapper '__ne__' of F150 object at 0x11275ea90>)\n",
      "('__new__', <built-in method __new__ of type object at 0x10022c5e0>)\n",
      "('__reduce__', <built-in method __reduce__ of F150 object at 0x11275ea90>)\n",
      "('__reduce_ex__', <built-in method __reduce_ex__ of F150 object at 0x11275ea90>)\n",
      "('__repr__', <method-wrapper '__repr__' of F150 object at 0x11275ea90>)\n",
      "('__setattr__', <method-wrapper '__setattr__' of F150 object at 0x11275ea90>)\n",
      "('__sizeof__', <built-in method __sizeof__ of F150 object at 0x11275ea90>)\n",
      "('__str__', <method-wrapper '__str__' of F150 object at 0x11275ea90>)\n",
      "('__subclasshook__', <built-in method __subclasshook__ of type object at 0x1038d3048>)\n",
      "('__weakref__', None)\n",
      "('cylinders', 6)\n",
      "('fogLights', True)\n",
      "('fuildLevelsOK', True)\n",
      "('make', 'Ford')\n",
      "('speedoTop', 120)\n",
      "('updateMeterTop', <bound method F150.updateMeterTop of <__main__.F150 object at 0x11275ea90>>)\n",
      "('updateWheel', <bound method F150.updateWheel of <__main__.F150 object at 0x11275ea90>>)\n",
      "('year', 2016)\n"
     ]
    }
   ],
   "source": [
    "import inspect as ins\n",
    "anotherTruck = F150()\n",
    "\n",
    "print(\"Output of dir() method:\")\n",
    "print( dir(anotherTruck), '\\n' ) # Base function, returns list of attributes\n",
    "\n",
    "print(\"Output of getmembers() method called on class:\")\n",
    "for item in inspect.getmembers(F150):  # From inspect module, returns \n",
    "    print(item)                         # tuples of (attribute, description)\n",
    "  \n",
    "print('\\n', \"Output of getmembers() method called on class instance:\")\n",
    "for item in inspect.getmembers(anotherTruck): \n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Built-In Data Structures\n",
    "\n",
    "Next week we will learn about pandas DataFrames, a way of representing tabular data. However, there are more basic data types in Python that you should get familiar with...\n",
    "- [Lists]()\n",
    "- [Tuples]()\n",
    "- [Dictionaries]()\n",
    "\n",
    "### Tuples\n",
    "Tuples hold data in ordered pairs, just like (X, Y) coordinates on a cartesian plane. Even their structure looks similar! Tuples can hold any number of objects, **not just two** as in the example above.\n",
    "\n",
    "### Lists\n",
    "Lists are a class that hold data in a specified number of dimensions. You'll usually only need one or two dimensions, but it's possible to have three or ten. You can access the elements using square bracket notation: *a_list*\\[index1\\]\\[index2\\]\n",
    "\n",
    "### Dictionaries\n",
    "Dictionaries hold data in key-value pairs. The simplest dictionaries (or dicts) have keys as strings, and values as numbers. But really, the values could be a string, tuple, list, or another dictionary! If you hear the term JSON, think of them as dictionaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Tuple:\n",
      "0. ('More', 'Complex', 1234, 9)\n",
      "- Lists:\n",
      "1. ['within', 'a', 'list']\n",
      "2. within\n",
      "- Dictionaries:\n",
      "3. {'key': (1, 2), 'key3': {'inner_key2': 2, 'inner_key': 1}, 'key2': ['list', 'as', 'value']}\n",
      "4. ['list', 'as', 'value']\n",
      "5. 2\n",
      "- Big list:\n",
      "('More', 'Complex', 1234, 9)\n",
      "['a', 'list', ['within', 'a', 'list']]\n",
      "{'key': (1, 2), 'key3': {'inner_key2': 2, 'inner_key': 1}, 'key2': ['list', 'as', 'value']}\n"
     ]
    }
   ],
   "source": [
    "# Data type examples!\n",
    "\n",
    "# Tuples\n",
    "foo = 9\n",
    "tupl = (1,2,3,4,5)\n",
    "tupl = (\"Monty\", \"Python\") \n",
    "tupl = (\"More\", \"Complex\", 1234, foo)\n",
    "print('- Tuple:')\n",
    "print('0.', tupl)\n",
    "\n",
    "# Lists\n",
    "lst = [1, 2, 3, 4, 5]\n",
    "lst = ['a', 'b', 'c', 'd']\n",
    "lst = ['a', 2, 'c', foo]\n",
    "lst = ['a', 'list', ['within', 'a', 'list']]\n",
    "print('- Lists:')\n",
    "print('1.', lst[2])\n",
    "print('2.', lst[2][0])\n",
    "\n",
    "# Dictionaries\n",
    "dct = {'key' : 'value',\n",
    "       'key2' : 2,\n",
    "       'key3' : foo\n",
    "      }\n",
    "dct = {'key' : (1,2),\n",
    "       'key2' : ['list', 'as', 'value'],\n",
    "       'key3' : {'inner_key': 1,\n",
    "                 'inner_key2' : 2}\n",
    "      }\n",
    "print('- Dictionaries:')\n",
    "print('3.', dct)\n",
    "print('4.', dct['key2'])\n",
    "print('5.', dct['key3']['inner_key2'])\n",
    "\n",
    "# Example of nested data types\n",
    "bigList = [tupl, lst, dct]\n",
    "print('- Big list:')\n",
    "for thing in bigList:\n",
    "    print(thing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Your Turn!\n",
    "\n",
    "Now it's time for you to try making some class and function definitions. Use the previous cells as reference, but try it on your own first! The exercises start simple and become increasingly difficult. The last couple exercises might require you to consult the Python documentation... or search Stack Exchange. \n",
    "\n",
    "Look for the &lt;FILL IN&gt; bits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Professor None will be teaching None\n"
     ]
    }
   ],
   "source": [
    "# Define a class called collegeCourse. \n",
    "# It should have the following attributes; give them default any reasonable \n",
    "# default values in the initializer.\n",
    "# - 1 the department abbreviation\n",
    "# - 2 the course number\n",
    "# - 3 instructor's last name\n",
    "# - 4 the hour the class starts (24 hour clock)\n",
    "# - 5 the room number\n",
    "\n",
    "# And finish the function info( ), which nearly prints the information on the class.\n",
    "\n",
    "class collegeCourse:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.<FILL IN> = <FILL IN>\n",
    "        self.<FILL IN> = <FILL IN>\n",
    "        self.<FILL IN> = <FILL IN>\n",
    "        self.<FILL IN> = <FILL IN>\n",
    "        self.<FILL IN> = <FILL IN>\n",
    "    \n",
    "    def info(self):\n",
    "        print(\"Professor\", <FILL IN>, \"will be teaching\", <FILL IN>, <FILL IN>, \n",
    "        \"at\", <FILL IN>, \"in room number\", <FILL IN>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-47-f7d68999cbaf>, line 10)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-47-f7d68999cbaf>\"\u001b[0;36m, line \u001b[0;32m10\u001b[0m\n\u001b[0;31m    coolCourse.<FILL IN> = \"Freeberg\"\u001b[0m\n\u001b[0m               ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Let's instantiate our class and try our method \n",
    "\n",
    "coolCourse = collegeCourse()\n",
    "\n",
    "#coolCourse.<FILL IN>\n",
    "coolCourse.info()\n",
    "\n",
    "# Well it works, but it doesn't hold much information, does it? \n",
    "# Edit the attributes so the existing object describes the course \"DSUCSB 101\", \n",
    "# which is taught by professor Freeberg in room 1007 at 19:00.\n",
    "coolCourse.<FILL IN> = \"Freeberg\"\n",
    "coolCourse.<FILL IN> = \"DSUCSB\"\n",
    "coolCourse.<FILL IN> = 101\n",
    "coolCourse.<FILL IN> = 19.00\n",
    "coolCourse.<FILL IN> = 1007 \n",
    "\n",
    "# Let's print again!\n",
    "coolCourse.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Wouldn't it be great if we could just put in all that information on instantiation?\n",
    "# Yes, yes it would be. Let's do that.\n",
    "\n",
    "# Copy your class definition into this cell, replace the __init__ method with the one \n",
    "# below. It gives the default values when an object is made.\n",
    "\n",
    "\"\"\"\n",
    "def __init__(self, \n",
    "             dept = <FILL IN>, \n",
    "             instr = <FILL IN>, \n",
    "             course = <FILL IN>, \n",
    "             room = <FILL IN>, \n",
    "             hour = <FILL IN>):\n",
    "        self.dept = <FILL IN>\n",
    "        self.instr = <FILL IN>\n",
    "        self.course = <FILL IN>\n",
    "        self.room = <FILL IN>\n",
    "        self.hour = <FILL IN>\n",
    "\"\"\"\n",
    "\n",
    "# PASTE OLD DEFINITION HERE:\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Now let's try instantiating with the same course information as the last cell.\n",
    "\n",
    "coolCourse2 = collegeCourse(dept = <FILL IN>, \n",
    "                            instr = <FILL IN>,\n",
    "                            course = <FILL IN>, \n",
    "                            room = <FILL IN>, \n",
    "                            hour = <FILL IN>)\n",
    "\n",
    "coolCourse2.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\ndef meanGPA(self):\\n    for <FILL IN> in self.<FILL IN>:\\n        <FILL IN>\\n        \\n    return avgGPA\\n'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now let's try something more challenging. Like before, copy your class\n",
    "# definition into this cell. \n",
    "\n",
    "# Then add a new attribute, 'students'. It should be a dictionary with the students below \n",
    "# names as keys, and their GPAs as values. You don't need to make a default parameter in \n",
    "# the initializer.\n",
    "# Mary, 3.0\n",
    "# Jane, 4.0\n",
    "# Jerry, 3.5\n",
    "\n",
    "# The last challenge is to finish the 'meanGPA( )' class method. It should return the mean\n",
    "# GPA of the students in the course.\n",
    "\n",
    "\"\"\"\n",
    "def meanGPA(self):\n",
    "    for <FILL IN> in self.<FILL IN>:\n",
    "        <FILL IN>\n",
    "        \n",
    "    return avgGPA\n",
    "\"\"\"\n",
    "\n",
    "# PASTE OLD DEFINITION HERE:\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Instantiate a new colleCourse.\n",
    "lastCourse = <FILL IN>\n",
    "\n",
    "\n",
    "\n",
    "if lastCourse.meanGPA() == 3.5:\n",
    "    print('Nice! You\\'re all done! Good job.')\n",
    "else:\n",
    "    print('Not quite. Try iterating across the values and putting them in a list.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use any remaining time to work on DataCamp or Codecademy exercises."
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}