classes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Classes\n",
    "# Object-oriented programming is one of the most effective approaches to writing software.\n",
    "# In object-oriented programming you write classes that represent real-world things and situations,... \n",
    "# .....and you create objects based on these classes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a class\n",
    "# keep the first letter of class name in capital only.\n",
    "class Dog:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "    def sit(self):\n",
    "        print(self.name + ' is now sitting')\n",
    "    def roll_over(self):\n",
    "        print(self.name + ' rolled over !')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# making an instance for a class\n",
    "my_dog = Dog('shiro',3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my dog name is shiro\n",
      "The age of my dog is 3 years\n"
     ]
    }
   ],
   "source": [
    "# Accessing attributes\n",
    "print('my dog name is ' + my_dog.name)\n",
    "print('The age of my dog is ' + str(my_dog.age) + ' years')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shiro is now sitting\n",
      "shiro rolled over !\n"
     ]
    }
   ],
   "source": [
    "# calling method\n",
    "my_dog.sit()\n",
    "my_dog.roll_over()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# another example using same class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding this new instance in above class only.\n",
    "new_dog = Dog('Bruno',2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The name of the new dog is Bruno\n"
     ]
    }
   ],
   "source": [
    "# printing its name\n",
    "print('The name of the new dog is ' + new_dog.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bruno is 2 years old\n"
     ]
    }
   ],
   "source": [
    "# printing its age\n",
    "print(new_dog.name + ' is ' + str(new_dog.age) + ' years old')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bruno is now sitting\n"
     ]
    }
   ],
   "source": [
    "# priting its behaviour\n",
    "new_dog.sit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bruno rolled over !\n"
     ]
    }
   ],
   "source": [
    "new_dog.roll_over()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.1 (restaurant intoduction)\n",
    "# note: cuisine means a style of cooking always followed (simply whats most made there)\n",
    "class Restaurant:\n",
    "    def __init__(self,restaurant_name,cuisine_type):\n",
    "        self.restaurant_name = restaurant_name\n",
    "        self.cuisine_type = cuisine_type\n",
    "    def describe_restaurant(self):\n",
    "        print('Restaurant ' + self.restaurant_name + ' is very good and the cuisine type here is ' + self.cuisine_type)\n",
    "    def open_restaurant(self):\n",
    "        print('The Restaurant ' + self.restaurant_name + ' is open')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "China Town\n",
      "chineese\n"
     ]
    }
   ],
   "source": [
    "# note: when you need to call attributes for output first fill the arguments and then use --> print(instance.attribute)\n",
    "restaurant = Restaurant('China Town','chineese')\n",
    "print(restaurant.restaurant_name) # first attrubute\n",
    "print(restaurant.cuisine_type) # second attribute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restaurant China Town is very good and the cuisine type here is chineese\n"
     ]
    }
   ],
   "source": [
    "restaurant.describe_restaurant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Restaurant China Town is open\n"
     ]
    }
   ],
   "source": [
    "restaurant.open_restaurant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restaurant China Town is very good and the cuisine type here is chineese\n",
      "The Restaurant China Town is open\n"
     ]
    }
   ],
   "source": [
    "# All output together\n",
    "restaurant.describe_restaurant()\n",
    "restaurant.open_restaurant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note: you can call the same class multiple times but if you need to chnage its parameter's argument you better....\n",
    "# ....create a new calling variable instead of current one (like here restaurant is being use....\n",
    "# ...to call the current class which Restaurant.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restaurant South Corner is very good and the cuisine type here is South Indian\n",
      "Restaurant Friendly is very good and the cuisine type here is fast food\n",
      "Restaurant Family Table is very good and the cuisine type here is Indian Food\n"
     ]
    }
   ],
   "source": [
    "# the three new instances using describe_restaurant only (lets introduce 3 new restaurant names)\n",
    "# we also need to change the class calling varibale to avoid any data loss.\n",
    "restaurant2 = Restaurant('South Corner','South Indian')\n",
    "restaurant2.describe_restaurant()\n",
    "restaurant3 = Restaurant('Friendly','fast food')\n",
    "restaurant3.describe_restaurant()\n",
    "restaurant4 = Restaurant('Family Table','Indian Food')\n",
    "restaurant4.describe_restaurant()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.2 (User details)\n",
    "class User:\n",
    "    def __init__(self,first_name,last_name,location,interest):\n",
    "        self.fullname = first_name + ' ' + last_name\n",
    "        self.location = location\n",
    "        self.interest = interest\n",
    "    def describe(self):                # will provide summary of user\n",
    "        print('Name: ' + self.fullname)\n",
    "        print('Location: ' + self.location)\n",
    "        print('Interest: ' + self.interest)\n",
    "    def greet_user(self):              # will provide greetings to the user\n",
    "        print('\\nWelcome ' + self.fullname + ' :)')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Yash Marmat\n",
      "Location: Delhi\n",
      "Interest: Python\n",
      "\n",
      "Welcome Yash Marmat :)\n"
     ]
    }
   ],
   "source": [
    "details = User('Yash','Marmat','Delhi','Python')\n",
    "details.describe()\n",
    "details.greet_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Edward kenvey\n",
      "Location: Havana\n",
      "Interest: Python\n",
      "\n",
      "Welcome Edward kenvey :)\n",
      "\n",
      "\n",
      "Name: Conor kenvey\n",
      "Location: Havana\n",
      "Interest: Python\n",
      "\n",
      "Welcome Conor kenvey :)\n"
     ]
    }
   ],
   "source": [
    "# for multiple users\n",
    "# note: you can use same class for defferent insatnces (Instances are those which are use to call classes)\n",
    "details2 = User('Edward','kenvey','Havana','Python')\n",
    "details2.describe()\n",
    "details2.greet_user()\n",
    "print('\\n')\n",
    "\n",
    "details3 = User('Conor','kenvey','Havana','Python')\n",
    "details3.describe()\n",
    "details3.greet_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# working with Classes and Instances: just printing whole attributes in one print statement.\n",
    "\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title() # here 'return' is use with a varibale 'about' so that we can print our details in title manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_car = Car('audi','a4',2016)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Audi, Model A4 Of Year 2016'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting a Default Value for an Attribute "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: Odometer is an instrument which is use measure the distance travelled by a vehicle\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   # a default value\n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         # definfing a new method\n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My New Car Is Audi, Model A4 Of Year 2016\n",
      "Distance travelled by this car is 0 miles.\n"
     ]
    }
   ],
   "source": [
    "my_car = Car('audi','a4',2016)\n",
    "print(my_car.description())\n",
    "my_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modifying Attribute Values: take an example of miles above, \n",
    "# what if we want to change miles?, first approach to directly change the default value from '0' to something else.\n",
    "# 2nd approach, introducing a new method (as shown below)\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   \n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         \n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')\n",
    "    def new_reading(self,mileage):   # only changes are here (a new method is defined whose value is assigned later)  \n",
    "        self.odometer_reading = mileage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Audi, Model A4 Of Year 2016'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car = Car('audi','a4',2016)\n",
    "my_car.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 23 miles.\n"
     ]
    }
   ],
   "source": [
    "my_car.new_reading(23) # holding the value\n",
    "my_car.read_odometer() # holding the print statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Restricting to change the odometer value\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   \n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         \n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')\n",
    "    def new_reading(self,mileage):\n",
    "        if mileage >= self.odometer_reading:\n",
    "            self.odometer_reading = mileage\n",
    "        else:\n",
    "            print('you cannot roll back an odometer')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Audi, Model A4 Of Year 2016'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car = Car('audi','a4',2016)\n",
    "my_car.description()" 
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 23 miles.\n"
     ]
    }
   ],
   "source": [
    "# current miles value:\n",
    "my_car.new_reading(23) \n",
    "my_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you cannot roll back an odometer\n",
      "Distance travelled by this car is 23 miles.\n"
     ]
    }
   ],
   "source": [
    "# lowering the miles value\n",
    "my_car.new_reading(0) \n",
    "my_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 25 miles.\n"
     ]
    }
   ],
   "source": [
    "# increasing the miles value\n",
    "my_car.new_reading(25) \n",
    "my_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Incrementing an attribute’s Value through a Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   \n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         \n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')\n",
    "    def new_reading(self,mileage):     \n",
    "        self.odometer_reading = mileage\n",
    "    def incrementing_odometer(self,miles):\n",
    "        self.odometer_reading += miles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Subaru, Model Outback Of Year 2013'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_used_car = Car('subaru','outback',2013)\n",
    "my_used_car.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 25000 miles.\n"
     ]
    }
   ],
   "source": [
    "my_used_car.new_reading(25000) # value got stored, print is pending\n",
    "my_used_car.read_odometer() # printing the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 25100 miles.\n"
     ]
    }
   ],
   "source": [
    "# incrementing the value, by method 'incrementing_odometer' as mentioned above.\n",
    "my_used_car.incrementing_odometer(100) # value got stored, print satement is pending\n",
    "my_used_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.3 (updation in class)\n",
    "class Restaurant:\n",
    "    def __init__(self,restaurant_name,cuisine_type):\n",
    "        self.restaurant_name = restaurant_name\n",
    "        self.cuisine_type = cuisine_type\n",
    "        self.number_served = 0  # the number of person served in the restaurant (called an attribute)\n",
    "    def describe_restaurant(self):\n",
    "        print('Restaurant ' + self.restaurant_name + ' is very good and the cuisine type here is ' + self.cuisine_type)\n",
    "    def open_restaurant(self):\n",
    "        print('The Restaurant ' + self.restaurant_name + ' is open')\n",
    "    def served(self):\n",
    "        print('Number of people served are: ' + str(self.number_served))\n",
    "    def upadte_served(self,new):\n",
    "        self.number_served = new\n",
    "    def set_number_served(self,served):\n",
    "        self.number_served = served\n",
    "    def increment_served(self,value):\n",
    "        self.number_served += value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# below 'restaurant' is an instance \n",
    "restaurant = Restaurant('pizza palace','pizza')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of people served are: 0\n"
     ]
    }
   ],
   "source": [
    "restaurant.served()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of people served are: 30\n"
     ]
    }
   ],
   "source": [
    "# changing the served value\n",
    "restaurant.upadte_served(30) # holds the value\n",
    "restaurant.served() # holds the print statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of people served are: 40\n"
     ]
    }
   ],
   "source": [
    "# setting a number of people served (assigning a particular value)\n",
    "restaurant.set_number_served(40)\n",
    "restaurant.served()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of people served are: 50\n"
     ]
    }
   ],
   "source": [
    "# Incrementing\n",
    "restaurant.increment_served(10)\n",
    "restaurant.served()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.4 (incremet,reset in class)\n",
    "class User:\n",
    "    def __init__(self,first_name,last_name,location,interest):\n",
    "        self.fullname = first_name + ' ' + last_name\n",
    "        self.location = location\n",
    "        self.interest = interest\n",
    "        self.login_attempts = 0\n",
    "    def describe(self):                # will provide summary of user\n",
    "        print('Name: ' + self.fullname)\n",
    "        print('Location: ' + self.location)\n",
    "        print('Interest: ' + self.interest)\n",
    "    def greet_user(self):              # will provide greetings to the user\n",
    "        print('\\nWelcome ' + self.fullname + ' :)')\n",
    "    def increment_login_attempts(self):\n",
    "        self.login_attempts += 1 \n",
    "    def reset_login_attempts(self):\n",
    "        self.login_attempts = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "profile = User('Yash','Marmat','Delhi','Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Yash Marmat\n",
      "Location: Delhi\n",
      "Interest: Python\n",
      "\n",
      "Welcome Yash Marmat :)\n"
     ]
    }
   ],
   "source": [
    "profile.describe()\n",
    "profile.greet_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Login attempts: 2\n"
     ]
    }
   ],
   "source": [
    "# number of login attempts\n",
    "profile.increment_login_attempts() # calling this method two times\n",
    "profile.increment_login_attempts()\n",
    "print('Login attempts: ' + str(profile.login_attempts))\n",
    "\n",
    "#print(\"  Login attempts: \" + str(profile.login_attempts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Login attempts: 0\n"
     ]
    }
   ],
   "source": [
    "# resetting login attempts\n",
    "profile.reset_login_attempts()\n",
    "print('Login attempts: ' + str(profile.login_attempts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The __init__() Method for a Child Class \n",
    "# Note: The super() function is a special function that allows you to call a method from the parent class,....\n",
    "# ...This tells Python to call the __init__() method from Car, which gives an ElectricCar instance all the....\n",
    "# ....attributes defined in that method. The name super comes from a convention of calling the parent class...\n",
    "# ....a superclass and the child class a subclass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using the same Car class: here working as parent class\n",
    "# note: whatever comes in self.(anything) is considered as attribute and the functions we define are called methods.\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   \n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         \n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')\n",
    "    def new_reading(self,mileage):     \n",
    "        self.odometer_reading = mileage\n",
    "    def incrementing_odometer(self,miles):\n",
    "        self.odometer_reading += miles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# intoducing child class\n",
    "class ElectricCar(Car):        # child class(parent class)\n",
    "    def __init__(self,name,model,year):\n",
    "        super().__init__(name,model,year) # no need of self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Tesla, Model S Of Year 2019'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# using parent class methods to print child class attributes\n",
    "child_class = ElectricCar('Tesla','s','2019')\n",
    "child_class.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining Attributes and Methods for the Child Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# note: whatever comes in self.(anything) is considered as attribute and the functions we define are called methods.\n",
    "class ElectricCar(Car):\n",
    "    def __init__(self,name,model,year):\n",
    "        super().__init__(name,model,year)\n",
    "        self.battery = 75\n",
    "    def current_battery(self):\n",
    "        print('Current Battery is: ' + str(self.battery) + '%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My New Car Is Tesla, Model S Of Year 2019\n",
      "Current Battery is: 75%\n"
     ]
    }
   ],
   "source": [
    "child_class = ElectricCar('Tesla','s','2019')\n",
    "print(child_class.description())\n",
    "child_class.current_battery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Overriding Methods from the Parent Class "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Say the class Car had a method called gas_tank(). This method is meaningless for an all-electric vehicle,...\n",
    "# .....so you might want to override this method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    def __init__(self,name,model,year):\n",
    "        super().__init__(name,model,year)\n",
    "        self.battery = 75\n",
    "    def current_battery(self):\n",
    "        print('Current Battery is: ' + str(self.battery) + '%')\n",
    "    def gas_tank(self):\n",
    "        print(\"This car doesn't need gas tank\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This car doesn't need gas tank\n"
     ]
    }
   ],
   "source": [
    "child_class = ElectricCar('Tesla','s','2019')\n",
    "child_class.gas_tank()\n",
    "\n",
    "# Now if someone tries to call gas_tank() with an electric car, Python will ignore the method gas_tank()...\n",
    "# ...in Car and run this code instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instances as Attributes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# When modeling something from the real world in code, you may find that you’re adding more and more detail to a class...\n",
    "# ....You’ll find that you have a growing list of attributes and methods and that your files are becoming.......\n",
    "# lengthy. In these situations, you might recognize that part of one class can be written as a separate class...\n",
    "# You can break your large class into smaller classes that work together. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# taking this car class again for example\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   \n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         \n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')\n",
    "    def new_reading(self,mileage):     \n",
    "        self.odometer_reading = mileage\n",
    "    def incrementing_odometer(self,miles):\n",
    "        self.odometer_reading += miles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in below example we talking same class Car, just seperating the battery method and making it a seperate class.\n",
    "# you can say we are splitting the methods of Electric car in a seperate class.\n",
    "class Battery:\n",
    "    def __init__(self,battery_per = 75):\n",
    "        self.battery_per = battery_per\n",
    "    def describe_battery(self):\n",
    "        print('this car has ' + str(self.battery_per )+ '-kwh Battery' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now to use the battery class in Electric class we just assign the battery class as an attribute using self,shown below:\n",
    "class ElectricCar(Car):\n",
    "    def __init__(self,name,model,year):\n",
    "        super().__init__(name,model,year)\n",
    "        self.battery = Battery()        # here the above class is declared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My New Car Is Tesla, Model S Of Year 2019\n",
      "this car has 75-kwh Battery\n"
     ]
    }
   ],
   "source": [
    "# lets call it with a new instance\n",
    "my_car = ElectricCar('Tesla','S','2019')\n",
    "print(my_car.description())\n",
    "my_car.battery.describe_battery() # format--> instance, attribute, method which is holding print statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Range of the car based on the battery size\n",
    "# here using classes --> Car, Battery, ElectricCar\n",
    "# Note: run classes in this manner --> Car, Battery, ElectricCar and at last call methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what we doing here --> different range values covered by a car on specific battery charge. \n",
    "class Battery:\n",
    "    def __init__(self,battery_per = 75):\n",
    "        self.battery_per = battery_per\n",
    "    def describe_battery(self):\n",
    "        print('this car has ' + str(self.battery_per )+ '-kwh Battery' )\n",
    "    def get_range(self):\n",
    "        if self.battery_per == 75:\n",
    "            range = 260\n",
    "        elif self.battery_per == 100:\n",
    "            range = 315\n",
    "        print('this car can go about ' + str(range) + ' miles on full charge')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My New Car Is Tesla, Model S Of Year 2019\n",
      "this car has 75-kwh Battery\n",
      "this car can go about 260 miles on full charge\n"
     ]
    }
   ],
   "source": [
    "my_car = ElectricCar('Tesla','S',2019)\n",
    "print(my_car.description())\n",
    "my_car.battery.describe_battery()\n",
    "my_car.battery.get_range() # as Battery class is assigned in the attribute of Class ElecrticCar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMPORTANT\n",
    "# Q.5: inheriting from previoius class named as restaurant.\n",
    "# note: inherit means to use the methods, attributes of some other class(we can also inherit the whole class, as shown below)\n",
    "\n",
    "class Restaurant:\n",
    "    def __init__(self,restaurant_name,cuisine_type):\n",
    "        self.restaurant_name = restaurant_name\n",
    "        self.cuisine_type = cuisine_type\n",
    "    def describe_restaurant(self):\n",
    "        print('Restaurant ' + self.restaurant_name + ' is very good and the cuisine type here is ' + self.cuisine_type)\n",
    "    def open_restaurant(self):\n",
    "        print('The Restaurant ' + self.restaurant_name + ' is open')\n",
    "        \n",
    "class IceCreamStand(Restaurant):      # here in paranthesis() we specified what is being inherited\n",
    "    def __init__(self,restaurant_name,cuisine_type):\n",
    "        super().__init__(restaurant_name,cuisine_type)\n",
    "        self.flavours = []    # declaring an empty list \n",
    "    def flavour_types(self):\n",
    "        print(\"Available Flavours:\\n\")\n",
    "        for each in self.flavour:\n",
    "            print(each)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "rest = IceCreamStand('Ice Cream Stand','Ice Creams') # assigning paramter values\n",
    "rest.flavour = ['chocolate','vanilla','strawberry'] # assigning values in the empty list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restaurant Ice Cream Stand is very good and the cuisine type here is Ice Creams\n"
     ]
    }
   ],
   "source": [
    "rest.describe_restaurant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Flavours:\n",
      "\n",
      "chocolate\n",
      "vanilla\n",
      "strawberry\n"
     ]
    }
   ],
   "source": [
    "rest.flavour_types()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.6 (multiple users)\n",
    "\n",
    "class User:\n",
    "    def __init__(self,first_name,last_name,location,interest):\n",
    "        self.fullname = first_name + ' ' + last_name\n",
    "        self.location = location\n",
    "        self.interest = interest\n",
    "    def describe(self):                # will provide summary of user\n",
    "        print('Name: ' + self.fullname)\n",
    "        print('Location: ' + self.location)\n",
    "        print('Interest: ' + self.interest)\n",
    "    def greet_user(self):              # will provide greetings to the user\n",
    "        print('\\nWelcome ' + self.fullname + ' :)')\n",
    "    \n",
    "class Admin(User):\n",
    "    def __init__(self,first_name,last_name,location,interest):\n",
    "        super().__init__(first_name,last_name,location,interest)\n",
    "        self.privileges = []     # declaring an empty list\n",
    "    def show_privileges(self):\n",
    "        print('\\nPriveleges:')\n",
    "        for every in self.privileges:\n",
    "            print(every)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filling up the class parameter values\n",
    "info_user = Admin('Yash','Marmat','Delhi','Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# filling up the empty privileges list(given in question)\n",
    "info_user.privileges = [\"--> can add post\", \"--> can delete post\", \"--> can ban user\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Yash Marmat\n",
      "Location: Delhi\n",
      "Interest: Python\n",
      "\n",
      "Priveleges:\n",
      "--> can add post\n",
      "--> can delete post\n",
      "--> can ban user\n"
     ]
    }
   ],
   "source": [
    "# calling methods\n",
    "info_user.describe()\n",
    "info_user.show_privileges()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.7 (privileges to user)\n",
    "# note: whatever comes in self.(anything) is considered as attribute and the functions we define are called methods.\n",
    "\n",
    "class Admin(User):\n",
    "    def __init__(self,first_name,last_name,location,interest):\n",
    "        super().__init__(first_name,last_name,location,interest)\n",
    "        self.privileges = Privileges_Class()\n",
    "        \n",
    "class Privileges_Class:\n",
    "    def __init__(self,privileges=[]):\n",
    "        self.privileges = privileges\n",
    "    def show_privileges(self):\n",
    "        print('Privileges: ')\n",
    "        if self.privileges:    # if priveleges are present in self.privileges then print it otherwise print no privileges.\n",
    "            for each1 in self.privileges:\n",
    "                print(each1)\n",
    "        else:\n",
    "            print('No Priveleges') # note: till now we didn't assigned the privileges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Yash Marmat\n",
      "Location: Delhi\n",
      "Interest: Python\n"
     ]
    }
   ],
   "source": [
    "priv = Admin('Yash','Marmat','Delhi','Python')\n",
    "priv.describe()   # beacuse class Admin inheriting User class where describe method is present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Privileges: \n",
      "No Priveleges\n"
     ]
    }
   ],
   "source": [
    "priv.privileges.show_privileges() # obviously if we print privileges without assigning values in its list we get this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adding Privileges\n"
     ]
    }
   ],
   "source": [
    "# now assigning privileges\n",
    "# using a different varibale here named as priv_privileges\n",
    "print('Adding Privileges')\n",
    "priv_privileges = ['can reset password','can block user','can unblock user']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Privileges: \n",
      "can reset password\n",
      "can block user\n",
      "can unblock user\n"
     ]
    }
   ],
   "source": [
    "# as priv_privileges is a new variable so making it equal to the existing attributes\n",
    "priv.privileges.privileges = priv_privileges\n",
    "priv.privileges.show_privileges()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Yash Marmat\n",
      "Location: Delhi\n",
      "Interest: Python\n",
      "\n",
      "Privileges: \n",
      "No Priveleges\n",
      "\n",
      "Adding Privileges...\n",
      "\n",
      "Privileges: \n",
      "can reset password\n",
      "can block user\n",
      "can unblock user\n"
     ]
    }
   ],
   "source": [
    "# all outputs together\n",
    "\n",
    "priv = Admin('Yash','Marmat','Delhi','Python\\n')\n",
    "priv.describe()   \n",
    "priv.privileges.show_privileges()\n",
    "print('\\nAdding Privileges...\\n')\n",
    "priv_privileges = ['can reset password','can block user','can unblock user']\n",
    "priv.privileges.privileges = priv_privileges\n",
    "priv.privileges.show_privileges()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.8 (car details)\n",
    "class Car:\n",
    "    def __init__(self,name,model,year):\n",
    "        self.name = name\n",
    "        self.model = model\n",
    "        self.year = year\n",
    "        self.odometer_reading = 0   \n",
    "    def description(self):\n",
    "        about = 'My new car is ' + self.name + ', model ' + self.model + ' of year ' + str(self.year)\n",
    "        return about.title()\n",
    "    def read_odometer(self):         \n",
    "        print('Distance travelled by this car is ' + str(self.odometer_reading) + ' miles.')\n",
    "    def new_reading(self,mileage):     \n",
    "        self.odometer_reading = mileage\n",
    "    def incrementing_odometer(self,miles):\n",
    "        self.odometer_reading += miles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Battery:\n",
    "    def __init__(self,battery_per = 60):\n",
    "        self.battery_per = battery_per\n",
    "    def describe_battery(self):\n",
    "        print('this car has ' + str(self.battery_per )+ '-kwh Battery' )\n",
    "    def get_range(self):\n",
    "        if self.battery_per == 60:\n",
    "            range = 140\n",
    "        elif self.battery_per == 80:\n",
    "            range = 180\n",
    "            print('already full')\n",
    "        print('this car can go ' + str(range) + 'miles on a full charge')\n",
    "    def upgrade_battery(self):\n",
    "        if self.battery_per == 60:\n",
    "            self.battery_per = 80\n",
    "            print('Upgraded the Battery to 80kwh')\n",
    "        else:\n",
    "            print('Battery is already Upgraded')        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    def __init__(self,name,model,year):\n",
    "        super().__init__(name,model,year)\n",
    "        self.battery = Battery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My New Car Is Tesla, Model S Of Year 2019\n",
      "\n",
      "Checking the Electric car Battery: \n",
      "\n",
      "this car has 60-kwh Battery\n",
      "Upgraded the Battery to 80kwh\n",
      "Battery is already Upgraded\n"
     ]
    }
   ],
   "source": [
    "ecar = ElectricCar('Tesla','S',2019)\n",
    "print(ecar.description()+ '\\n')\n",
    "print('Checking the Electric car Battery: \\n')\n",
    "ecar.battery.describe_battery()\n",
    "ecar.battery.upgrade_battery()   # upgrading the battery\n",
    "ecar.battery.upgrade_battery()   # upgrading again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Classes\n",
    "import import_ipynb # use this code if your module didnt load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing a single class: for this we created file nameds as car in this same directory only, now importing it.\n",
    "from car import Car  # means from file car.ipynb import the class called Car."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_car = Car('audi','a4',2016)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Audi, Model A4 Of Year 2016'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_car.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 0 miles.\n"
     ]
    }
   ],
   "source": [
    "my_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_car.odometer_reading = 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distance travelled by this car is 23 miles.\n"
     ]
    }
   ],
   "source": [
    "my_car.read_odometer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from car import ElectricCar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tesla = ElectricCar('Tesla','S',2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Tesla, Model S Of Year 2019'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_tesla.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this car has 75-kwh Battery\n"
     ]
    }
   ],
   "source": [
    "my_tesla.battery.describe_battery()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this car can go about 260 miles on full charge\n"
     ]
    }
   ],
   "source": [
    "my_tesla.battery.get_range()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Multiple Classes from a Module\n",
    "# you can say here we importing multiple classes in one line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from car import Car,ElectricCar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_audi = Car('audi','a4',2016)\n",
    "my_new_tesla = ElectricCar('Tesla','S',2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'My New Car Is Audi, Model A4 Of Year 2016'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'My New Car Is Tesla, Model S Of Year 2019'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"'\" + my_audi.description()+ \"'\")\n",
    "my_new_tesla.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: you can also import the entire module.\n",
    "# for ex: import car (by specifying only this the python will import every class that exists in file car.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing All Classes from a Module\n",
    "# format --> from module_name import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing a Module into a Module \n",
    "# for this we breaked our 3 classes in different modules( in simple words each class in seperate .ipynb file)\n",
    "# we stored Car class in a seperate file called car2.ipynb \n",
    "# the remaining classes which are ElectricCar and Battery both are stored in a single file called electric_car.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing Jupyter notebook from car2.ipynb\n"
     ]
    }
   ],
   "source": [
    "from car2 import Car"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_car1 = Car('audi','a4',2016)\n",
    "new_car2 = ElectricCar('Tesla','S',2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My New Car Is Audi, Model A4 Of Year 2016\n",
      "\n",
      "My New Car Is Tesla, Model S Of Year 2019\n"
     ]
    }
   ],
   "source": [
    "print(new_car1.description()+'\\n')\n",
    "print(new_car2.description())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing Jupyter notebook from electric_car.ipynb\n"
     ]
    }
   ],
   "source": [
    "# Using Aliases: means using shortforms for classes\n",
    "from electric_car import ElectricCar as EC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My New Car Is Tesla, Model S Of Year 2019'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car_tesla = EC('Tesla','S',2019)\n",
    "car_tesla.description()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Q.9 (import)\n",
    "# note: for this method first create seperate .ipynb file and in it make a class of about anything, \n",
    "# then make another .ipynb class. Now in this second .ipynb file import previous class and call that class here.\n",
    "# follow following method as an example to do so. (note: both the files must be in the same directory)\n",
    "\n",
    "import import_ipynb  # (first import the import method if you are getting an error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing Jupyter notebook from restaurant.ipynb\n"
     ]
    }
   ],
   "source": [
    "from restaurant import Restaurant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "rest = Restaurant('pizza palace',\"pizza\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Restaurant pizza palace is very good and the cuisine type here is pizza\n"
     ]
    }
   ],
   "source": [
    "rest.describe_restaurant()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "importing Jupyter notebook from user_admin.ipynb\n"
     ]
    }
   ],
   "source": [
    "# Q.10 (same as above)\n",
    "from user_admin import *  # (*) is use to import all the classes present in the file named as user_admin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "admin = Admin('yash','marmat','delhi','python')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "admin_privileges = ['can give access','can block access','can reset password']    # storing\n",
    "admin.privileges.privileges = admin_privileges  # assigning new variable(admin_privileges)in equals to with existing one    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Privileges: \n",
      "can give access\n",
      "can block access\n",
      "can reset password\n"
     ]
    }
   ],
   "source": [
    "admin.privileges.show_privileges()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: yash marmat\n",
      "Location: delhi\n",
      "Interest: python\n"
     ]
    }
   ],
   "source": [
    "admin.describe() # just for fun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: yash marmat\n",
      "Location: delhi\n",
      "Interest: python\n",
      "\n",
      "\n",
      "Privileges: \n",
      "can give access\n",
      "can block access\n",
      "can reset password\n"
     ]
    }
   ],
   "source": [
    "# optional\n",
    "admin.describe()\n",
    "print('\\n')\n",
    "admin.privileges.show_privileges()"
   ]
  }
 ],
 "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.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}