7th_october_oops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d8de283d",
   "metadata": {},
   "source": [
    "# OOPs Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3877543c",
   "metadata": {},
   "source": [
    "## Problem 1: Bank Account Create a class representing a bank account with attributes like account number, account holder name, and balance. Implement methods to deposit and withdraw money from the account."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ed052ef8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class bank_account:\n",
    "    def __init__(self,account_no,name,balance):\n",
    "        self.account_no = account_no\n",
    "        self.name = name\n",
    "        self.balance = balance\n",
    "        \n",
    "    def deposit(self,amt):\n",
    "        if amt>0:\n",
    "            self.balance+=amt\n",
    "            print(f\"Deposited amount:₹{amt} and total balance:₹{self.balance}\")\n",
    "        else:\n",
    "            print(\"Invalid amount, please enter valid amount.\")\n",
    "    \n",
    "    def withdraw(self,amt):\n",
    "        if amt<=self.balance:\n",
    "            self.balance-=amt\n",
    "            print(f\"₹{amt} withdrawn, remaining balance ₹{self.balance}\")\n",
    "        else:\n",
    "            print(\"Insufficient balance\")\n",
    "        \n",
    "    def show_balance(self):\n",
    "        print(f\"Current balance is ₹{self.balance}\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "44b3c004",
   "metadata": {},
   "outputs": [],
   "source": [
    "account_1 = bank_account(account_no = 1234, name = \"Ram\", balance = 5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7374bee9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current balance is ₹5000\n"
     ]
    }
   ],
   "source": [
    "account_1.show_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "59f2e149",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deposited amount:₹500 and total balance:₹5500\n"
     ]
    }
   ],
   "source": [
    "account_1.deposit(500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "05567627",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "₹1000 withdrawn, remaining balance ₹4500\n"
     ]
    }
   ],
   "source": [
    "account_1.withdraw(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "45074dc3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current balance is ₹4500\n"
     ]
    }
   ],
   "source": [
    "account_1.show_balance()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13e3b0c7",
   "metadata": {},
   "source": [
    "## Problem 2: Employee Management Create a class representing an employee with attributes like employee ID, name, and salary. Implement methods to calculate the yearly bonus and display employee details.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c7a7f043",
   "metadata": {},
   "outputs": [],
   "source": [
    "class employee:\n",
    "    def __init__(self,employee_id,name,salary):\n",
    "        self.employee_id = employee_id\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "    \n",
    "    def display_details(self):\n",
    "        print(\"Employee ID:\",self.employee_id)\n",
    "        print(\"Name of Employee:\",self.name)\n",
    "        print(\"Salary:\",self.salary)\n",
    "        \n",
    "    def yearly_bonus(self,bonus_percentage):\n",
    "        bonus_amount = (bonus_percentage / 100) * self.salary\n",
    "        print(\"Bonus amount is:\",bonus_amount)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "abb16d84",
   "metadata": {},
   "outputs": [],
   "source": [
    "employee1 = employee(employee_id = 1234, name = \"Ramen\", salary = 50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8c78ff71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee ID: 1234\n",
      "Name of Employee: Ramen\n",
      "Salary: 50000\n"
     ]
    }
   ],
   "source": [
    "employee1.display_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bf740171",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bonus amount is: 12500.0\n"
     ]
    }
   ],
   "source": [
    "employee1.yearly_bonus(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f869694a",
   "metadata": {},
   "source": [
    "## Problem 3: Vehicle Rental Create a class representing a vehicle rental system. Implement methods to rent a vehicle, return a vehicle, and display available vehicles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "33983181",
   "metadata": {},
   "outputs": [],
   "source": [
    "class vehicle_rental_system:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.available_vehicles = {}\n",
    "        \n",
    "    def add_vehicle(self, vehicle_id, model):\n",
    "        if vehicle_id not in self.available_vehicles:\n",
    "            self.available_vehicles[vehicle_id] = {\"model\":model, \"is_available\": True}\n",
    "            print(f\"Vehicle {vehicle_id} added successfully!\")\n",
    "        else:\n",
    "            print(f\"Vehicle {vehicle_id} already exists!\")\n",
    "            \n",
    "    def rent_vehicle(self,vehicle_id):\n",
    "        if vehicle_id in self.available_vehicles and self.available_vehicles[vehicle_id][\"is_available\"]:\n",
    "            self.available_vehicles[vehicle_id][\"is_available\"] = False\n",
    "            print(f\"Vehicle {vehicle_id} rented successfully !\")\n",
    "        else:\n",
    "            print(f\"Sorry!, Vehicle {vehicle_id} not available for rent\")\n",
    "        \n",
    "    def return_vehicle(self,vehicle_id):\n",
    "        if vehicle_id in self.available_vehicles and not self.available_vehicles[vehicle_id][\"is_available\"]:\n",
    "            self.available_vehicles[vehicle_id][\"is_available\"] = True\n",
    "            print(f\"Vehicle {vehicle_id} returned successfully !\")\n",
    "        else:\n",
    "            print(\"Invalid return!\")\n",
    "    \n",
    "    def display_available_vehicles(self):\n",
    "        available_vehicles = [vehicle_id for vehicle_id, info in self.available_vehicles.items() if info[\"is_available\"]]\n",
    "        if available_vehicles:\n",
    "            print(\"Available Vehicles:\")\n",
    "            for vehicle_id in available_vehicles:\n",
    "                print(f\"ID: {vehicle_id}, Model: {self.available_vehicles[vehicle_id]['model']}\")\n",
    "        else:\n",
    "            print(\"No vehicles are currently available.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5b0a2f6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No vehicles are currently available.\n"
     ]
    }
   ],
   "source": [
    "rental_system = vehicle_rental_system()\n",
    "rental_system.display_available_vehicles()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "65d5b06b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle V001 added successfully!\n",
      "Vehicle V002 added successfully!\n",
      "Vehicle V003 added successfully!\n",
      "Vehicle V004 added successfully!\n"
     ]
    }
   ],
   "source": [
    "rental_system.add_vehicle(\"V001\", \"Van\")\n",
    "rental_system.add_vehicle(\"V002\", \"SUV\")\n",
    "rental_system.add_vehicle(\"V003\", \"Truck\")\n",
    "rental_system.add_vehicle(\"V004\", \"Sedan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0a4e1263",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Vehicles:\n",
      "ID: V001, Model: Van\n",
      "ID: V002, Model: SUV\n",
      "ID: V003, Model: Truck\n",
      "ID: V004, Model: Sedan\n"
     ]
    }
   ],
   "source": [
    "rental_system.display_available_vehicles()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "349a6b0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle V002 rented successfully !\n"
     ]
    }
   ],
   "source": [
    "rental_system.rent_vehicle(\"V002\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "78d98725",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle V003 rented successfully !\n"
     ]
    }
   ],
   "source": [
    "rental_system.rent_vehicle(\"V003\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a4e752e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Vehicles:\n",
      "ID: V001, Model: Van\n",
      "ID: V004, Model: Sedan\n"
     ]
    }
   ],
   "source": [
    "rental_system.display_available_vehicles()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1321c4c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle V002 returned successfully !\n"
     ]
    }
   ],
   "source": [
    "rental_system.return_vehicle(\"V002\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "bb9e6460",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle V003 returned successfully !\n"
     ]
    }
   ],
   "source": [
    "rental_system.return_vehicle(\"V003\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b96bfeeb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid return!\n"
     ]
    }
   ],
   "source": [
    "rental_system.return_vehicle(\"V001\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2f76ca73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Vehicles:\n",
      "ID: V001, Model: Van\n",
      "ID: V002, Model: SUV\n",
      "ID: V003, Model: Truck\n",
      "ID: V004, Model: Sedan\n"
     ]
    }
   ],
   "source": [
    "rental_system.display_available_vehicles()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c87cb3c1",
   "metadata": {},
   "source": [
    "## Problem 4: Library Catalog Create classes representing a library and a book. Implement methods to add books to the library, borrow books, and display available books."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "d3132a60",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.is_available = True\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'\"{self.title}\" by {self.author}'\n",
    "\n",
    "class Library:\n",
    "    def __init__(self):\n",
    "        self.books = []\n",
    "\n",
    "    def add_book(self, book):\n",
    "        self.books.append(book)\n",
    "        print(f'Book added: {book}')\n",
    "\n",
    "    def borrow_book(self, title):\n",
    "        for book in self.books:\n",
    "            if book.title == title and book.is_available:\n",
    "                book.is_available = False\n",
    "                print(f'Book borrowed: {book}')\n",
    "        print(f'Book not available: {title}')\n",
    "\n",
    "    def display_available_books(self):\n",
    "        available_books = [book for book in self.books if book.is_available]\n",
    "        if available_books:\n",
    "            print('Available Books:')\n",
    "            for book in available_books:\n",
    "                print(f'  {book}')\n",
    "        else:\n",
    "            print('No books available.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "39e03de1",
   "metadata": {},
   "outputs": [],
   "source": [
    "book1 = Book(\"DSA\", \"Jatin\")\n",
    "book2 = Book(\"fundamentals of computer\", \"Hasan\")\n",
    "book3 = Book(\"1984\", \"homeo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "7e72b0f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "library = Library()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "0bacb75d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book added: \"DSA\" by Jatin\n",
      "Book added: \"fundamentals of computer\" by Hasan\n",
      "Book added: \"1984\" by homeo\n"
     ]
    }
   ],
   "source": [
    "library.add_book(book1)\n",
    "library.add_book(book2)\n",
    "library.add_book(book3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "4624f02b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Books:\n",
      "  \"DSA\" by Jatin\n",
      "  \"fundamentals of computer\" by Hasan\n",
      "  \"1984\" by homeo\n"
     ]
    }
   ],
   "source": [
    "library.display_available_books()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "b540eefe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book borrowed: \"DSA\" by Jatin\n",
      "Book not available: DSA\n"
     ]
    }
   ],
   "source": [
    "library.borrow_book(\"DSA\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "a3f922ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Books:\n",
      "  \"fundamentals of computer\" by Hasan\n",
      "  \"1984\" by homeo\n"
     ]
    }
   ],
   "source": [
    "library.display_available_books()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12d43efe",
   "metadata": {},
   "source": [
    "## Problem 5: Product Inventory Create classes representing a product and an inventory system. Implement methods to add products to the inventory, update product quantity, and display available products.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "5aa347a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Product:\n",
    "    def __init__(self, product_id, name, price, quantity):\n",
    "        self.product_id = product_id\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "        self.quantity = quantity\n",
    "\n",
    "    def __str__(self):\n",
    "        return f'Product ID: {self.product_id}, Name: {self.name}, Price: ₹{self.price}, Quantity: {self.quantity}'\n",
    "\n",
    "class Inventory:\n",
    "    def __init__(self):\n",
    "        self.products = []\n",
    "\n",
    "    def add_product(self, product):\n",
    "        self.products.append(product)\n",
    "        print(f'Product added to inventory: {product}')\n",
    "\n",
    "    def update_quantity(self, product_id, new_quantity):\n",
    "        for product in self.products:\n",
    "            if product.product_id == product_id:\n",
    "                product.quantity = new_quantity\n",
    "                print(f'Quantity updated for {product}: New Quantity: {new_quantity}')\n",
    "        print(f'Product with ID {product_id} not found in inventory.')\n",
    "\n",
    "    def display_available_products(self):\n",
    "        if self.products:\n",
    "            print('Available Products:')\n",
    "            for product in self.products:\n",
    "                print(f'  {product}')\n",
    "        else:\n",
    "            print('No products available in the inventory.')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "e639a9cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "product1 = Product(1, \"Laptop\", 1200, 10)\n",
    "product2 = Product(2, \"Smartphone\", 800, 15)\n",
    "product3 = Product(3, \"Headphones\", 100, 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "1e5b2d02",
   "metadata": {},
   "outputs": [],
   "source": [
    "inventory = Inventory()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "bdef1d07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product added to inventory: Product ID: 1, Name: Laptop, Price: ₹1200, Quantity: 10\n",
      "Product added to inventory: Product ID: 2, Name: Smartphone, Price: ₹800, Quantity: 15\n",
      "Product added to inventory: Product ID: 3, Name: Headphones, Price: ₹100, Quantity: 30\n"
     ]
    }
   ],
   "source": [
    "inventory.add_product(product1)\n",
    "inventory.add_product(product2)\n",
    "inventory.add_product(product3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "3615289e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Products:\n",
      "  Product ID: 1, Name: Laptop, Price: ₹1200, Quantity: 10\n",
      "  Product ID: 2, Name: Smartphone, Price: ₹800, Quantity: 15\n",
      "  Product ID: 3, Name: Headphones, Price: ₹100, Quantity: 30\n"
     ]
    }
   ],
   "source": [
    "inventory.display_available_products()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "23e9c734",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantity updated for Product ID: 2, Name: Smartphone, Price: ₹800, Quantity: 20: New Quantity: 20\n",
      "Product with ID 2 not found in inventory.\n"
     ]
    }
   ],
   "source": [
    "inventory.update_quantity(2, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "3a6b8386",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Products:\n",
      "  Product ID: 1, Name: Laptop, Price: ₹1200, Quantity: 10\n",
      "  Product ID: 2, Name: Smartphone, Price: ₹800, Quantity: 20\n",
      "  Product ID: 3, Name: Headphones, Price: ₹100, Quantity: 30\n"
     ]
    }
   ],
   "source": [
    "inventory.display_available_products()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9bc672",
   "metadata": {},
   "source": [
    "## Problem 6: Shape Calculation Create a class representing a shape with attributes like length, width, and height. Implement methods to calculate the area and perimeter of the shape."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "0f24745c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class shape:\n",
    "    def __init__(self,length,width,height):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "        \n",
    "    def area(self):\n",
    "        return 2*(self.length*self.width+self.width*self.height+self.length*self.height)\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 4*(self.length+self.width+self.height)\n",
    "    def volume(self):\n",
    "        return self.length*self.width*self.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "54163b41",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the cuboid is 160 sq. unit\n",
      "Perimeter of the cuboid is 68 unit\n",
      "Volume of the cuboid is 100 cubic unit\n"
     ]
    }
   ],
   "source": [
    "cuboid = shape(10,5,2)\n",
    "print(f\"Area of the cuboid is {cuboid.area()} sq. unit\")\n",
    "print(f\"Perimeter of the cuboid is {cuboid.perimeter()} unit\")\n",
    "print(f\"Volume of the cuboid is {cuboid.volume()} cubic unit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "23268a62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of the cube is 294 sq. unit\n",
      "Perimeter of the cube is 84 unit\n",
      "Volume of the cube is 343 cubic unit\n"
     ]
    }
   ],
   "source": [
    "cube = shape(7,7,7)\n",
    "print(f\"Area of the cube is {cube.area()} sq. unit\")\n",
    "print(f\"Perimeter of the cube is {cube.perimeter()} unit\")\n",
    "print(f\"Volume of the cube is {cube.volume()} cubic unit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29a76fad",
   "metadata": {},
   "source": [
    "## Problem 7: Student Management Create a class representing a student with attributes like student ID, name, and grades. Implement methods to calculate the average grade and display student details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "65bb8184",
   "metadata": {},
   "outputs": [],
   "source": [
    "class student:\n",
    "    \n",
    "    def __init__(self,student_id,name,grades):\n",
    "        self.student_id = student_id\n",
    "        self.name = name\n",
    "        self.grades = grades\n",
    "        \n",
    "    def calc_avg_grade(self):\n",
    "        if not self.grades:\n",
    "            return 0\n",
    "        else:\n",
    "            return sum(self.grades)/len(self.grades)\n",
    "    \n",
    "    def display_student_details(self):\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "        print(f\"Student's name: {self.name}\")\n",
    "        print(f\"Grades: {', '.join(map(str, self.grades))}\")\n",
    "        print(f\"Average grade: {self.calc_avg_grade()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "32cf84fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "student1 = student(student_id = 1,name=\"hari\",grades=[90,52,54,78,91,85])\n",
    "student2 = student(student_id=2,name=\"ravi\",grades=[50,50,50,50,85])\n",
    "student3 = student(student_id=3,name=\"Raja\",grades=[40,85,85,74,85,95,65])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "63cff683",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student ID: 1\n",
      "Student's name: hari\n",
      "Grades: 90, 52, 54, 78, 91, 85\n",
      "Average grade: 75.0\n"
     ]
    }
   ],
   "source": [
    "student1.display_student_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "40be4311",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student ID: 2\n",
      "Student's name: ravi\n",
      "Grades: 50, 50, 50, 50, 85\n",
      "Average grade: 57.0\n"
     ]
    }
   ],
   "source": [
    "student2.display_student_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "f5c6bb44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student ID: 3\n",
      "Student's name: Raja\n",
      "Grades: 40, 85, 85, 74, 85, 95, 65\n",
      "Average grade: 75.57142857142857\n"
     ]
    }
   ],
   "source": [
    "student3.display_student_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba84d25d",
   "metadata": {},
   "source": [
    "## Problem 8: Email Management Create a class representing an email with attributes like sender, recipient, and subject. Implement methods to send an email and display email details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "236efe67",
   "metadata": {},
   "outputs": [],
   "source": [
    "class email:\n",
    "    def __init__(self, sender, recipient, subject, body):\n",
    "        self.sender = sender\n",
    "        self.recipient = recipient\n",
    "        self.subject = subject\n",
    "        self.body = body\n",
    "        self.sent = False\n",
    "\n",
    "    def send_email(self):\n",
    "        self.sent = True\n",
    "        print(\"Email sent!\")\n",
    "\n",
    "    def display_email_details(self):\n",
    "        print(f\"Sender: {self.sender}\")\n",
    "        print(f\"Recipient: {self.recipient}\")\n",
    "        print(f\"Subject: {self.subject}\")\n",
    "        print(f\"Body: {self.body}\")\n",
    "        print(f\"Status: {'Sent' if self.sent else 'Draft'}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "2f3f2bcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "email1 = email(sender=\"abc@gmail.com\", recipient=\"xyz@gmail.com\", subject=\"Random\", body=\"This is a test email\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "a41bdc01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Email sent!\n"
     ]
    }
   ],
   "source": [
    "email1.send_email()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "d54337c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sender: abc@gmail.com\n",
      "Recipient: xyz@gmail.com\n",
      "Subject: Random\n",
      "Body: This is a test email\n",
      "Status: Sent\n"
     ]
    }
   ],
   "source": [
    "email1.display_email_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "789dd1c0",
   "metadata": {},
   "source": [
    "## Problem 9: Social Media Profile Create a class representing a social media profile with attributes like username and posts. Implement methods to add posts, display posts, and search for posts by keyword."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "813c6c1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SocialMediaProfile:\n",
    "    def __init__(self, username):\n",
    "        self.username = username\n",
    "        self.posts = []\n",
    "\n",
    "    def add_post(self, content):\n",
    "        post = {\"content\": content, \"author\": self.username}\n",
    "        self.posts.append(post)\n",
    "        print(\"Post added successfully!\")\n",
    "\n",
    "    def display_posts(self):\n",
    "        if not self.posts:\n",
    "            print(\"No posts to display.\")\n",
    "        else:\n",
    "            print(f\"Posts by {self.username}:\")\n",
    "            for i, post in enumerate(self.posts, start=1):\n",
    "                print(f\"{i}. {post['content']}\")\n",
    "\n",
    "    def search_posts_by_keyword(self, keyword):\n",
    "        matching_posts = [post for post in self.posts if keyword.lower() in post['content'].lower()]\n",
    "        if not matching_posts:\n",
    "            print(f\"No posts found containing the keyword '{keyword}'.\")\n",
    "        else:\n",
    "            print(f\"Matching posts for keyword '{keyword}':\")\n",
    "            for i, post in enumerate(matching_posts, start=1):\n",
    "                print(f\"{i}. {post['content']}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "0faacd68",
   "metadata": {},
   "outputs": [],
   "source": [
    "profile1 = SocialMediaProfile(username=\"Raman\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "217d974b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Post added successfully!\n",
      "Post added successfully!\n",
      "Post added successfully!\n"
     ]
    }
   ],
   "source": [
    "profile1.add_post(\"Hello, this is my first post!\")\n",
    "profile1.add_post(\"Having a great day! 😊\")\n",
    "profile1.add_post(\"Just finished reading a good book.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "89bfe116",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Posts by Raman:\n",
      "1. Hello, this is my first post!\n",
      "2. Having a great day! 😊\n",
      "3. Just finished reading a good book.\n"
     ]
    }
   ],
   "source": [
    "profile1.display_posts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "3d80fda6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matching posts for keyword 'a':\n",
      "1. Having a great day! 😊\n",
      "2. Just finished reading a good book.\n"
     ]
    }
   ],
   "source": [
    "profile1.search_posts_by_keyword(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1032161b",
   "metadata": {},
   "source": [
    "## Problem 10: ToDo List Create a class representing a ToDo list with attributes like tasks and due dates. Implement methods to add tasks, mark tasks as completed, and display pending tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "b5e15fef",
   "metadata": {},
   "outputs": [],
   "source": [
    "class to_do_list:\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.tasks = []\n",
    "\n",
    "    def add_task(self, task):\n",
    "        self.tasks.append({\"task\": task, \"completed\": False})\n",
    "        print(f\"Task '{task}' added to the To-Do list.\")\n",
    "\n",
    "    def mark_task_as_completed(self, task_index):\n",
    "        if 0 <= task_index < len(self.tasks):\n",
    "            self.tasks[task_index][\"completed\"] = True\n",
    "            print(f\"Task '{self.tasks[task_index]['task']}' marked as completed.\")\n",
    "        else:\n",
    "            print(\"Invalid task index.\")\n",
    "\n",
    "    def display_pending_tasks(self):\n",
    "        pending_tasks = [task[\"task\"] for task in self.tasks if not task[\"completed\"]]\n",
    "        if not pending_tasks:\n",
    "            print(\"No pending tasks.\")\n",
    "        else:\n",
    "            print(\"Pending Tasks:\")\n",
    "            for i, task in enumerate(pending_tasks, start=1):\n",
    "                print(f\"{i}. {task}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "358ace33",
   "metadata": {},
   "outputs": [],
   "source": [
    "todo_list = to_do_list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "41c71ff1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 'complete assignment' added to the To-Do list.\n",
      "Task 'Upload it on the github' added to the To-Do list.\n",
      "Task 'paste the github link on pwskills website' added to the To-Do list.\n"
     ]
    }
   ],
   "source": [
    "todo_list.add_task(\"complete assignment\")\n",
    "todo_list.add_task(\"Upload it on the github\")\n",
    "todo_list.add_task(\"paste the github link on pwskills website\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "9aa41398",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pending Tasks:\n",
      "1. complete assignment\n",
      "2. Upload it on the github\n",
      "3. paste the github link on pwskills website\n"
     ]
    }
   ],
   "source": [
    "todo_list.display_pending_tasks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "c0b99d8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 'complete assignment' marked as completed.\n"
     ]
    }
   ],
   "source": [
    "todo_list.mark_task_as_completed(0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "d6fceb71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pending Tasks:\n",
      "1. Upload it on the github\n",
      "2. paste the github link on pwskills website\n"
     ]
    }
   ],
   "source": [
    "todo_list.display_pending_tasks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "57713dc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 'Upload it on the github' marked as completed.\n"
     ]
    }
   ],
   "source": [
    "todo_list.mark_task_as_completed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "ce4a64d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pending Tasks:\n",
      "1. paste the github link on pwskills website\n"
     ]
    }
   ],
   "source": [
    "todo_list.display_pending_tasks()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "b002e176",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 'paste the github link on pwskills website' marked as completed.\n"
     ]
    }
   ],
   "source": [
    "todo_list.mark_task_as_completed(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "8788c727",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No pending tasks.\n"
     ]
    }
   ],
   "source": [
    "todo_list.display_pending_tasks()"
   ]
  }
 ],
 "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}