Assignment 19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7e5c2dce",
   "metadata": {},
   "source": [
    "# Assignment 19"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7a1eb4d",
   "metadata": {},
   "source": [
    "## 1. Define the relationship between a class and its instances. Is it a one-to-one or a one-to-many partnership, for example?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b8a748d",
   "metadata": {},
   "source": [
    "__Ans:__ Relationship between a `class` and its `instances` is a one to many partnership. Object is a physical entity or real word entity. An object occupies space in memory. Example:-banana,chair,pen etc are objects. Class is a logical entity which does not exist in real world. Or we can say that class is a blueprint to create objects of similiar types. A class does not take space in memory. Examples:-fruits,furniture,vehicles etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a21ece93",
   "metadata": {},
   "source": [
    "## 2. What kind of data is held only in an instance?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a789a0d",
   "metadata": {},
   "source": [
    "__Ans:__ Instance objects contains the Instance variables which are specific to that specific Instance object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d12a17dd",
   "metadata": {},
   "source": [
    "## 3. What kind of knowledge is stored in a class?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "772f3336",
   "metadata": {},
   "source": [
    "__Ans:__ Class creates a user-defined data structure, which holds its own data members and member functions, which can be accessed and used by creating an instance of that class. A class is like a blueprint for an object. Class is a logical entity which does not exist in real world Or we can say that class is a blueprint to create objects of similiar types. A class does not take space in memory. Examples:-fruits,furniture,vehicles etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c050a7dc",
   "metadata": {},
   "source": [
    "## 4. What exactly is a method, and how is it different from a regular function?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2afe80a7",
   "metadata": {},
   "source": [
    "__Ans:__ The methods with a class can be used to access the insatnce variables of its instance. So,the object's state can be modified by its method. Function can't access the attributes of an instance of a class or can't modify the state of the object."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3223a151",
   "metadata": {},
   "source": [
    "## 5. Is inheritance supported in Python, and if so, what is the syntax?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b178fe9",
   "metadata": {},
   "source": [
    "__Ans:__ Yes,Python supports inheritance. The Types of Inheritence Supported by Python are:\n",
    "\n",
    "- 1. Simple Inheritence\n",
    "\n",
    "- 2. Multiple Inheritence\n",
    "\n",
    "- 3. Multilevel lInheritence\n",
    "\n",
    "- 4. Hybrid Inheritence\n",
    "\n",
    "- 5. Hierracial Inheritence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0eabcafe",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, fname, lname):\n",
    "        self.first_name = fname\n",
    "        self.last_name = lname\n",
    "class Student(Person):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68db4578",
   "metadata": {},
   "source": [
    "## 6. How much encapsulation (making instance or class variables private) does Python support?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5a01c64",
   "metadata": {},
   "source": [
    "__Ans:__ `Encapsulation` describes the idea of wrapping data and the methods that work on data within one unit. This puts restrictions on accessing variables and methods directly and can prevent the accidental modification of data. To prevent accidental change, an objects variable can only be changed by an objects method."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf0c071d",
   "metadata": {},
   "source": [
    "## 7. How do you distinguish between a class variable and an instance variable?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ff1e026",
   "metadata": {},
   "source": [
    "__Ans:__ The Class Attribute is available to all the instance objects of that class. whereas Instance Attributes are accessible only to the object or Instance of that class.\n",
    "\n",
    "A single copy of Class attributes is maintained by pvm at the class level. Whereas difference copies of instance attributes are maintained by pvm at objects/instance level."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba7faa1a",
   "metadata": {},
   "source": [
    "## 8. When, if ever, can self be included in a class's method definitions?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0090ce6",
   "metadata": {},
   "source": [
    "__Ans:__ Yes, self can included in class method definations to access the instance variables inside class methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a59397b2",
   "metadata": {},
   "source": [
    "## 9. What is the difference between the _ _add_ _ and the _ _radd_ _ methods?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52d73250",
   "metadata": {},
   "source": [
    "__Ans:__ Entering __radd__ Python will first try __add()__, and if that returns Not Implemented Python will check if the right-hand operand implements __radd__, and if it does, it will call __radd()__ rather than raising a TypeError.\n",
    "\n",
    "The expression a+b is internally translated to the method call a.add(b). But if a and b are of different types, it is possible that a's implementation of addition cannot deal with objects of b's type (or maybe a does not have a add method, at all). So, if a.add(b) fails, Python tries b.radd(a) instead, to see if b's implementation can deal with objects of a's type.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51e13a8b",
   "metadata": {},
   "source": [
    "## 10. When is it necessary to use a reflection method? When do you not need it, even though you support the operation in question?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3a14a78",
   "metadata": {},
   "source": [
    "__Ans:__ Reflection method we often encounter the requirement that a method in the executing object, or a variable in the calling object, or a field of the object should be assigned, while the method name or field name can not be determined when encoding the code, and need to be input in the form of passing strings through parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "16b46c08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is not callable\n",
      "y is callable\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "\n",
    "def testFunction():\n",
    "  print(\"Test\")\n",
    "   \n",
    "y = testFunction\n",
    "\n",
    "if (callable(x)):\n",
    "    print(\"x is callable\")\n",
    "else:\n",
    "    print(\"x is not callable\")\n",
    "\n",
    "if (callable(y)):\n",
    "    print(\"y is callable\")\n",
    "else:\n",
    "    print(\"y is not callable\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd94343",
   "metadata": {},
   "source": [
    "## 11. What is the _ _iadd_ _ method called?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91533846",
   "metadata": {},
   "source": [
    "__Ans:__ iadd method is called when we use implementation like a+=b which is a.iadd(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a3884c9",
   "metadata": {},
   "source": [
    "## 12. Is the _ _init_ _ method inherited by subclasses? What do you do if you need to customize its behavior within a subclass?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea2b6068",
   "metadata": {},
   "source": [
    "__Ans:__ Yes, init method will be inherited by subclasses. if we want to customize its behaviour within a subclass we can use super() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d39fcf05",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}