Assignment 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "99e5b33e",
   "metadata": {},
   "source": [
    "# 1. What is the concept of an abstract superclass?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94659571",
   "metadata": {},
   "source": [
    "An abstract class/superclass can be considered as a blueprint for other classes. It allows US to create a set of methods that must be created within any child classes built from the abstract class. A class which contains one or more abstract methods is called an abstract class Whereas an abstract method is a method that has a declaration but does not have an implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6d694d1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "class Polygon(ABC): # Abstract Class\n",
    "    @abstractmethod\n",
    "    def noofsides(self): # Abstract Method\n",
    "        pass\n",
    "class Triangle(Polygon):\n",
    "    def noofsides(self):  # overriding abstract method in child class Triangle\n",
    "        print(\"I have 3 sides\")\n",
    "class Pentagon(Polygon):\n",
    "    def noofsides(self): # overriding abstract method in child class Pentagon\n",
    "        print(\"I have 5 sides\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e566203b",
   "metadata": {},
   "source": [
    "# 2. What happens when a class statement's top level contains a basic assignment statement?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f033f7f2",
   "metadata": {},
   "source": [
    "When a Class statement's top level contains a basic assignment statement, it is usually treated as a class attribute or class level variable where as assignment statements inside methods are treated as instance attributes or local attributes.\n",
    "\n",
    "When an instance of a class is created, a single copy of class attributes is maintained and shared to all instances of class where as each instance object maintains its own copy of instance variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a443757e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Human:\n",
    "    species = 'Homesapiens' # class attribute\n",
    "    def __init__(self,name,gender):\n",
    "        self.name = name # instance attributes\n",
    "        self.gender = gender"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d907eb4e",
   "metadata": {},
   "source": [
    "# 3. Why does a class need to manually call a superclass's init method?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e69133fd",
   "metadata": {},
   "source": [
    "If a child class has __init__ method, then it will not inherit the __init__ method of the parent class. In other words the __init__ method of the child class overrides the __init__ method of the parent class. So, we have to manually call a parent superclass's __init__ using super() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2eda6a47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Nancy', 'age': 26, 'salary': 20000}\n"
     ]
    }
   ],
   "source": [
    "class Human:\n",
    "    def __init__(self,name,age):\n",
    "        self.name = name\n",
    "        self.age = age       \n",
    "class Employee(Human):\n",
    "    def __init__(self,name,age,salary):\n",
    "        super().__init__(name,age)\n",
    "        self.salary = salary\n",
    "emp_1 = Employee('Nancy',26,20000)\n",
    "print(emp_1.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce30caa",
   "metadata": {},
   "source": [
    "# 4. How can you augment, instead of completely replacing, an inherited method?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bf33595",
   "metadata": {},
   "source": [
    "super() method can be used to augment, instead of completely replacing, an inherited method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fd7a1d37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Nancy', 'gender': 'Female', 'salary': 10000}\n"
     ]
    }
   ],
   "source": [
    "class Human:\n",
    "    def __init__(self,name,gender):\n",
    "        self.name = name\n",
    "        self.gender = gender\n",
    "class Employee(Human):\n",
    "    def __init__(self,name,gender,salary):\n",
    "        super().__init__(name,gender) \n",
    "        self.salary = salary\n",
    "emp_1 = Employee('Nancy','Female',10000)\n",
    "print(emp_1.__dict__) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bfa0eac",
   "metadata": {},
   "source": [
    "# 5. How is the local scope of a class different from that of a function?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0376252a",
   "metadata": {},
   "source": [
    "A Variable which is defined inside a function is local to that function. It is accesible from the point at which it is defined until the end of the function, and exists for as long as the function is existing.\n",
    "\n",
    "Similary a variable inside of a class also has a local variable scope. Variables which are defined in the class body (but outside all methods) are called as class level variables or class attributes. They can be referenced by their bare names within the same scope, but they can also be accessed from outside this scope if we use the attribute access operator (.) on a class or an instance of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2166d61d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you're name is Nancy Soni\n",
      "Name varible is not available outside hello function scope\n",
      "HomeSapiens\n",
      "HomeSapiens\n"
     ]
    }
   ],
   "source": [
    "def hello(name):\n",
    "    name = name\n",
    "    print(f'you\\'re name is {name}')\n",
    "hello('Nancy Soni')\n",
    "try:\n",
    "    name\n",
    "except NameError:\n",
    "    print('Name varible is not available outside hello function scope')\n",
    "\n",
    "class Person:\n",
    "    species = \"HomeSapiens\"\n",
    "    def __init__(self):\n",
    "        pass\n",
    "print(Person.species) # Accessing species using class name\n",
    "Male = Person()\n",
    "print(Male.species) # Accessing species using instance of class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e0ccad7",
   "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
}