06 - Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is based on [Python Cheat Sheet](http://ehmatthes.github.io/pcc/cheatsheets/README.html) by [Eric Matthes](https://github.com/ehmatthes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What are classes?\n",
    "Classes are the foundation of object-oriented programming. Classes represent real-world things you want to model in your programs: for example dogs, cars, and robots. You use a class to make objects, which are specific instances of dogs, cars, and robots. A class defines the general behavior that a whole category of objects can have, and the information that can be associated with those objects.\n",
    "\n",
    "Classes can inherit from each other – you can write a class that extends the functionality of an existing class. This allows you to code efficiently for a wide variety of situations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating and using a class\n",
    "Consider how we might model a car. What information would we associate with a car, and what behavior would it have? The information is stored in variables called attributes, and the behavior is represented by functions. Functions that are part of a class are called methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The Car class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"A simple attempt to model a car.\"\"\"\n",
    "    \n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize car attributes.\"\"\"\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        \n",
    "        # Fuel capacity and level in gallons.\n",
    "        self.fuel_capacity = 15\n",
    "        self.fuel_level = 0\n",
    "        \n",
    "    def fill_tank(self):\n",
    "        \"\"\"Fill gas tank to capacity.\"\"\"\n",
    "        self.fuel_level = self.fuel_capacity\n",
    "        print(\"Fuel tank is full.\")\n",
    "        \n",
    "    def drive(self):\n",
    "        \"\"\"Simulate driving.\"\"\"\n",
    "        print(\"The car is moving.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Creating an object from a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_car = Car('audi', 'a4', 2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Accessing attribute values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "audi\n",
      "a4\n",
      "2016\n"
     ]
    }
   ],
   "source": [
    "print(my_car.make)\n",
    "print(my_car.model)\n",
    "print(my_car.year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Calling methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fuel tank is full.\n",
      "The car is moving.\n"
     ]
    }
   ],
   "source": [
    "my_car.fill_tank()\n",
    "my_car.drive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Creating multiple objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_car = Car('audi', 'a4', 2016)\n",
    "my_old_car = Car('subaru', 'outback', 2013)\n",
    "my_truck = Car('toyota', 'tacoma', 2010)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying attributes\n",
    "You can modify an attribute's value directly, or you can write methods that manage updating values more carefully."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Modifying an attribute directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "my_new_car = Car('audi', 'a4', 2016)\n",
    "my_new_car.fuel_level = 5\n",
    "\n",
    "print(my_new_car.fuel_level)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Writing a method to update an attribute's value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "class Car():\n",
    "    \"\"\"A simple attempt to model a car.\"\"\"\n",
    "    \n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize car attributes.\"\"\"\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        \n",
    "        # Fuel capacity and level in gallons.\n",
    "        self.fuel_capacity = 15\n",
    "        self.fuel_level = 0\n",
    "        \n",
    "    def fill_tank(self):\n",
    "        \"\"\"Fill gas tank to capacity.\"\"\"\n",
    "        self.fuel_level = self.fuel_capacity\n",
    "        print(\"Fuel tank is full.\")\n",
    "        \n",
    "    def drive(self):\n",
    "        \"\"\"Simulate driving.\"\"\"\n",
    "        print(\"The car is moving.\")\n",
    "    \n",
    "    def update_fuel_level(self, new_level):\n",
    "        \"\"\"Update the fuel level.\"\"\"\n",
    "    \n",
    "        if new_level <= self.fuel_capacity:\n",
    "            self.fuel_level = new_level\n",
    "        else:\n",
    "            print(\"The tank can't hold that much!\")\n",
    "            \n",
    "                    \n",
    "my_new_car = Car('audi', 'a4', 2016)\n",
    "print(my_new_car.fuel_level)\n",
    "my_new_car.update_fuel_level(8)\n",
    "print(my_new_car.fuel_level)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Writing a method to increment an attribute's value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "Added fuel.\n",
      "5\n",
      "Added fuel.\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "class Car():\n",
    "    \"\"\"A simple attempt to model a car.\"\"\"\n",
    "    \n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize car attributes.\"\"\"\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        \n",
    "        # Fuel capacity and level in gallons.\n",
    "        self.fuel_capacity = 15\n",
    "        self.fuel_level = 0\n",
    "        \n",
    "    def fill_tank(self):\n",
    "        \"\"\"Fill gas tank to capacity.\"\"\"\n",
    "        self.fuel_level = self.fuel_capacity\n",
    "        print(\"Fuel tank is full.\")\n",
    "        \n",
    "    def drive(self):\n",
    "        \"\"\"Simulate driving.\"\"\"\n",
    "        print(\"The car is moving.\")\n",
    "        \n",
    "    def update_fuel_level(self, new_level):\n",
    "        \"\"\"Update the fuel level.\"\"\"\n",
    "    \n",
    "        if new_level <= self.fuel_capacity:\n",
    "            self.fuel_level = new_level\n",
    "        else:\n",
    "            print(\"The tank can't hold that much!\")\n",
    "        \n",
    "    def add_fuel(self, amount):\n",
    "        \"\"\"Add fuel to the tank.\"\"\"\n",
    "\n",
    "        if (self.fuel_level + amount <= self.fuel_capacity):\n",
    "            self.fuel_level += amount\n",
    "            print(\"Added fuel.\")\n",
    "        else:\n",
    "            print(\"The tank won't hold that much.\")\n",
    "            \n",
    "            \n",
    "my_new_car = Car('audi', 'a4', 2016)\n",
    "print(my_new_car.fuel_level)\n",
    "my_new_car.add_fuel(5)\n",
    "print(my_new_car.fuel_level)\n",
    "my_new_car.add_fuel(2)\n",
    "print(my_new_car.fuel_level)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naming conventions\n",
    "In Python class names are written in CamelCase and object names are written in lowercase with underscores. Modules that contain classes should still be named in lowercase with underscores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class inheritance\n",
    "If the class you're writing is a specialized version of another class, you can use inheritance. When one class inherits from another, it automatically takes on all the attributes and methods of the parent class. The child class is free to introduce new attributes and methods, and override attributes and methods of the parent class.\n",
    "\n",
    "To inherit from another class include the name of the parent class in parentheses when defining the new class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### The __init__() method for a child class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"A simple model of an electric car.\"\"\"\n",
    "\n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize an electric car.\"\"\"\n",
    "        super().__init__(make, model, year)\n",
    "        \n",
    "        # Attributes specific to electric cars.\n",
    "        # Battery capacity in kWh.\n",
    "        self.battery_size = 70\n",
    "        # Charge level in %.\n",
    "        self.charge_level = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Adding new methods to the child class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"A simple model of an electric car.\"\"\"\n",
    "\n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize an electric car.\"\"\"\n",
    "        super().__init__(make, model, year)\n",
    "        \n",
    "        # Attributes specific to electric cars.\n",
    "        # Battery capacity in kWh.\n",
    "        self.battery_size = 70\n",
    "        # Charge level in %.\n",
    "        self.charge_level = 0\n",
    "    \n",
    "    def charge(self):\n",
    "        \"\"\"Fully charge the vehicle.\"\"\"\n",
    "        self.charge_level = 100\n",
    "        print(\"The vehicle is fully charged.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using child methods and parent methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The vehicle is fully charged.\n",
      "The car is moving.\n"
     ]
    }
   ],
   "source": [
    "my_ecar = ElectricCar('tesla', 'model s', 2016)\n",
    "my_ecar.charge()\n",
    "my_ecar.drive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Overriding parent methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"A simple model of an electric car.\"\"\"\n",
    "\n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize an electric car.\"\"\"\n",
    "        super().__init__(make, model, year)\n",
    "        \n",
    "        # Attributes specific to electric cars.\n",
    "        # Battery capacity in kWh.\n",
    "        self.battery_size = 70\n",
    "        # Charge level in %.\n",
    "        self.charge_level = 0\n",
    "    \n",
    "    def charge(self):\n",
    "        \"\"\"Fully charge the vehicle.\"\"\"\n",
    "        self.charge_level = 100\n",
    "        print(\"The vehicle is fully charged.\")\n",
    "        \n",
    "    def fill_tank(self):\n",
    "        \"\"\"Display an error message.\"\"\"\n",
    "        print(\"This car has no fuel tank!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This car has no fuel tank!\n"
     ]
    }
   ],
   "source": [
    "my_ecar = ElectricCar('tesla', 'model s', 2016)\n",
    "my_ecar.fill_tank()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Instances as attributes\n",
    "A class can have objects as attributes. This allows classes to work together to model complex situations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A Battery clas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Battery():\n",
    "    \"\"\"A battery for an electric car.\"\"\"\n",
    "    \n",
    "    def __init__(self, size=70):\n",
    "        \"\"\"Initialize battery attributes.\"\"\"\n",
    "        # Capacity in kWh, charge level in %.\n",
    "        self.size = size\n",
    "        self.charge_level = 0\n",
    "        \n",
    "    def get_range(self):\n",
    "        \"\"\"Return the battery's range.\"\"\"\n",
    "        if self.size == 70:\n",
    "            return 240\n",
    "        elif self.size == 85:\n",
    "            return 270"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using an instance as an attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"A simple model of an electric car.\"\"\"\n",
    "\n",
    "    def __init__(self, make, model, year):\n",
    "        \"\"\"Initialize an electric car.\"\"\"\n",
    "        super().__init__(make, model, year)\n",
    "        \n",
    "        # Attribute specific to electric cars.\n",
    "        self.battery = Battery()\n",
    "        \n",
    "    def charge(self):\n",
    "        \"\"\"Fully charge the vehicle.\"\"\"\n",
    "        self.battery.charge_level = 100\n",
    "        print(\"The vehicle is fully charged.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Using the instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The vehicle is fully charged.\n",
      "240\n",
      "The car is moving.\n"
     ]
    }
   ],
   "source": [
    "my_ecar = ElectricCar('tesla', 'model x', 2016)\n",
    "\n",
    "my_ecar.charge()\n",
    "print(my_ecar.battery.get_range())\n",
    "my_ecar.drive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing classes\n",
    "Class files can get long as you add detailed information and functionality. To help keep your program files uncluttered, you can store your classes in modules and import the classes you need into your main program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Storing classes in a file\n",
    "Refer car.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Importing individual classes from a module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fuel tank is full.\n",
      "The car is moving.\n",
      "The vehicle is fully charged.\n",
      "The car is moving.\n"
     ]
    }
   ],
   "source": [
    "from car import MyCar, MyElectricCar\n",
    "\n",
    "my_beetle = MyCar('volkswagen', 'beetle', 2016)\n",
    "my_beetle.fill_tank()\n",
    "my_beetle.drive()\n",
    "\n",
    "my_tesla = MyElectricCar('tesla', 'model s', 2016)\n",
    "my_tesla.charge()\n",
    "my_tesla.drive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Importing an entire module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fuel tank is full.\n",
      "The car is moving.\n",
      "The vehicle is fully charged.\n",
      "The car is moving.\n"
     ]
    }
   ],
   "source": [
    "import car\n",
    "\n",
    "my_beetle = car.MyCar('volkswagen', 'beetle', 2016)\n",
    "my_beetle.fill_tank()\n",
    "my_beetle.drive()\n",
    "\n",
    "my_tesla = car.MyElectricCar('tesla', 'model s', 2016)\n",
    "my_tesla.charge()\n",
    "my_tesla.drive()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Importing all classes from a module\n",
    "(Don’t do this, but recognize it when you see it.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from car import *\n",
    "\n",
    "my_beetle = MyCar('volkswagen', 'beetle', 2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes in Python 2.7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Classes should inherit from object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# class ClassName(object):\n",
    "\n",
    "# The Car class in Python\n",
    "\n",
    "# class Car(object):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#####  Child class \\_\\_init\\_\\_() method is different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# class ChildClassName(ParentClass):\n",
    "#     def __init__(self):\n",
    "#         super(ClassName, self).__init__()\n",
    "    \n",
    "# The ElectricCar class in Python 2.7\n",
    "\n",
    "# class ElectricCar(Car):\n",
    "#     def __init__(self, make, model, year):\n",
    "#         super(ElectricCar, self).__init__(make, model, year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Storing objects in a list\n",
    "A list can hold as many items as you want, so you can make a large number of objects from a class and store them in a list.\n",
    "\n",
    "Here's an example showing how to make a fleet of rental cars, and make sure all the cars are ready to drive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### A fleet of rental car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "Fuel tank is full.\n",
      "The vehicle is fully charged.\n",
      "The vehicle is fully charged.\n",
      "The vehicle is fully charged.\n",
      "The vehicle is fully charged.\n",
      "The vehicle is fully charged.\n",
      "Gas cars: 10\n",
      "Electric cars: 5\n"
     ]
    }
   ],
   "source": [
    "from car import MyCar, MyElectricCar\n",
    "\n",
    "# Make lists to hold a fleet of cars.\n",
    "gas_fleet = []\n",
    "electric_fleet = []\n",
    "\n",
    "# Make 10 gas cars and 5 electric cars.\n",
    "for _ in range(10):\n",
    "    car = MyCar('ford', 'focus', 2016)\n",
    "    gas_fleet.append(car)\n",
    "    \n",
    "for _ in range(5):\n",
    "    ecar = MyElectricCar('nissan', 'leaf', 2016)\n",
    "    electric_fleet.append(ecar)\n",
    "\n",
    "# Fill the gas cars, and charge electric cars.\n",
    "for car in gas_fleet:\n",
    "    car.fill_tank()\n",
    "    \n",
    "for ecar in electric_fleet:\n",
    "    ecar.charge()\n",
    "\n",
    "print(\"Gas cars:\", len(gas_fleet))\n",
    "print(\"Electric cars:\", len(electric_fleet))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Notebook created by [Sujeevan Nagarajah](https://github.com/sujee81)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}