Assignment 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5f715563",
   "metadata": {},
   "source": [
    "# Q1. What is the relationship between classes and modules?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "296137e2",
   "metadata": {},
   "source": [
    "Classes are blueprints that allow you to create instances with attributes and bound functionality. Classes support inheritance, metaclasses, and descriptors.\n",
    "\n",
    "Whereas, Modules in python is simply a way to organize the code, and it contains either python classes or just functions. If you need those classes or functions in your project, you just import them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4a6fa12",
   "metadata": {},
   "source": [
    "# Q2. How do you make instances and classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c44733",
   "metadata": {},
   "source": [
    "To create instances of a class, you call the class using class name and pass in whatever arguments its __init__ method accepts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7b620465",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"This would create first object of Employee class\"\n",
    "emp1 = Employee(\"Zara\", 2000)\n",
    "\"This would create second object of Employee class\"\n",
    "emp2 = Employee(\"Manni\", 5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4188b5fd",
   "metadata": {},
   "source": [
    "For creating a class, we use the Class keyword. Class keyword is followed by classname and semicolon."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "28cdc598",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example: \n",
    "#Here Employee is a class created with class keyword with arguments gender and salary.\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self, gender,salary):\n",
    "        self.gender = gender\n",
    "        self.salary = salary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3310b8fe",
   "metadata": {},
   "source": [
    "# Q3. Where and how should be class attributes created?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7539f85f",
   "metadata": {},
   "source": [
    "Class attributes or Class level Attributes belong to the class itself. these attributes will be shared by all the instances of the class. Hence these attributes are usually created/defined in the top of class definiation outside all methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d8fbca6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example: \n",
    "#In the below code we are defining a class attribute called no_of_wheels which will be shared by all the instances of the class Car\n",
    "\n",
    "class Car:\n",
    "    no_of_wheels = 4; # this is a class attribute\n",
    "    def __init__(self,color,price,engine):\n",
    "        self.color = color # All this are instance attributes\n",
    "        self.price = price\n",
    "        self.engine = engine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c53785a9",
   "metadata": {},
   "source": [
    "# Q4. Where and how are instance attributes created?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71d4081b",
   "metadata": {},
   "source": [
    "Instances attributes are passed to the class when an object of the class is created. Unlike class attributes, instance attributes are not shared by all objects of the classs. Instead each object maintains its own copy of instance attributes at object level whereas incase of class attributes, all instances of class refer to a single copy. Usually instance attributes are defined within the __init__ method of class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "123795de",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Example: \n",
    "#In the below sample code we are creating a class Car with instance varaibles color, price, engine, which will be provided when an instance of class Car is created.\n",
    "\n",
    "class Car:\n",
    "    def __init__(self,color,price,engine):\n",
    "        self.color = color # All this are instance attributes\n",
    "        self.price = price\n",
    "        self.engine = engine\n",
    "\n",
    "nexon_ev = Car('Indigo Blue', 1400000, 'electric')\n",
    "safari = Car('Pearl White',2100000, 'petrol')\n",
    "\n",
    "#nexon_ev, safari are both the instances of class Car with different instance variables."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a870ce9b",
   "metadata": {},
   "source": [
    "# Q5. What does the term \"self\" in a Python class mean?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91825695",
   "metadata": {},
   "source": [
    "self represents the instance of the class (it represents the object itself). By using the “self” keyword we can access the attributes and methods of the class with in the class in python. It binds the attributes with the given arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "121e0f4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'color': 'Indigo Blue', 'price': 1400000, 'engine': 'electric'}\n",
      "{'color': 'Pearl White', 'price': 2100000, 'engine': 'petrol'}\n"
     ]
    }
   ],
   "source": [
    "class Car:\n",
    "    def __init__(self,color,price,engine):\n",
    "        self.color = color # All this are instance attributes\n",
    "        self.price = price\n",
    "        self.engine = engine\n",
    "\n",
    "nexon_ev = Car('Indigo Blue', 1400000, 'electric')\n",
    "safari = Car('Pearl White',2100000, 'petrol')\n",
    "\n",
    "print(nexon_ev.__dict__)\n",
    "print(safari.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "132bdf22",
   "metadata": {},
   "source": [
    "# Q6. How does a Python class handle operator overloading?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbcf25cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "Python Classes handle operator overloading by using special methods called Magic methods. These special methods usually begin and end with __ (double underscore)\n",
    "Example: Magic methods for basic arithmetic operators are:\n",
    "\n",
    "+ -> __add__()\n",
    "\n",
    "- -> __sub__()\n",
    "\n",
    "* -> __mul__() \n",
    "\n",
    "/ -> __div__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "025cf108",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of pages in 2 books is 1200\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self,pages):\n",
    "        self.pages = pages\n",
    "    def __add__(self,other):\n",
    "        return self.pages + other.pages\n",
    "b1 = Book(500)\n",
    "b2 = Book(700)\n",
    "print(f'The total number of pages in 2 books is {b1+b2}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5e3abb6",
   "metadata": {},
   "source": [
    "# Q7. When do you consider allowing operator overloading of your classes?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d71dda89",
   "metadata": {},
   "source": [
    "We consider allowing operator overloading when we want to have different meaning for the same operator. For example operator + is used to add two integers as well as join two strings and merge two lists. It is achievable because ‘+’ operator is overloaded by int class and str class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1bf3ea5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "NancySoni\n",
      "12\n",
      "IneuronIneuronIneuronIneuron\n"
     ]
    }
   ],
   "source": [
    "# Python program to show use of\n",
    "# + operator for different purposes.\n",
    " \n",
    "print(1 + 2)\n",
    " \n",
    "# concatenate two strings\n",
    "print(\"Nancy\"+\"Soni\")\n",
    " \n",
    "# Product two numbers\n",
    "print(3 * 4)\n",
    " \n",
    "# Repeat the String\n",
    "print(\"Ineuron\"*4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1417b6b5",
   "metadata": {},
   "source": [
    "# Q8. What is the most popular form of operator overloading?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a2d34ec",
   "metadata": {},
   "source": [
    "The most popular form of operator overloading in python is by special methods called Magic methods. It usually begins and ends with double underscore  __<method name>__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2d4f600d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum -> 3\n",
      "String Concatenation -> Nancy Soni\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self,a):\n",
    "        self.a = a\n",
    "    def __add__(self,o):\n",
    "        return self.a+o.a\n",
    "obj1 = A(1)\n",
    "obj2 = A(2)\n",
    "obj3 = A('Nancy')\n",
    "obj4 = A(' Soni')\n",
    "print(f'Sum -> {obj1+obj2}')\n",
    "print(f'String Concatenation -> {obj3+obj4}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a02f310",
   "metadata": {},
   "source": [
    "# Q9. What are the two most important concepts to grasp in order to comprehend Python OOP code?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b212a1d",
   "metadata": {},
   "source": [
    "Classes and objects are the two most important concepts to grasp in order to comprehend python OOP code as more formally objects are entities that represent instances of general abstract concept called class.\n",
    "\n",
    "Along with classes and objects the important concepts to grasp are:\n",
    "\n",
    "1.Inheritence\n",
    "\n",
    "2.Abstraction\n",
    "\n",
    "3.Polymorphism\n",
    "\n",
    "4.Encapsulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95c211bf",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}