PythonP3.ipynb

{
 "metadata": {
  "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.8.2"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python382jvsc74a57bd001e4a4ef43d7435a6845fd7336130797196ba9e9ad58f05806271349b7c58ab1",
   "display_name": "Python 3.8.2 64-bit"
  },
  "metadata": {
   "interpreter": {
    "hash": "01e4a4ef43d7435a6845fd7336130797196ba9e9ad58f05806271349b7c58ab1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "## Classes\n",
    "- Chapter 9\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "- In object oriented programing we write class to represent real world things and situations\n",
    "- making an object from class is called instantiation\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating and Using a class\n",
    "\n",
    "# Creating the dog class\n",
    "\n",
    "class Dog(): # defined a class called dog # Capitalized name refer to classes on python\n",
    "    \"\"\" A simple attempt to model a dog.\"\"\"\n",
    "\n",
    "    def __init__(self, name, age): # function that is part of a class\n",
    "        \"\"\"Initialize name and age attributes.\"\"\"\n",
    "\n",
    "        self.name=name\n",
    "        self.age=age\n",
    "\n",
    "    def sit(self):\n",
    "        \"\"\"Simulate a dog sitting in response to a command.\"\"\"\n",
    "        print(self.name.title()+\" is now sitting.\")\n",
    "\n",
    "    def roll_over(self):\n",
    "        \"\"\"Simulate rolling over in response to a command.\"\"\"\n",
    "        print(self.name.title()+\" rolled over!\")\n",
    "    \n",
    "    # __init__() is a special method which pythons runs automatically whenever we create a new instance \n",
    "    #__init__() have 3 parameter: self,name and age\n",
    "    #self is always required and must come before any other parameter\n",
    "    # __init__() method will automatically pass the self argument. Every method call associated with a class automatically passes self, which is a reference to the instance itself; it gives the individual instance access to the attributes and methods in the class. \n",
    "    # two variables self.name and self.age .Since it has prefix as self so it will be available to every method inside a class\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "My dog's name is Willie.\nMy dog is 6 years old.\n"
     ]
    }
   ],
   "source": [
    "# making an Instance from a class\n",
    "\n",
    "my_dog =Dog('willie',6)\n",
    "print(\"My dog's name is \"+my_dog.name.title()+'.')\n",
    "print(\"My dog is \"+str(my_dog.age)+' years old.')\n",
    "\n",
    "# here 1st line automatically call __init__ method \n",
    "# __init__() method create an instance and sets the name and age attributes using the values we provide\n",
    "#__init__() method has no explicit return ,but Python automatically returns an instance representing this dog. \n",
    "# we store the instance in my_dog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Wille is now sitting.\nWille rolled over!\n"
     ]
    }
   ],
   "source": [
    "# calling methods\n",
    "\n",
    "my_dog=Dog(\"wille\",6)\n",
    "my_dog.sit()\n",
    "my_dog.roll_over()\n",
    "# here we are calling a method using the name of instance followed by method we want to call seperated by dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "My dog's name is Willie.\nMy dog is 6 years old.\nWillie is now sitting.\nWillie rolled over!\n\nYour dog's name is Lucy.\nYour dog is 3 years old.\nLucy is now sitting.\nLucy rolled over!\n"
     ]
    }
   ],
   "source": [
    "# creating multiple instances\n",
    "my_dog=Dog(\"willie\",6)\n",
    "your_dog=Dog('lucy',3)\n",
    "\n",
    "print(\"My dog's name is \"+my_dog.name.title()+'.')\n",
    "print(\"My dog is \"+str(my_dog.age)+' years old.')\n",
    "my_dog.sit()\n",
    "my_dog.roll_over()\n",
    "\n",
    "print(\"\\nYour dog's name is \"+your_dog.name.title()+'.')\n",
    "print(\"Your dog is \"+str(your_dog.age)+' years old.')\n",
    "your_dog.sit()\n",
    "your_dog.roll_over()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2021 Audi A4\n"
     ]
    }
   ],
   "source": [
    "# WOrking with Classes and Instances\n",
    "\n",
    "# the car class\n",
    "\n",
    "class Car():\n",
    "    \"\"\"A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes to describe a car.\"\"\"\n",
    "        self.make=make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "    \n",
    "    def get_descriptive_name(self):\n",
    "        \"\"\"Return a meatly formatted descriptive name.\"\"\"\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name.title()\n",
    "\n",
    "my_new_car=Car('audi','a4',2021)\n",
    "print(my_new_car.get_descriptive_name())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2021 Audi A4\nThis car has 0 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# Setting a default value for an Attribute\n",
    "class Car():\n",
    "    \"\"\"A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes to describe a car.\"\"\"\n",
    "        self.make=make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading=0\n",
    "    \n",
    "    def get_descriptive_name(self):\n",
    "        \"\"\"Return a meatly formatted descriptive name.\"\"\"\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name.title()\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        \"\"\"Print a statement showing the car's mileage.\"\"\"\n",
    "        print(\"This car has \"+str(self.odometer_reading)+' miles on it.')\n",
    "    \n",
    "\n",
    "my_new_car=Car('audi','a4',2021)\n",
    "print(my_new_car.get_descriptive_name())\n",
    "my_new_car.read_odometer()\n",
    "\n",
    "# here we create new variable self.odometer_reading and new method read_odometer where we passed self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2021 Audi A4\nThis car has 23 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# modifying attributes values\n",
    "\n",
    "#modifying an attribute's value directly\n",
    "\n",
    "class Car():\n",
    "    \"\"\"A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes to describe a car.\"\"\"\n",
    "        self.make=make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading=0\n",
    "    \n",
    "    def get_descriptive_name(self):\n",
    "        \"\"\"Return a meatly formatted descriptive name.\"\"\"\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name.title()\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        \"\"\"Print a statement showing the car's mileage.\"\"\"\n",
    "        print(\"This car has \"+str(self.odometer_reading)+' miles on it.')\n",
    "    \n",
    "\n",
    "my_new_car=Car('audi','a4',2021)\n",
    "print(my_new_car.get_descriptive_name())\n",
    "my_new_car.odometer_reading=23\n",
    "my_new_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2021 Audi A4\nThis car has 23 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# modifying an attribute's through a method.\n",
    "class Car():\n",
    "    \"\"\"A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes to describe a car.\"\"\"\n",
    "        self.make=make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading=0\n",
    "    \n",
    "    def get_descriptive_name(self):\n",
    "        \"\"\"Return a meatly formatted descriptive name.\"\"\"\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name.title()\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        \"\"\"Print a statement showing the car's mileage.\"\"\"\n",
    "        print(\"This car has \"+str(self.odometer_reading)+' miles on it.')\n",
    "\n",
    "    def update_odometer(self,mileage):\n",
    "        \"\"\"Set the odometer reading to the given value.\"\"\"\n",
    "        self.odometer_reading=mileage\n",
    "    \n",
    "\n",
    "my_new_car=Car('audi','a4',2021)\n",
    "print(my_new_car.get_descriptive_name())\n",
    "my_new_car.update_odometer(23)\n",
    "my_new_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2021 Audi A4\nThis car has 23 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# Adding logic in above program\n",
    "class Car():\n",
    "    \"\"\"A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes to describe a car.\"\"\"\n",
    "        self.make=make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading=0\n",
    "    \n",
    "    def get_descriptive_name(self):\n",
    "        \"\"\"Return a meatly formatted descriptive name.\"\"\"\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name.title()\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        \"\"\"Print a statement showing the car's mileage.\"\"\"\n",
    "        print(\"This car has \"+str(self.odometer_reading)+' miles on it.')\n",
    "\n",
    "    def update_odometer(self,mileage):\n",
    "        \"\"\"Set the odometer reading to the given value.\"\"\"\n",
    "        if mileage>=self.odometer_reading:\n",
    "            self.odometer_reading=mileage\n",
    "        else:\n",
    "            print(\"You can't roll back an odometer\")\n",
    "    \n",
    "\n",
    "my_new_car=Car('audi','a4',2021)\n",
    "print(my_new_car.get_descriptive_name())\n",
    "my_new_car.update_odometer(23)\n",
    "my_new_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2019 Audi A4\nThis car has 23600 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# Incrementing an attribute's value thorugh a method\n",
    "class Car():\n",
    "    \"\"\"A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes to describe a car.\"\"\"\n",
    "        self.make=make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading=0\n",
    "    \n",
    "    def get_descriptive_name(self):\n",
    "        \"\"\"Return a meatly formatted descriptive name.\"\"\"\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name.title()\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        \"\"\"Print a statement showing the car's mileage.\"\"\"\n",
    "        print(\"This car has \"+str(self.odometer_reading)+' miles on it.')\n",
    "\n",
    "    def update_odometer(self,mileage):\n",
    "        \"\"\"Set the odometer reading to the given value.\"\"\"\n",
    "        self.odometer_reading=mileage\n",
    "    \n",
    "    def increment_odometer(self,miles):\n",
    "        \"\"\"Add tie given amount to the odometer reading.\"\"\"\n",
    "        self.odometer_reading+=miles\n",
    "    \n",
    "\n",
    "my_used_car=Car('audi','a4',2019)\n",
    "print(my_used_car.get_descriptive_name())\n",
    "my_used_car.update_odometer(23500)\n",
    "my_used_car.increment_odometer(100)\n",
    "my_used_car.read_odometer()"
   ]
  },
  {
   "source": [
    "### Inheritance\n",
    "- We don't always have to start from scratch when writing a class.If the class we're writing is a specialized version of another class we wrote, we can use Inheritance\n",
    "- When one class inherits from another , it automatically takes on all the attributes and methods of the first class\n",
    "- THe original class is called parent class, and the new class is the child class.\n",
    "- the child class inherts method and attributes of parent class but is also free to defone new attributes and method of its own."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2020 tesla Model S\n"
     ]
    }
   ],
   "source": [
    "# The __init__() method for a child class\n",
    "\n",
    "#electric_car.py\n",
    "\n",
    "class Car(): # Parent Class\n",
    "    \"\"\" A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        self.make = make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading =0\n",
    "    \n",
    "    def get_descriptive(self):\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        print(\"this car has \"+str(self.read_odometer)+\" miles on it.\")\n",
    "    \n",
    "    def update_odometer(self,mileage):\n",
    "        if mileage>=self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print(\"You cant roll back on odometer.\")\n",
    "    \n",
    "    def increment_odometer(self,miles):\n",
    "        self.odometer_reading+=miles\n",
    "    \n",
    "\n",
    "class EletricCar(Car): # Child Class\n",
    "    \"\"\"Represent aspects of a car,specific to eletric vechiles.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initalize attributes of the parent class.\"\"\"\n",
    "        super().__init__(make,model,year)\n",
    "    \n",
    "\n",
    "my_tesla=EletricCar('tesla','Model S','2020')\n",
    "print(my_tesla.get_descriptive())\n",
    "\n",
    "# when we define child class name of parent class must be passed\n",
    "# __init__() method takes in tge information required to make a Car instance. \n",
    "# super() function is a special function that helps python make connections between the parent and child class. \n",
    "# super().__init__(make,model,year), this line tells pyhton to call the __init__() method from ElectricCar's parent class,which gives an ElectricCar instance all the attribites of its aprent class\n",
    "# The name super comes from a convention of callinf the parent class a superclass and the child class a subclass. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2020 tesla Model S\nThis car has a 70-kWh battery.\n"
     ]
    }
   ],
   "source": [
    "# Defining Attributes and Method for the child class\n",
    "class Car(): # Parent Class\n",
    "    \"\"\" A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        self.make = make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading =0\n",
    "    \n",
    "    def get_descriptive(self):\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        print(\"this car has \"+str(self.read_odometer)+\" miles on it.\")\n",
    "    \n",
    "    def update_odometer(self,mileage):\n",
    "        if mileage>=self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print(\"You cant roll back on odometer.\")\n",
    "    \n",
    "    def increment_odometer(self,miles):\n",
    "        self.odometer_reading+=miles\n",
    "    \n",
    "\n",
    "class EletricCar(Car): # Child Class\n",
    "    \"\"\"Represent aspects of a car,specific to eletric vechiles.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initialize attributes if the parent cass.\n",
    "       Then initialize attributes specific to an electric car.\"\"\"\n",
    "        super().__init__(make,model,year)\n",
    "        self.battery_size=70\n",
    "    \n",
    "    def describe_battery(self):\n",
    "        \"\"\" Print a statement describing the battery size.\"\"\"\n",
    "        print(\"This car has a \"+str(self.battery_size)+\"-kWh battery.\")\n",
    "    \n",
    "    \n",
    "\n",
    "my_tesla=EletricCar('tesla','Model S','2020')\n",
    "print(my_tesla.get_descriptive())\n",
    "my_tesla.describe_battery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2020 tesla Model S\nThis car has a 70-kWh battery.\nThis car doesn't have a gas tank!\n"
     ]
    }
   ],
   "source": [
    "# Overriding Methods from the parent class\n",
    "\n",
    "class Car(): # Parent Class\n",
    "    \"\"\" A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        self.make = make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading =0\n",
    "    \n",
    "    def get_descriptive(self):\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        print(\"this car has \"+str(self.read_odometer)+\" miles on it.\")\n",
    "    \n",
    "    def update_odometer(self,mileage):\n",
    "        if mileage>=self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print(\"You cant roll back on odometer.\")\n",
    "    \n",
    "    def increment_odometer(self,miles):\n",
    "        self.odometer_reading+=miles\n",
    "    \n",
    "\n",
    "class EletricCar(Car): # Child Class\n",
    "    \"\"\"Represent aspects of a car,specific to eletric vechiles.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initialize attributes if the parent cass.\n",
    "       Then initialize attributes specific to an electric car.\"\"\"\n",
    "        super().__init__(make,model,year)\n",
    "        self.battery_size=70\n",
    "    \n",
    "    def describe_battery(self):\n",
    "        \"\"\" Print a statement describing the battery size.\"\"\"\n",
    "        print(\"This car has a \"+str(self.battery_size)+\"-kWh battery.\")\n",
    "    \n",
    "    def fill_gas_tank(self):\n",
    "        \"\"\"Electric cars dont have a gas tank\"\"\"\n",
    "        print(\"This car doesn't have a gas tank!\")\n",
    "    \n",
    "    \n",
    "\n",
    "my_tesla=EletricCar('tesla','Model S','2020')\n",
    "print(my_tesla.get_descriptive())\n",
    "my_tesla.describe_battery()\n",
    "my_tesla.fill_gas_tank()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2020 tesla Model S\nThis car has a 70=kwh battery.\n"
     ]
    }
   ],
   "source": [
    "# Instances as Attributes\n",
    "\n",
    "class Car(): # Parent Class\n",
    "    \"\"\" A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        self.make = make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading =0\n",
    "    \n",
    "    def get_descriptive(self):\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        print(\"this car has \"+str(self.read_odometer)+\" miles on it.\")\n",
    "    \n",
    "    def update_odometer(self,mileage):\n",
    "        if mileage>=self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print(\"You cant roll back on odometer.\")\n",
    "    \n",
    "    def increment_odometer(self,miles):\n",
    "        self.odometer_reading+=miles\n",
    "\n",
    "class Battery():\n",
    "    \"\"\"A simple way to model abattery from an electric car.\"\"\"\n",
    "\n",
    "    def __init__(self,battery_size=70):\n",
    "        \"\"\"Initialize the battery's attributes.\"\"\"\n",
    "        self.battery_size=battery_size\n",
    "    \n",
    "    def describe_battery(self):\n",
    "        \"\"\"Print a statement describing the battery size.\"\"\"\n",
    "        print(\"This car has a \"+str(self.battery_size)+\"-kwh battery.\")\n",
    "\n",
    "class EletricCar(Car): # Child Class\n",
    "    \"\"\"Represent aspects of a car,specific to eletric vechiles.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initialize attributes if the parent cass.\n",
    "       Then initialize attributes specific to an electric car.\"\"\"\n",
    "        super().__init__(make,model,year)\n",
    "        self.battery=Battery()\n",
    "    \n",
    "\n",
    "my_tesla=EletricCar('tesla','Model S','2020')\n",
    "print(my_tesla.get_descriptive())\n",
    "my_tesla.battery.describe_battery()\n",
    "\n",
    "# Here we created a new class Battery() \n",
    "# In ElectricCar class we create a new attribute that called self.battery which is a instance of class Battery\n",
    "# when we call eletriccar ,__init__() method is trigerred and it creates a instance of class battery.\n",
    "# my_tesla.battery.describe_battery(),this tell at instance my_tesla look for battery and call describe_battery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2020 tesla Model S\nThis car has a 70-kwh battery.\nthis car can go approximately 240 miles on a full charge.\n"
     ]
    }
   ],
   "source": [
    "class Car(): # Parent Class\n",
    "    \"\"\" A simple attempt to represent a car.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        self.make = make\n",
    "        self.model=model\n",
    "        self.year=year\n",
    "        self.odometer_reading =0\n",
    "    \n",
    "    def get_descriptive(self):\n",
    "        long_name=str(self.year)+\" \"+self.make+\" \"+self.model\n",
    "        return long_name\n",
    "    \n",
    "    def read_odometer(self):\n",
    "        print(\"this car has \"+str(self.odometer_reading)+\" miles on it.\")\n",
    "    \n",
    "    def update_odometer(self,mileage):\n",
    "        if mileage>=self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print(\"You cant roll back on odometer.\")\n",
    "    \n",
    "    def increment_odometer(self,miles):\n",
    "        self.odometer_reading+=miles\n",
    "\n",
    "class Battery():\n",
    "    \"\"\"A simple way to model abattery from an electric car.\"\"\"\n",
    "\n",
    "    def __init__(self,battery_size=70):\n",
    "        \"\"\"Initialize the battery's attributes.\"\"\"\n",
    "        self.battery_size=battery_size\n",
    "    \n",
    "    def describe_battery(self):\n",
    "        \"\"\"Print a statement describing the battery size.\"\"\"\n",
    "        print(\"This car has a \"+str(self.battery_size)+\"-kwh battery.\")\n",
    "\n",
    "    def get_range(self):\n",
    "        \"\"\"Print a statement about the range this battery provides.\"\"\"\n",
    "        if self.battery_size==70:\n",
    "            range=240\n",
    "        elif self.battery_size==85:\n",
    "            range=270\n",
    "        \n",
    "        message=\"this car can go approximately \"+str(range)\n",
    "        message+=\" miles on a full charge.\"\n",
    "        print(message)\n",
    "\n",
    "class EletricCar(Car): # Child Class\n",
    "    \"\"\"Represent aspects of a car,specific to eletric vechiles.\"\"\"\n",
    "\n",
    "    def __init__(self,make,model,year):\n",
    "        \"\"\"Initialize attributes if the parent cass.\n",
    "       Then initialize attributes specific to an electric car.\"\"\"\n",
    "        super().__init__(make,model,year)\n",
    "        self.battery=Battery()\n",
    "    \n",
    "\n",
    "my_tesla=EletricCar('tesla','Model S','2020')\n",
    "print(my_tesla.get_descriptive())\n",
    "my_tesla.battery.describe_battery()\n",
    "my_tesla.battery.get_range()"
   ]
  },
  {
   "source": [
    "### Importing Classes\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2019 audi a4\nthis car has 23 miles on it.\n"
     ]
    }
   ],
   "source": [
    "# importing a single class\n",
    "# my_car.py \n",
    "\n",
    "from car import Car\n",
    "\n",
    "my_new_car=Car('audi','a4','2019')\n",
    "print(my_new_car.get_descriptive())\n",
    "\n",
    "my_new_car.odometer_reading = 23\n",
    "my_new_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2019 volkswagen beetle\n2019 tesla roadster\n"
     ]
    }
   ],
   "source": [
    "# Storing Multiple Classes in a Module.\n",
    "\n",
    "#my_cars.py \n",
    "\n",
    "import car\n",
    "my_beetle=car.Car('volkswagen','beetle','2019')\n",
    "print(my_beetle.get_descriptive())\n",
    "\n",
    "my_tesla=car.EletricCar('tesla','roadster','2019')\n",
    "print(my_tesla.get_descriptive())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import all classes from a module\n",
    "\n",
    "from car import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "2019 volkswagen beetle\n2019 tesla roadster\n"
     ]
    }
   ],
   "source": [
    "# importing a module into a module\n",
    "\n",
    "from cars import Car\n",
    "from electric_car import EletricCar\n",
    "\n",
    "my_beetle=car.Car('volkswagen','beetle','2019')\n",
    "print(my_beetle.get_descriptive())\n",
    "\n",
    "my_tesla=car.EletricCar('tesla','roadster','2019')\n",
    "print(my_tesla.get_descriptive())\n",
    "\n",
    "# in electric_car we import Car module\n",
    "# and here we import both cars and electric_car modules"
   ]
  },
  {
   "source": [
    "### The Python Standard library\n",
    "\n",
    "- Python Standard library is a set of modules included with every Python installation\n",
    "\n",
    "#### OrderedDict\n",
    "\n",
    "- Dictionaries allow u to connect pieces of information,but they dont keep track of the order in which you ass key-value pairs.\n",
    "\n",
    "- we can user OrderedDict class from collections module to keep track of the order in which key  value pairs are added.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Jen's favorite language is Python.\nSarah's favorite language is C.\nEdward's favorite language is Ruby.\nPhil's favorite language is Python.\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "favorite_languages= OrderedDict()\n",
    "\n",
    "favorite_languages['jen']='python'\n",
    "favorite_languages['sarah']='c'\n",
    "favorite_languages['edward']='ruby'\n",
    "favorite_languages['phil']='python'\n",
    "\n",
    "for name,language in favorite_languages.items():\n",
    "    print(name.title()+\"'s favorite language is \"+language.title()+'.')\n",
    "\n",
    "# here we import OrderedDict from collection. Then we create an instance of OrderedDict i.e. favorite_languages which creates an empty ordered dicitionary for us. so when we loop through the dictionary , we always get response in the order they were added\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}