Day_6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 5\n",
    "\n",
    "## Practicing python from Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encapsulation in Python\n",
    "\n",
    "1.  Create a class `BankAccount` with private attributes `account_number` and `balance`. Implement getter and setter methods to access and modify these attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Account Number ::  54891243\n",
      "Balance        ::  23000\n"
     ]
    }
   ],
   "source": [
    "# Creating class BanckAccount\n",
    "class BankAccount:\n",
    "\n",
    "    # Declaring private variables\n",
    "    __account_number = None\n",
    "    __balance = None\n",
    "\n",
    "    # declaring setter method for account number\n",
    "    def set_account_number(self,account_number):\n",
    "        self.__account_number = account_number\n",
    "    \n",
    "    # declaring getter method for account number\n",
    "    def get_account_number(self):\n",
    "        return self.__account_number\n",
    "\n",
    "    # declaring setter method for balance\n",
    "    def set_balance(self,balance):\n",
    "        self.__balance = balance\n",
    "    \n",
    "    # declaring getter method for balance\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n",
    "    \n",
    "# creating object \n",
    "ba = BankAccount()\n",
    "\n",
    "# setting values using setter methods.\n",
    "ba.set_account_number(54891243)\n",
    "ba.set_balance(23000)\n",
    "\n",
    "# getting values using getter methods.\n",
    "account_number = ba.get_account_number()\n",
    "balance = ba.get_balance()\n",
    "\n",
    "# printing values\n",
    "print(\"Account Number :: \",account_number)\n",
    "print(\"Balance        :: \",balance)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  Define a class `Student` with private attributes `name` and `age`. Implement a method `display_info()` to display the student's information without directly accessing the private attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name of Student :: Nitin K \n",
      "Age :: 23\n"
     ]
    }
   ],
   "source": [
    "# creating class Student\n",
    "class Student:\n",
    "\n",
    "    # Declaring private variables/attributes\n",
    "    __name = \"Nitin K\"\n",
    "    __age = 23\n",
    "\n",
    "    # Defining method to display info without directly accessing private variables.\n",
    "    def display_info(self):\n",
    "        name = self.get_name()\n",
    "        age = self.get_age()\n",
    "        print(f\"Name of Student :: {name} \\nAge :: {age}\")\n",
    "\n",
    "    # defining method to get name from private variable\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    # defining method to get age from private variable\n",
    "    def get_age(self):\n",
    "        return self.__age\n",
    "\n",
    "# creating object\n",
    "stu = Student()\n",
    "\n",
    "# calling display method to print student info\n",
    "stu.display_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "source": [
    "3.  Implement a class `Customer` with private attributes `name`, `email`, and `phone`. Provide methods to set and get these attributes securely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name  ::  Nitin K\n",
      "Email ::  nit123@gmail.com\n",
      "Phone ::  2354671289\n"
     ]
    }
   ],
   "source": [
    "# creating class customer\n",
    "class Customer:\n",
    "    \n",
    "    # declaring private variables\n",
    "    __name = None\n",
    "    __email = None\n",
    "    __phone = None\n",
    "\n",
    "    # setter method for name\n",
    "    def set_name(self,name):\n",
    "        self.__name = name\n",
    "    \n",
    "    # getter method for name\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "    \n",
    "    # setter method for email\n",
    "    def set_email(self,email):\n",
    "        self.__email = email\n",
    "\n",
    "    # getter method for email\n",
    "    def get_email(self):\n",
    "        return self.__email\n",
    "    \n",
    "    # setter method for phone\n",
    "    def set_phone(self, phone):\n",
    "        self.__phone = phone\n",
    "    \n",
    "    # getter method for phone\n",
    "    def get_phone(self):\n",
    "        return self.__phone\n",
    "\n",
    "# creating customer object\n",
    "cust = Customer()\n",
    "\n",
    "# setting values\n",
    "cust.set_name('Nitin K')\n",
    "cust.set_email('nit123@gmail.com')\n",
    "cust.set_phone('2354671289')\n",
    "\n",
    "# getting values\n",
    "name = cust.get_name()\n",
    "email = cust.get_email()\n",
    "phone = cust.get_phone()\n",
    "\n",
    "# printing values\n",
    "print(\"Name  :: \",name)\n",
    "print(\"Email :: \",email)\n",
    "print(\"Phone :: \",phone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Abstraction in Python\n",
    "\n",
    "4.  Create an abstract class `Shape` with a method `area()`. Implement subclasses `Circle`, `Rectangle`, and `Triangle`, each with its own `area()` method.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "area of circle for radious 4 is :: 50.24\n",
      "area of triangle for base 2 and height 4 is :: 4.0\n",
      "area of rectangle for length 5 and width 3 is :: 15\n"
     ]
    }
   ],
   "source": [
    "# importing abstract \n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# creating abstract class\n",
    "class Shape(ABC):\n",
    "\n",
    "    # Creating abstract method\n",
    "    @abstractmethod\n",
    "    def area(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "class Circle(Shape):\n",
    "    \n",
    "    def area(self,r):\n",
    "        pi = 3.14\n",
    "        area = pi*(r**2)\n",
    "        return f\"area of circle for radious {r} is :: {area}\"\n",
    "\n",
    "class Triangle(Shape):\n",
    "    \n",
    "    def area(self,b,h):\n",
    "        area = 1/2 * (b*h)\n",
    "        return f\"area of triangle for base {b} and height {h} is :: {area}\"\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    \n",
    "    def area(self,l,w):\n",
    "        area = l*w\n",
    "        return f\"area of rectangle for length {l} and width {w} is :: {area}\"\n",
    "    \n",
    "## creating objects\n",
    "# shape_obj = Shape()\n",
    "circ_obj = Circle()\n",
    "tri_obj = Triangle()\n",
    "rect_obj = Rectangle()\n",
    "\n",
    "# shape_obj.info()\n",
    "# shape_obj.area()\n",
    "\n",
    "# print()\n",
    "\n",
    "print(circ_obj.area(4))\n",
    "print(tri_obj.area(2,4))\n",
    "print(rect_obj.area(5,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  Define an abstract class `Animal` with a method `speak()`. Create subclasses `Dog`, `Cat`, and `Cow`, each implementing the `speak()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Dog says - woof!\n",
      "Cat says - meow!\n",
      "Cow says - moo!\n"
     ]
    }
   ],
   "source": [
    "# importing abstract \n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "# creating abstract animal class\n",
    "class Animal(ABC):\n",
    "\n",
    "    # creating abstract method\n",
    "    @abstractmethod\n",
    "    def speak(self):\n",
    "        pass\n",
    "\n",
    "# creating Dog class\n",
    "class Dog(Animal):\n",
    "    def speak(self):\n",
    "        return 'woof!'\n",
    "\n",
    "# creating Cat class\n",
    "class Cat(Animal):\n",
    "    def speak(self):\n",
    "        return 'meow!'\n",
    "\n",
    "# creating Cow class\n",
    "class Cow(Animal):\n",
    "    def speak(self):\n",
    "        return 'moo!'\n",
    "\n",
    "# creating objects\n",
    "# ani_obj = Animal()\n",
    "dog_obj = Dog()\n",
    "cat_obj = Cat()\n",
    "cow_obj = Cow()\n",
    "\n",
    "# printing info\n",
    "# print(ani_obj.speak())\n",
    "print(f\"\\nDog says - {dog_obj.speak()}\")\n",
    "print(f\"Cat says - {cat_obj.speak()}\")\n",
    "print(f\"Cow says - {cow_obj.speak()}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.  Implement a class `Database` with abstract methods `connect()`, `disconnect()`, `execute_query()`. Create subclasses `MySQL`, `PostgreSQL`, and `SQLite`, each implementing these methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MySQL : Connection Successfull!\n",
      "PostgreSQL : Connection Successfull!\n",
      "SQLite : Connection Successfull!\n",
      "\n",
      "MySQL : Disconnected Successfully!\n",
      "PostgreSQL : Disconnected Successfully!\n",
      "SQLite : Disconnected Successfully!\n",
      "\n",
      "MySQL : Query Executed Syccessfully!\n",
      "PostgreSQL : Query Executed Syccessfully!\n",
      "SQLite : Query Executed Syccessfully!\n"
     ]
    }
   ],
   "source": [
    "# importing abstract\n",
    "from abc import ABC, abstractmethod\n",
    "class Database(ABC):\n",
    "    \n",
    "    # creating abstract method\n",
    "    @abstractmethod\n",
    "    def connect(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def disconnect(self):\n",
    "        pass\n",
    "\n",
    "    @abstractmethod\n",
    "    def execute_query(self):\n",
    "        pass\n",
    "\n",
    "# Creating mysql class\n",
    "class MySQL(Database):\n",
    "\n",
    "    # Connection method\n",
    "    def connect(self):\n",
    "        return \"MySQL : Connection Successfull!\"\n",
    "\n",
    "    # Disconnection method\n",
    "    def disconnect(self):\n",
    "        return \"MySQL : Disconnected Successfully!\"\n",
    "\n",
    "    # Execution method\n",
    "    def execute_query(self):\n",
    "        return \"MySQL : Query Executed Syccessfully!\"\n",
    "\n",
    "# creating postgreSQL Class\n",
    "class PostgreSQL(Database):\n",
    "\n",
    "    def connect(self):\n",
    "        return \"PostgreSQL : Connection Successfull!\"\n",
    "\n",
    "    def disconnect(self):\n",
    "        return \"PostgreSQL : Disconnected Successfully!\"\n",
    "\n",
    "    def execute_query(self):\n",
    "        return \"PostgreSQL : Query Executed Syccessfully!\"\n",
    "\n",
    "# Creating SQLite class\n",
    "class SQLite(Database):\n",
    "\n",
    "    def connect(self):\n",
    "        return \"SQLite : Connection Successfull!\"\n",
    "\n",
    "    def disconnect(self):\n",
    "        return \"SQLite : Disconnected Successfully!\"\n",
    "\n",
    "    def execute_query(self):\n",
    "        return \"SQLite : Query Executed Syccessfully!\"\n",
    "\n",
    "\n",
    "\n",
    "## Creating objects\n",
    "# dat = Database()\n",
    "mysql = MySQL()\n",
    "post = PostgreSQL()\n",
    "lite = SQLite()\n",
    "\n",
    "## connections\n",
    "print(\"Connections Check >>\")\n",
    "print(mysql.connect())\n",
    "print(post.connect())\n",
    "print(lite.connect())\n",
    "\n",
    "## disconnect\n",
    "print()\n",
    "print(\"Disconnect >> \")\n",
    "print(mysql.disconnect())\n",
    "print(post.disconnect())\n",
    "print(lite.disconnect())\n",
    "\n",
    "## query execute\n",
    "print()\n",
    "print(\"Execute >>>>>\")\n",
    "print(mysql.execute_query())\n",
    "print(post.execute_query())\n",
    "print(lite.execute_query())"
   ]
  }
 ],
 "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.10.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}