assignment07 copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2ad876d9-dbe3-4029-9fcd-69fc906975b5",
   "metadata": {},
   "source": [
    "Q1. What is Abstraction in OOps? Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f543192-95fe-4db9-b039-9f0cd01ca4c2",
   "metadata": {},
   "source": [
    "Ans: Abstraction involves representing complex real-world entities or concepts in a simplified manner within the program. It focuses on extracting the essential characteristics and behaviors of an object, while hiding unnecessary details. Abstraction provides a high-level view, allowing programmers to create abstract classes or interfaces that define common attributes and methods without specifying their implementation. It helps in managing program complexity, promoting code reusability, and facilitating modular design.\n",
    "Eg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1b52df03-4419-4f28-870d-4a7ddc1a4a82",
   "metadata": {},
   "outputs": [],
   "source": [
    "import abc\n",
    "class sk:\n",
    "    @abc.abstractclassmethod\n",
    "    def st(self):\n",
    "        pass\n",
    "    @abc.abstractclassmethod\n",
    "    def st_a(self):\n",
    "        pass\n",
    "    @abc.abstractclassmethod\n",
    "    def st_m(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0de4a05d-e42d-4bf5-8232-36cdd0bc0e0a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'student details'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class st_dl(sk):\n",
    "    def st(self):\n",
    "        return \"student details\"\n",
    "    def st_a(self):\n",
    "        return \"assign for a student\"\n",
    "sd=st_dl()\n",
    "sd.st()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dabe0dd-1462-4b94-853e-ce82a0ce9e58",
   "metadata": {},
   "source": [
    "Q2. Differentiate between Abstraction and Encapsulation. Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aade333-9f6b-4244-839b-cfcfbc5c2dec",
   "metadata": {},
   "source": [
    "Ans:\n",
    "Abstraction:\n",
    "Abstraction refers to the process of representing complex real-world entities or concepts in a simplified manner within the program. It focuses on extracting the essential characteristics and behaviors of an object while hiding unnecessary details. Abstraction allows programmers to create abstract classes or interfaces that define common attributes and methods without specifying their implementation.\n",
    "\n",
    "Abstraction helps in managing program complexity, promoting code reusability, and facilitating modular design. It allows us to work at a higher level of abstraction, dealing with general concepts rather than specific implementation details.\n",
    "\n",
    "Eg:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3b93c771-4b30-40ab-a80f-c9e5899dd208",
   "metadata": {},
   "outputs": [],
   "source": [
    "import abc\n",
    "class geometry:\n",
    "    @abc.abstractclassmethod\n",
    "    def area(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "093a70f9-a0aa-428c-a7a9-ee6553c7e15c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle(geometry):\n",
    "    def __init__(self,r):\n",
    "        self.r=r\n",
    "    def area(self):\n",
    "        return 3.14*(self.r**2)\n",
    "class Rectangle(geometry):\n",
    "    def __init__(self,l,w):\n",
    "        self.l=l\n",
    "        self.w=w\n",
    "    def area(self):\n",
    "        return self.l*self.w\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78716ea8-dfca-45a4-868f-81c7c5dea111",
   "metadata": {},
   "source": [
    "Encapsulation:\n",
    "Encapsulation is the mechanism of bundling data (attributes) and methods (behaviors) together within a class. It allows the data to be accessed and manipulated only through the defined methods, thereby providing control over the data's visibility and modification. Encapsulation helps in achieving data hiding, abstraction, and modular programming.\n",
    "\n",
    "Encapsulation ensures that the internal state of an object is protected from external access, and the object's behavior is controlled by well-defined methods. It promotes the principle of information hiding, where the implementation details are hidden from other parts of the program, and only the necessary interface is exposed.\n",
    "Eg:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2164bd34-2b4a-4cd0-ac1a-aa2daaa0662f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car:\n",
    "    def __init__(self,yr,mk,model,speed):\n",
    "        self.__yr=yr\n",
    "        self.__mk=mk\n",
    "        self.__model=model \n",
    "        self.__speed=speed\n",
    "    def set_s(self,speed):\n",
    "        self.__speed=0 if speed<0 else speed\n",
    "    def get_s(self):\n",
    "        return self.__speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a92aa9b4-4889-4340-9829-83307cab7b43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2021"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c=car(2021,\"Tesla\",\"78hy\",45)\n",
    "c._car__yr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "da4b4e07-be29-4b8d-a665-016efeb01605",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.set_s(90)\n",
    "c.get_s()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45b21f1-23ad-4590-8092-9bf6d7c18338",
   "metadata": {},
   "source": [
    "Q3. What is abc module in python? Why is it used?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57e8b07c-ac5e-4622-9958-bccbfc2668c2",
   "metadata": {},
   "source": [
    "Ans: the abc module in Python is used to define abstract base classes that define common interfaces and enforce method implementations in derived classes. It promotes the concept of abstraction, providing a way to define common behaviors without specifying the implementation details. The module helps in achieving modularity, code clarity, and ensuring adherence to a contract among related classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a4821f-3211-4d26-b849-3421245dd93d",
   "metadata": {},
   "source": [
    "Q4. How can we achieve data abstraction?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8411387-aecf-4a3f-a982-43d2dd583cda",
   "metadata": {},
   "source": [
    "Ans: \n",
    "1) Identify the Relevant Data: Determine the essential data elements that are required for representing an object or concept. These data elements will form the attributes of the class.\n",
    "\n",
    "2) Create a Class: Define a class that encapsulates the relevant data attributes and associated methods. The class acts as a blueprint for creating objects.\n",
    "\n",
    "3) Define Access Methods: Within the class, define methods that provide controlled access to the data attributes. These methods can be used to read or modify the data, enforcing any necessary validation or business logic.\n",
    "\n",
    "4) Hide Internal Implementation: Hide the internal implementation details of the class and its attributes from external access. This is achieved by marking the attributes as private or using naming conventions to indicate that they are intended for internal use only.\n",
    "\n",
    "5) Use Public Interface: Expose a public interface for interacting with the object. This interface consists of the methods that provide access to the attributes and perform relevant operations on the data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b70d1b37-5b9c-492a-8857-b7f7194f6fdf",
   "metadata": {},
   "source": [
    "Q5. Can we create an instance of an abstract class? Explain your answer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f7d500e-4211-451b-b76c-177c436b3ab0",
   "metadata": {},
   "source": [
    "Ans: No, we cannot create an instance of an abstract class in Python. Abstract classes are meant to serve as blueprints or templates for other classes to inherit from. They define common interfaces and provide a set of methods that must be implemented by their subclasses.\n",
    "\n",
    "The purpose of an abstract class is to be inherited and extended by subclasses that provide concrete implementations for the abstract methods defined in the abstract class. Abstract classes are incomplete on their own and lack specific implementation details required to create instances.\n",
    "\n",
    "Python provides the abc module (Abstract Base Classes) to define abstract base classes using the ABC class and the @abstractmethod decorator. When a class inherits from an abstract base class and does not implement all the abstract methods, it becomes an abstract class itself. An abstract class cannot be instantiated."
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}