01-python/07-objectoriented/ObjectOriented.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# suppress automatic output\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"none\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object-Oriented Programming\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Python is an <b>object-oriented</b> programming language. This means that everything in Python is an <b>object</b>, which can store data using <b>attributes</b> and do things using <b>methods</b>.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    All the data types we have learned so far (<code>int</code>, <code>str</code>, <code>list</code>, <code>dict</code>, etc.) are actually object types, and an individual integer or list is an object. In this lab, we will learn about objects and classes in order to better understand how Python works.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    A <b>class</b> defines the properties of a particular type of object. Once it is defined, we can use it as a template for creating objects of that type. For example, we could have a <code>Pet</code> class and use it to define an individual <code>pet</code> object.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Let's learn how to <b>define a class</b>. To start a class definition, we use the keyword <code>class</code>, a title, and a colon <code>:</code>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is an example class header\n",
    "class Pet:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class Naming Conventions\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    So far, we have been usign snake_case for naming functions and variables. However, for classes we typically capitalize each word and do not use underscores. For example:\n",
    "    </p>\n",
    "    \n",
    "<ul style='font-size:1.75rem;line-height:1.5'>\n",
    "    <li>ClassName</li>\n",
    "    <li>Person</li>\n",
    "    <li>GroceryList</li>\n",
    "    </ul>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Although this is not required by Python, it helps distinguish classes from functions and variables. This makes your code more readable, both for others and yourself.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Attributes\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    <b>Attributes</b> are how classes store data. Attributes are variables that belong to each object made with the class.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Below is an example of a class that has an attribute named <code>x</code> that stores the number <code>1</code>. Add two more attributes of your choice. (Hint: They are just like variables!)\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExampleClassOne:\n",
    "    x = 1\n",
    "    \n",
    "    # Add two more attributes\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dot Operator\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    The <b>dot operator</b> is a period <code>.</code>. It is used to access the attributes and methods of a class. For example, here is how we can access the <code>x</code> attribute we made before:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of accesing the x attribute from ExampleOne\n",
    "print(ExampleClassOne.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Now try accessing the two attributes you made before:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access the two attribute you made from class ExampleOne\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    The dot operator can also be used to modify attributes, or even assign completely new attributes! Here is an example of changing an attribute:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ExampleClassOne.x = 5\n",
    "print(ExampleClassOne.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Make a new attribute and assign a string to it. Then print the attribute.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Methods\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Classes can also contain their own form of functions called <b>methods</b>. The difference between functions and methods is just that methods appear in classes.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Below is an example of a class with a very basic method, as well as how to call that class method.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExampleClassTwo:\n",
    "    def print_hello(self):\n",
    "        print('Hello World')\n",
    "\n",
    "ex2 = ExampleClassTwo()\n",
    "ex2.print_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    The code above might be confusing. What is <code>ex2 = ExampleClassTwo()</code>? Why is the word <code>self</code> in the method's parameters? Two understand this, we need to learn about <b>objects</b>.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objects\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    We almost never work directly with a class. Instead, we make <strong>instances</strong>, or copies, of the class, which are called <strong>objects</strong>. We use the following syntax:\n",
    "    </p> \n",
    "    \n",
    "<pre style='font-size:1.75rem;line-height:1.5'>\n",
    "    object = Class()\n",
    "</pre>\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Write a class <code>ExampleClassThree</code> with a method <code>print_stuff</code> that prints the string <code>'I love classes'</code>. Then make an instance of <code>ExampleClassThree</code> and call <code>print_stuff</code>.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Hint: See previous example. Also, <b>put <code>self</code> in the parentheses of the method</b>. We will go over the reason for this soon.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a class ExampleClassThree\n",
    "\n",
    "\n",
    "    # Write a method print_stuff(self)\n",
    "\n",
    "    \n",
    "        # Print the string 'I love classes'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a instance of ExampleClassThree\n",
    "\n",
    "\n",
    "# Call the print_stuff() (Hint: use dot notation!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instance Variables\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    We often want to create variables that exist for instances of a class rather than the entire class. For example, let's say we have a <code>Pet</code> class. Each pet might make a sound, but different animals would make different sounds.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Variables we define for instances of a class (objects) only exist within that object. For example, run the code below:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pet:\n",
    "    sound = ''\n",
    "\n",
    "dog = Pet()\n",
    "dog.sound = 'ruff ruff!'\n",
    "\n",
    "cat = Pet()\n",
    "cat.sound = 'meow'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Now run each of the following code blocks. Before running each, what do you think will be outputted?\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Pet.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(dog.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(cat.sound)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `self`\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    When a method is called, Python automatically passes in the object that called the method as the first parameter, which we typically name <code>self</code>.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Because of this, <strong>include <code>self</code> as the first parameter in any method you write</strong>, even when we do not need to use it. For example, try running each method below and see what happens:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class ExampleClassFour:\n",
    "    def method1(self):\n",
    "        print('This is a correct method.')\n",
    "    \n",
    "    def method2():\n",
    "        print('This is an incorrect method.')\n",
    "\n",
    "ex = ExampleClassFour()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex.method1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ex.method2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Looking at the error message, we can see that 1 parameter is passed in automatically (the object which called the method) even though we did not explicitly provide any parameters to the method.\n",
    "    </p>\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Remember, <code>self</code> is the object that called the method. So we can use <code>self</code> to access object variables within a class! For example:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pet:\n",
    "    sound = ''\n",
    "    \n",
    "    def make_sound(self):\n",
    "        print(self.sound)\n",
    "\n",
    "dog = Pet()\n",
    "dog.sound = 'ruff ruff!'\n",
    "\n",
    "cat = Pet()\n",
    "cat.sound = 'meow'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Now try running the code blocks below. What do you think will be printed?\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog.make_sound()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat.make_sound()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multiple Parameters\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    We can also have additional parameters. In this case, we still need <code>self</code> as the first parameter. For example:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Greeter:\n",
    "    def greet(self, name):\n",
    "        print('Hello ' + name + '!')\n",
    "\n",
    "greeter = Greeter()\n",
    "name = raw_input(\"What's your name: \")\n",
    "greeter.greet(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Smart Calculator\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Write a class <code>Calculator</code> that has four methods which do the four basic mathematical operations. Remember, each method should have three arguments: <code>self</code>, and two numbers.\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Also, to make our calculator a little smarter, let's have it return the last result. In each method, save the result in an object variable <code>last_result</code>. Then write a method <code>print_last_result</code> which prints the last result.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Calculator:\n",
    "    last_result = None\n",
    "    \n",
    "    def add(self, num1, num2):\n",
    "        result = num1 + num2\n",
    "        self.last_result = result\n",
    "        return result\n",
    "    \n",
    "    def sub(self, num1, num2):\n",
    "        # Subtract the two numbers\n",
    "\n",
    "        \n",
    "        # Save the result in self.last_result\n",
    "\n",
    "        \n",
    "        # Return the result\n",
    "\n",
    "        \n",
    "    \n",
    "    # Write a multiply method that returns and saves the result\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    # Write a divide method that returns and saves the result. \n",
    "    # Remember about integer division!\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "    def print_last_result(self):\n",
    "        # Print the last result\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Now try using the calculator! Create two instances of the <code>Calculator</code> class. Use both calculators, and the print the last result from each calculator.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create two instances of the Calculator class\n",
    "\n",
    "\n",
    "\n",
    "# Do a math operation using each calculator\n",
    "\n",
    "\n",
    "\n",
    "# Print out the last result from each calculator\n",
    "# Are they different from each other?\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initializing Instance Data\n",
    "\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    There are several methods in Python that do special things. These methods have double underscores on each side (sometimes called \"dunder\")\n",
    "    </p>\n",
    "    \n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Here we will learn about <code>__init__</code>. This method is called automatically when an new object is created, and it takes parameters passed into the class itself. For example, here is a rectangle class:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    When we create a new object, we now need to pass in two parameters, width and height, which will be stored as object variables. For example:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rect1 = Rectangle(2, 6)\n",
    "\n",
    "print(rect1.width)\n",
    "print(rect1.height)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    We can even use these variables within the class like we did before. For example, we might want to find the area of the rectangle:\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    def find_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "rect2 = Rectangle(7, 4)\n",
    "print(rect2.find_area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pet Class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Now it's your turn! Let's update our <code>Pet</code> class to take in the following parameters:\n",
    "    </p>\n",
    "<ul style='font-size:1.75rem;line-height:1.5'>\n",
    "    <li><code>animal</code>: A string containing the type of animal.</li>\n",
    "    <li><code>name</code>: A string containing the pet's name.</li>\n",
    "    <li><code>age</code>: An integer containing the age in years.</li>\n",
    "    <li><code>sound</code>: A string containing the sound the pet makes.</li>\n",
    "    <li><code>cuteness</code>: An string indicating cuteness: <code>'ugly'</code>, <code>'of average cuteness</code>, <code>'cute'</code>, <code>'very cute'</code>.</li>\n",
    "    </ul>\n",
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Also write the following methods:\n",
    "    </p>\n",
    "<ul style='font-size:1.75rem;line-height:1.5'>\n",
    "    <li><code>__init__</code>: Initialize the five variables.</li>\n",
    "    <li><code>get_profile</code>: Print out the animal, name, age, and cuteness.</li>\n",
    "    <ul style='font-size:1.75rem;line-height:1.5'>\n",
    "        <li>For example: <code>Otis is a dog that is 5 years old. Otis is very cute!</code></li>\n",
    "    </ul>\n",
    "    <li><code>make_sound</code>: Print out the sound that this pet makes.</li>\n",
    "    </ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the Pet class\n",
    "\n",
    "\n",
    "    # Create the __init__ method (remember to include self!)\n",
    "\n",
    "    \n",
    "        # Assign the object variables to the arguments\n",
    "\n",
    "        \n",
    "        \n",
    "    # Create the get_profile method\n",
    "\n",
    "    \n",
    "        # Print a message containing animal, name, age, and cuteness\n",
    "\n",
    "        \n",
    "    # Create the make_sound method\n",
    "\n",
    "    \n",
    "        # Print the sound\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='font-size:1.75rem;line-height:1.5'>\n",
    "    Now make an instance of your pet class. Call <code>get_profile</code> and <code>make_sound</code>.\n",
    "    </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize a new pet\n",
    "\n",
    "\n",
    "# Print the pet's profile\n",
    "\n",
    "\n",
    "# Print the pet's sound\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}