08 Feb_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3d5029cc-8b1d-475c-bebc-eb309fd52e6b",
   "metadata": {},
   "source": [
    "Python Assignment on OOP's Part 2  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bbd0f66-0fa4-4e1c-8b7e-f6001ff36bc6",
   "metadata": {},
   "source": [
    "2. What is Abstraction in OOps? Explain with an example.\n",
    "\n",
    "---> abstraction refers to thea process of simplifying complex systems by breaking them down into more manageable and understandable parts. It involves focusing on essential characteristics and hiding unnecessary details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bad8be05-cb5f-47da-82d5-2f8189f84396",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Vehicle(ABC):\n",
    "    def __init__(self, speed, fuel):\n",
    "        self.speed = speed\n",
    "        self.fuel = fuel\n",
    "    \n",
    "    @abstractmethod\n",
    "    def move(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def refuel(self):\n",
    "        pass\n",
    "\n",
    "class Car(Vehicle):\n",
    "    def move(self):\n",
    "        print(\"The car is moving.\")\n",
    "\n",
    "    def refuel(self):\n",
    "        print(\"The car is refueling.\")\n",
    "\n",
    "class Motorcycle(Vehicle):\n",
    "    def move(self):\n",
    "        print(\"The motorcycle is moving.\")\n",
    "\n",
    "    def refuel(self):\n",
    "        print(\"The motorcycle is refueling.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "527268c4-7741-4180-a920-086702daa962",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The car is moving.\n",
      "The car is refueling.\n",
      "The motorcycle is moving.\n",
      "The motorcycle is refueling.\n"
     ]
    }
   ],
   "source": [
    "car = Car(speed=60, fuel=50)\n",
    "car.move()    \n",
    "car.refuel() \n",
    "\n",
    "motorcycle = Motorcycle(speed=80, fuel=30)\n",
    "motorcycle.move()    \n",
    "motorcycle.refuel()  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8273b287-b579-4c73-81b3-e9d7b3fa4d48",
   "metadata": {},
   "source": [
    "Q2. Differentiate between Abstraction and Encapsulation. Explain with an example. \n",
    "\n",
    "---> Abstraction:\n",
    "Abstraction focuses on creating simplified representations of complex systems by hiding unnecessary details and exposing only essential features.\n",
    "\n",
    "Encapsulation:\n",
    "Encapsulation is the practice of bundling related data and behaviors into a single unit, typically called a class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "97b4260e-6702-4c8d-808d-e1a933ed7f0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, account_number, balance):\n",
    "        self.__account_number = account_number  # Encapsulated attribute\n",
    "        self.__balance = balance  # Encapsulated attribute\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        self.__balance += amount\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if self.__balance >= amount:\n",
    "            self.__balance -= amount\n",
    "        else:\n",
    "            print(\"Insufficient funds.\")\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "da638599-950a-4a0e-92a2-954303b83900",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n",
      "1500\n",
      "1300\n"
     ]
    }
   ],
   "source": [
    "# Create an instance of the BankAccount class\n",
    "account = BankAccount(\"123456789\", 1000)\n",
    "\n",
    "\n",
    "print(account.get_balance())  \n",
    "\n",
    "account.deposit(500)\n",
    "print(account.get_balance())  \n",
    "\n",
    "account.withdraw(200)\n",
    "print(account.get_balance())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c271273-dd12-4d34-a3a5-dbc6b2af0c6d",
   "metadata": {},
   "source": [
    "\n",
    "Q3. What is abc module in python? Why is it used?\n",
    "\n",
    "---> The abc module in Python stands for \"Abstract Base Classes.\" It provides mechanisms for defining abstract base classes (ABCs) in Python. An abstract base class is a class that cannot be instantiated directly but serves as a blueprint for defining subclasses.\n",
    "The abc module in Python is used for several reasons: \n",
    "Defining common interfaces: Abstract base classes (ABCs) allow you to define a common set of methods that related classes should implement.\n",
    "Enforcing method implementation: Abstract base classes can enforce that certain methods must be implemented by subclasses.\n",
    "Enabling polymorphism: Abstract base classes enable polymorphism, which means that objects of different classes can be treated interchangeably based on their shared interface defined in the abstract base class.\n",
    "Providing documentation and guidance: Abstract base classes serve as documentation and guidance for developers who need to create subclasses. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe1ec345-c140-4199-bb73-c51b57747bc2",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Q4. How can we achieve data abstraction?\n",
    "\n",
    "---> ata abstraction can be achieved through the use of classes, objects, and access modifiers. Here are the key steps to achieve data abstraction:\n",
    "\n",
    "Define a Class: Create a class that represents the abstraction you want to achieve. This class should encapsulate the relevant data and behaviors.\n",
    "\n",
    "Encapsulate Data: Encapsulate the data within the class by declaring them as private or protected using access modifiers. Private data can only be accessed and modified within the class itself, while protected data can also be accessed by subclasses.\n",
    "\n",
    "Provide Public Methods: Define public methods, also known as accessor and mutator methods or getters and setters, to provide controlled access to the encapsulated data. These methods allow external code to interact with the class's data without directly accessing or modifying it.\n",
    "\n",
    "Hide Implementation Details: Make sure to hide the implementation details of the class and expose only the essential functionality. The external code interacting with the class should only need to know about the public methods and not the internal workings of the class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44246a25-5617-4b8f-9e84-780ce028f985",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Q5. Can we create an instance of an abstract class? Explain your answer. \n",
    "\n",
    "---> No, we cannot create an instance of an abstract class in Python. Abstract classes are designed to be incomplete and act as blueprints for other classes to inherit from. They serve as a template for creating subclasses that provide concrete implementations for the abstract methods defined in the abstract base class. "
   ]
  }
 ],
 "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
}