7th_Oct_OOPS_1_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a1214228",
   "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.\n",
    "\n",
    "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",
    "\n",
    "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.\n",
    "\n",
    "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.\n",
    "\n",
    "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",
    "\n",
    "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.\n",
    "\n",
    "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.\n",
    "\n",
    "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.\n",
    "\n",
    "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.\n",
    "\n",
    "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": "markdown",
   "id": "18fc6044",
   "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": 6,
   "id": "0df398c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Account Number: 12345\n",
      "Account Holder: Mit Thakkar\n",
      "Balance: Rs.1000.0\n",
      "Deposited Rs.500.0 into the account. New balance: Rs.1500.0\n",
      "Withdrew Rs.200.0 from the account. New balance: Rs.1300.0\n",
      "Account Number: 12345\n",
      "Account Holder: Mit Thakkar\n",
      "Balance: Rs.1300.0\n"
     ]
    }
   ],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, account_number, account_holder_name, balance=0.0):\n",
    "        self.account_number = account_number\n",
    "        self.account_holder_name = account_holder_name\n",
    "        self.balance = balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        if amount > 0:\n",
    "            self.balance += amount\n",
    "            print(f\"Deposited Rs.{amount} into the account. New balance: Rs.{self.balance}\")\n",
    "        else:\n",
    "            print(\"Invalid deposit amount. Please deposit a positive amount.\")\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if amount > 0 and amount <= self.balance:\n",
    "            self.balance -= amount\n",
    "            print(f\"Withdrew Rs.{amount} from the account. New balance: Rs.{self.balance}\")\n",
    "        elif amount <= 0:\n",
    "            print(\"Invalid withdrawal amount. Please withdraw a positive amount.\")\n",
    "        else:\n",
    "            print(\"Insufficient balance for withdrawal.\")\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self.balance\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"Account Number: {self.account_number}\\nAccount Holder: {self.account_holder_name}\\nBalance: Rs.{self.balance}\"\n",
    "\n",
    "# Example usage:\n",
    "\n",
    "account = BankAccount(\"12345\", \"Mit Thakkar\", 1000.0)\n",
    "\n",
    "print(account)\n",
    "account.deposit(500.0)\n",
    "account.withdraw(200.0)\n",
    "print(account)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77db3c5b",
   "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": 10,
   "id": "9c9fc995",
   "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 calculate_yearly_bonus(self, bonus_percentage):\n",
    "        if bonus_percentage >= 0 and bonus_percentage <= 100:\n",
    "            bonus_amount = (bonus_percentage / 100) * self.salary\n",
    "            return bonus_amount\n",
    "        else:\n",
    "            return \"Invalid bonus percentage. It should be between 0 and 100.\"\n",
    "\n",
    "    def display_employee_details(self):\n",
    "        print(f\"Employee ID: {self.employee_id}\")\n",
    "        print(f\"Name: {self.name}\")\n",
    "        print(f\"Salary: ${self.salary}\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dfb7a6f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee ID: E12345\n",
      "Name: John Doe\n",
      "Salary: $50000.0\n",
      "Yearly Bonus: $5000.00\n"
     ]
    }
   ],
   "source": [
    "employee = Employee(\"E12345\", \"John Doe\", 50000.0)\n",
    "\n",
    "employee.display_employee_details()\n",
    "\n",
    "bonus_percentage = 10  # 10% bonus\n",
    "\n",
    "bonus = employee.calculate_yearly_bonus(bonus_percentage)\n",
    "\n",
    "if isinstance(bonus, str):\n",
    "    print(bonus)\n",
    "else:\n",
    "    print(f\"Yearly Bonus: ${bonus:.2f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e05c5f5",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cd6d23f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class VehicleRentalSystem:\n",
    "    def __init__(self):\n",
    "        # Initialize an empty dictionary to store available vehicles.\n",
    "        self.available_vehicles = {}\n",
    "\n",
    "    def add_vehicle(self, vehicle_id, vehicle_type):\n",
    "        if vehicle_id not in self.available_vehicles:\n",
    "            self.available_vehicles[vehicle_id] = vehicle_type\n",
    "            print(f\"Vehicle {vehicle_id} ({vehicle_type}) added to the rental system.\")\n",
    "        else:\n",
    "            print(f\"Vehicle {vehicle_id} is already in the system.\")\n",
    "\n",
    "    def rent_vehicle(self, vehicle_id):\n",
    "        if vehicle_id in self.available_vehicles:\n",
    "            vehicle_type = self.available_vehicles[vehicle_id]\n",
    "            del self.available_vehicles[vehicle_id]\n",
    "            print(f\"Rented vehicle {vehicle_id} ({vehicle_type}).\")\n",
    "        else:\n",
    "            print(f\"Vehicle {vehicle_id} is not available for rent.\")\n",
    "\n",
    "    def return_vehicle(self, vehicle_id, vehicle_type):\n",
    "        if vehicle_id not in self.available_vehicles:\n",
    "            self.available_vehicles[vehicle_id] = vehicle_type\n",
    "            print(f\"Returned vehicle {vehicle_id} ({vehicle_type}).\")\n",
    "        else:\n",
    "            print(f\"Vehicle {vehicle_id} is already available for rent.\")\n",
    "\n",
    "    def display_available_vehicles(self):\n",
    "        print(\"Available Vehicles:\")\n",
    "        for vehicle_id, vehicle_type in self.available_vehicles.items():\n",
    "            print(f\"Vehicle {vehicle_id} ({vehicle_type})\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "76822c47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vehicle V001 (Sedan) added to the rental system.\n",
      "Vehicle V002 (SUV) added to the rental system.\n",
      "Vehicle V003 (Compact) added to the rental system.\n",
      "Available Vehicles:\n",
      "Vehicle V001 (Sedan)\n",
      "Vehicle V002 (SUV)\n",
      "Vehicle V003 (Compact)\n",
      "Rented vehicle V001 (Sedan).\n",
      "Available Vehicles:\n",
      "Vehicle V002 (SUV)\n",
      "Vehicle V003 (Compact)\n",
      "Returned vehicle V001 (Sedan).\n",
      "Available Vehicles:\n",
      "Vehicle V002 (SUV)\n",
      "Vehicle V003 (Compact)\n",
      "Vehicle V001 (Sedan)\n"
     ]
    }
   ],
   "source": [
    "rental_system = VehicleRentalSystem()\n",
    "\n",
    "rental_system.add_vehicle(\"V001\", \"Sedan\")\n",
    "rental_system.add_vehicle(\"V002\", \"SUV\")\n",
    "rental_system.add_vehicle(\"V003\", \"Compact\")\n",
    "\n",
    "rental_system.display_available_vehicles()\n",
    "\n",
    "rental_system.rent_vehicle(\"V001\")\n",
    "rental_system.display_available_vehicles()\n",
    "\n",
    "rental_system.return_vehicle(\"V001\", \"Sedan\")\n",
    "rental_system.display_available_vehicles()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0da4a41a",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "11d6291b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, book_id):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.book_id = book_id\n",
    "        self.available = True\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"Book ID: {self.book_id}, Title: {self.title}, Author: {self.author}, Available: {self.available}\"\n",
    "\n",
    "class Library:\n",
    "    def __init__(self):\n",
    "        # Initialize an empty list to store books.\n",
    "        self.books = []\n",
    "\n",
    "    def add_book(self, title, author):\n",
    "        # Generate a unique book ID by incrementing the last book ID by 1.\n",
    "        book_id = len(self.books) + 1\n",
    "        new_book = Book(title, author, book_id)\n",
    "        self.books.append(new_book)\n",
    "        print(f\"Book '{title}' by {author} added to the library with ID {book_id}.\")\n",
    "\n",
    "    def borrow_book(self, book_id):\n",
    "        for book in self.books:\n",
    "            if book.book_id == book_id:\n",
    "                if book.available:\n",
    "                    book.available = False\n",
    "                    print(f\"You have borrowed '{book.title}' by {book.author}.\")\n",
    "                else:\n",
    "                    print(f\"The book '{book.title}' is currently not available.\")\n",
    "                return\n",
    "        print(\"Book not found in the library.\")\n",
    "\n",
    "    def display_available_books(self):\n",
    "        print(\"Available Books:\")\n",
    "        for book in self.books:\n",
    "            if book.available:\n",
    "                print(book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "91c1b872",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book 'To Kill a Mockingbird' by Harper Lee added to the library with ID 1.\n",
      "Book '1984' by George Orwell added to the library with ID 2.\n",
      "Book 'The Great Gatsby' by F. Scott Fitzgerald added to the library with ID 3.\n",
      "Available Books:\n",
      "Book ID: 1, Title: To Kill a Mockingbird, Author: Harper Lee, Available: True\n",
      "Book ID: 2, Title: 1984, Author: George Orwell, Available: True\n",
      "Book ID: 3, Title: The Great Gatsby, Author: F. Scott Fitzgerald, Available: True\n",
      "You have borrowed 'To Kill a Mockingbird' by Harper Lee.\n",
      "The book 'To Kill a Mockingbird' is currently not available.\n",
      "You have borrowed 'The Great Gatsby' by F. Scott Fitzgerald.\n",
      "Available Books:\n",
      "Book ID: 2, Title: 1984, Author: George Orwell, Available: True\n"
     ]
    }
   ],
   "source": [
    "library = Library()\n",
    "\n",
    "library.add_book(\"To Kill a Mockingbird\", \"Harper Lee\")\n",
    "library.add_book(\"1984\", \"George Orwell\")\n",
    "library.add_book(\"The Great Gatsby\", \"F. Scott Fitzgerald\")\n",
    "\n",
    "library.display_available_books()\n",
    "\n",
    "library.borrow_book(1)\n",
    "library.borrow_book(1)  # Attempt to borrow the same book again\n",
    "library.borrow_book(3)  # Attempt to borrow a non-existent book\n",
    "\n",
    "library.display_available_books()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "470ba36c",
   "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": 14,
   "id": "3f2768ea",
   "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:.2f}, Quantity: {self.quantity}\"\n",
    "\n",
    "class Inventory:\n",
    "    def __init__(self):\n",
    "        # Initialize an empty dictionary to store products with their IDs as keys.\n",
    "        self.products = {}\n",
    "\n",
    "    def add_product(self, product_id, name, price, quantity):\n",
    "        if product_id not in self.products:\n",
    "            new_product = Product(product_id, name, price, quantity)\n",
    "            self.products[product_id] = new_product\n",
    "            print(f\"Product '{name}' added to the inventory with ID {product_id}.\")\n",
    "        else:\n",
    "            print(f\"Product with ID {product_id} already exists in the inventory.\")\n",
    "\n",
    "    def update_quantity(self, product_id, new_quantity):\n",
    "        if product_id in self.products:\n",
    "            product = self.products[product_id]\n",
    "            product.quantity = new_quantity\n",
    "            print(f\"Quantity for product '{product.name}' (ID {product_id}) updated to {new_quantity}.\")\n",
    "        else:\n",
    "            print(f\"Product with ID {product_id} is not found in the inventory.\")\n",
    "\n",
    "    def display_available_products(self):\n",
    "        print(\"Available Products:\")\n",
    "        for product_id, product in self.products.items():\n",
    "            print(product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e3907739",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product 'Laptop' added to the inventory with ID 1.\n",
      "Product 'Smartphone' added to the inventory with ID 2.\n",
      "Product 'Tablet' added to the inventory with ID 3.\n",
      "Available Products:\n",
      "Product ID: 1, Name: Laptop, Price: $999.99, Quantity: 10\n",
      "Product ID: 2, Name: Smartphone, Price: $599.99, Quantity: 20\n",
      "Product ID: 3, Name: Tablet, Price: $299.99, Quantity: 15\n",
      "Quantity for product 'Laptop' (ID 1) updated to 5.\n",
      "Product with ID 4 is not found in the inventory.\n",
      "Available Products:\n",
      "Product ID: 1, Name: Laptop, Price: $999.99, Quantity: 5\n",
      "Product ID: 2, Name: Smartphone, Price: $599.99, Quantity: 20\n",
      "Product ID: 3, Name: Tablet, Price: $299.99, Quantity: 15\n"
     ]
    }
   ],
   "source": [
    "\n",
    "inventory_system = Inventory()\n",
    "\n",
    "inventory_system.add_product(1, \"Laptop\", 999.99, 10)\n",
    "inventory_system.add_product(2, \"Smartphone\", 599.99, 20)\n",
    "inventory_system.add_product(3, \"Tablet\", 299.99, 15)\n",
    "\n",
    "inventory_system.display_available_products()\n",
    "\n",
    "inventory_system.update_quantity(1, 5)\n",
    "inventory_system.update_quantity(4, 8)  # Attempt to update a non-existent product\n",
    "\n",
    "inventory_system.display_available_products()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8b5d438",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f7c89d27",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Shape:\n",
    "    def __init__(self, length, width=None, height=None):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def calculate_area(self):\n",
    "        if self.width is None and self.height is None:\n",
    "            return None\n",
    "        elif self.width is not None and self.height is not None:\n",
    "            return 2 * (self.length * self.width + self.width * self.height + self.height * self.length)\n",
    "        elif self.width is not None:\n",
    "            return self.length * self.width\n",
    "        else:\n",
    "            import math\n",
    "            return math.pi * (self.length ** 2)\n",
    "\n",
    "    def calculate_perimeter(self):\n",
    "        if self.width is None and self.height is None:\n",
    "            return self.length * 2\n",
    "        elif self.width is not None and self.height is not None:\n",
    "            return 4 * (self.length + self.width + self.height)\n",
    "        elif self.width is not None:\n",
    "            return 2 * (self.length + self.width)\n",
    "        else:\n",
    "            import math\n",
    "            return 2 * math.pi * self.length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "de997847",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Line: Area - None Perimeter - 10\n",
      "Rectangle: Area - 24 Perimeter - 20\n",
      "Circle: Area - None Circumference - 7.0\n",
      "Cuboid: Surface Area - 148 Perimeter - 60\n"
     ]
    }
   ],
   "source": [
    "line = Shape(5)\n",
    "rectangle = Shape(4, 6)\n",
    "circle = Shape(3.5)\n",
    "cuboid = Shape(4, 5, 6)\n",
    "\n",
    "print(\"Line: Area -\", line.calculate_area(), \"Perimeter -\", line.calculate_perimeter())\n",
    "print(\"Rectangle: Area -\", rectangle.calculate_area(), \"Perimeter -\", rectangle.calculate_perimeter())\n",
    "print(\"Circle: Area -\", circle.calculate_area(), \"Circumference -\", circle.calculate_perimeter())\n",
    "print(\"Cuboid: Surface Area -\", cuboid.calculate_area(), \"Perimeter -\", cuboid.calculate_perimeter())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff78fdc",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "50cfd690",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, student_id, name):\n",
    "        self.student_id = student_id\n",
    "        self.name = name\n",
    "        self.grades = []\n",
    "\n",
    "    def add_grade(self, grade):\n",
    "        self.grades.append(grade)\n",
    "\n",
    "    def calculate_average_grade(self):\n",
    "        if len(self.grades) == 0:\n",
    "            return 0  # Avoid division by zero.\n",
    "        total = sum(self.grades)\n",
    "        average = total / len(self.grades)\n",
    "        return average\n",
    "\n",
    "    def display_student_details(self):\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "        print(f\"Name: {self.name}\")\n",
    "        print(f\"Grades: {', '.join(map(str, self.grades))}\")\n",
    "        print(f\"Average Grade: {self.calculate_average_grade():.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6f277f54",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Student ID: S12345\n",
      "Name: TMR\n",
      "Grades: 85, 92, 78\n",
      "Average Grade: 85.00\n"
     ]
    }
   ],
   "source": [
    "student = Student(\"S12345\", \"TMR\")\n",
    "\n",
    "student.add_grade(85)\n",
    "student.add_grade(92)\n",
    "student.add_grade(78)\n",
    "\n",
    "student.display_student_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "537e9def",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9f1a336e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Email:\n",
    "    def __init__(self, sender, recipient, subject, message):\n",
    "        self.sender = sender\n",
    "        self.recipient = recipient\n",
    "        self.subject = subject\n",
    "        self.message = message\n",
    "        self.sent = False\n",
    "\n",
    "    def send_email(self):\n",
    "        if not self.sent:\n",
    "            self.sent = True\n",
    "            print(\"Email sent successfully!\")\n",
    "        else:\n",
    "            print(\"This email has already been sent.\")\n",
    "\n",
    "    def display_email_details(self):\n",
    "        print(\"Sender:\", self.sender)\n",
    "        print(\"Recipient:\", self.recipient)\n",
    "        print(\"Subject:\", self.subject)\n",
    "        print(\"Message:\", self.message)\n",
    "        if self.sent:\n",
    "            print(\"Status: Sent\")\n",
    "        else:\n",
    "            print(\"Status: Draft\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1a77064e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sender: sender@example.com\n",
      "Recipient: recipient@example.com\n",
      "Subject: Hello\n",
      "Message: This is a test email message.\n",
      "Status: Draft\n",
      "Email sent successfully!\n",
      "Sender: sender@example.com\n",
      "Recipient: recipient@example.com\n",
      "Subject: Hello\n",
      "Message: This is a test email message.\n",
      "Status: Sent\n"
     ]
    }
   ],
   "source": [
    "email = Email(\"sender@example.com\", \"recipient@example.com\", \"Hello\", \"This is a test email message.\")\n",
    "\n",
    "email.display_email_details()\n",
    "email.send_email()\n",
    "email.display_email_details()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f30633e0",
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "02b57684",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SocialMediaProfile:\n",
    "    def __init__(self, username):\n",
    "        self.username = username\n",
    "        self.posts = []\n",
    "\n",
    "    def add_post(self, post_content):\n",
    "        self.posts.append(post_content)\n",
    "        print(f\"New post added by {self.username}:\\n{post_content}\")\n",
    "\n",
    "    def display_posts(self):\n",
    "        if not self.posts:\n",
    "            print(f\"{self.username} has no posts.\")\n",
    "        else:\n",
    "            print(f\"Posts by {self.username}:\")\n",
    "            for i, post in enumerate(self.posts, start=1):\n",
    "                print(f\"{i}. {post}\")\n",
    "\n",
    "    def search_posts_by_keyword(self, keyword):\n",
    "        matching_posts = [post for post in self.posts if keyword.lower() in post.lower()]\n",
    "        if not matching_posts:\n",
    "            print(f\"No posts containing '{keyword}' found for {self.username}.\")\n",
    "        else:\n",
    "            print(f\"Posts by {self.username} containing '{keyword}':\")\n",
    "            for i, post in enumerate(matching_posts, start=1):\n",
    "                print(f\"{i}. {post}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3ec9addb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New post added by user123:\n",
      "Enjoying a beautiful day in the park.\n",
      "New post added by user123:\n",
      "Trying out a new recipe for dinner.\n",
      "New post added by user123:\n",
      "Just returned from a fantastic vacation!\n",
      "Posts by user123:\n",
      "1. Enjoying a beautiful day in the park.\n",
      "2. Trying out a new recipe for dinner.\n",
      "3. Just returned from a fantastic vacation!\n",
      "Posts by user123 containing 'recipe':\n",
      "1. Trying out a new recipe for dinner.\n",
      "No posts containing 'workout' found for user123.\n"
     ]
    }
   ],
   "source": [
    "profile = SocialMediaProfile(\"user123\")\n",
    "\n",
    "profile.add_post(\"Enjoying a beautiful day in the park.\")\n",
    "profile.add_post(\"Trying out a new recipe for dinner.\")\n",
    "profile.add_post(\"Just returned from a fantastic vacation!\")\n",
    "\n",
    "profile.display_posts()\n",
    "\n",
    "profile.search_posts_by_keyword(\"recipe\")\n",
    "profile.search_posts_by_keyword(\"workout\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e494ed13",
   "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": 30,
   "id": "24463250",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ToDoList:\n",
    "    def __init__(self):\n",
    "        self.tasks = []\n",
    "\n",
    "    def add_task(self, task, due_date):\n",
    "        self.tasks.append({\"task\": task, \"due_date\": due_date, \"completed\": False})\n",
    "        print(f\"Task '{task}' added with a due date of {due_date}.\")\n",
    "\n",
    "    def mark_task_as_completed(self, task):\n",
    "        for item in self.tasks:\n",
    "            if item[\"task\"] == task:\n",
    "                item[\"completed\"] = True\n",
    "                print(f\"Task '{task}' marked as completed.\")\n",
    "                return\n",
    "        print(f\"Task '{task}' not found in the ToDo list.\")\n",
    "\n",
    "    def display_pending_tasks(self):\n",
    "        pending_tasks = [item for item in self.tasks if not item[\"completed\"]]\n",
    "        if not pending_tasks:\n",
    "            print(\"No pending tasks.\")\n",
    "        else:\n",
    "            print(\"Pending Tasks:\")\n",
    "            for item in pending_tasks:\n",
    "                print(f\"Task: {item['task']}, Due Date: {item['due_date']}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "07721eb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Task 'Buy groceries' added with a due date of 2023-11-10.\n",
      "Task 'Prepare presentation' added with a due date of 2023-11-15.\n",
      "Task 'Exercise' added with a due date of 2023-11-12.\n",
      "Pending Tasks:\n",
      "Task: Buy groceries, Due Date: 2023-11-10\n",
      "Task: Prepare presentation, Due Date: 2023-11-15\n",
      "Task: Exercise, Due Date: 2023-11-12\n",
      "Task 'Buy groceries' marked as completed.\n",
      "Task 'Go to the gym' not found in the ToDo list.\n",
      "Pending Tasks:\n",
      "Task: Prepare presentation, Due Date: 2023-11-15\n",
      "Task: Exercise, Due Date: 2023-11-12\n"
     ]
    }
   ],
   "source": [
    "\n",
    "todo_list = ToDoList()\n",
    "\n",
    "todo_list.add_task(\"Buy groceries\", \"2023-11-10\")\n",
    "todo_list.add_task(\"Prepare presentation\", \"2023-11-15\")\n",
    "todo_list.add_task(\"Exercise\", \"2023-11-12\")\n",
    "\n",
    "todo_list.display_pending_tasks()\n",
    "\n",
    "todo_list.mark_task_as_completed(\"Buy groceries\")\n",
    "todo_list.mark_task_as_completed(\"Go to the gym\")  # Attempt to mark a non-existent task\n",
    "\n",
    "todo_list.display_pending_tasks()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74da3001",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}