Object Oriented Programming (oop) .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "26b3cad3-c2a1-4a9e-bda4-c035356601a4",
   "metadata": {},
   "source": [
    "# 1. Explain the importance of Functions\n",
    "\n",
    "- Reusability: Like having a magic spell you can cast again and again, functions save you time and effort by letting you reuse code instead of rewriting it.\n",
    "\n",
    "- Organization: Functions act like organizers for your code, keeping everything neat and tidy by dividing it into manageable sections with clear purposes.\n",
    "\n",
    "- Readability: By breaking down complex tasks into smaller steps within functions, your code becomes easier to understand for both you and others.\n",
    "\n",
    "- Maintainability: If you need to change something, you only need to update the relevant function, not hunt through your entire code. It's like fixing one Lego piece instead of rebuilding the whole castle.\n",
    "\n",
    "- Abstraction: Functions hide the complex details, allowing you to focus on what the code does rather than how it does it. This makes your code cleaner and easier to work with."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9b9fc48a-03e9-47e4-a208-6295e13db8e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice! Welcome to class.\n",
      "Hello, Bob! Welcome to class.\n",
      "Hello, Charlie! Welcome to class.\n"
     ]
    }
   ],
   "source": [
    "# 2. Write a basic function to greet students\n",
    "\n",
    "def greet_students(names):\n",
    " \n",
    "  for name in names:\n",
    "        \n",
    "    print(f\"Hello, {name}! Welcome to class.\")\n",
    "\n",
    "student_list = [\"Alice\", \"Bob\", \"Charlie\"]\n",
    "\n",
    "greet_students(student_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1acc0ecb-23d9-403a-9864-6264ab219121",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 3. What is the difference between print and return statements\n",
    "\n",
    "# Print:\n",
    "- Displays output: It shows information on the screen, like a message or a variable's value.\n",
    "- Doesn't return a value: It simply outputs information and doesn't provide anything for further use in the code.\n",
    "# Return:\n",
    "- Provides a value: It sends a value back to the code that called the function.\n",
    "- Can be stored and used: The returned value can be stored in a variable, used in calculations, or passed to other functions for further processing.\n",
    "\n",
    "In short: Use print to display information and return to provide a value for further use in your code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce591e95-1df6-4cae-baed-29fcc4892a6e",
   "metadata": {},
   "source": [
    "# 4. What are *args and **kwargs\n",
    "\n",
    "These are special syntax elements in Python functions that allow you to pass a variable number of arguments:\n",
    "# *args:\n",
    "- Variable positional arguments: This captures any number of positional arguments (arguments passed without keywords) as a tuple.\n",
    "\n",
    "- Example: \n",
    "\n",
    "def sum_numbers(*args):\n",
    "  total = 0\n",
    "  for num in args:\n",
    "    total += num\n",
    "  return total\n",
    "\n",
    "result = sum_numbers(1, 2, 3, 4, 5)  # args becomes (1, 2, 3, 4, 5)\n",
    "print(result)  # Output: 15\n",
    "\n",
    "# **kwargs:\n",
    "- Variable keyword arguments: This captures any number of keyword arguments (arguments passed with keywords) as a dictionary.\n",
    "\n",
    "- Example:\n",
    " \n",
    "def greet_person(**kwargs):\n",
    "  if \"name\" in kwargs:\n",
    "    print(f\"Hello, {kwargs['name']}!\")\n",
    "  if \"age\" in kwargs:\n",
    "    print(f\"You are {kwargs['age']} years old.\")\n",
    "\n",
    "greet_person(name=\"Alice\", age=30)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d849252-2034-4705-bbd8-2c90a77d3806",
   "metadata": {},
   "source": [
    "# 5. Explain the iterator function\n",
    "\n",
    "\n",
    "An iterator function is like a special guide that lets you walk through a collection of items (like a list, tuple, or string) one item at a time. It remembers where you are and gives you the next item when you ask for it.\n",
    "\n",
    "How it works:\n",
    "\n",
    "- iter() function: You first use the built-in iter() function to get an iterator object for your collection. This object knows how to navigate through the collection.\n",
    "- next() function: You then use the next() function to get the next item from the iterator. Each time you call next(), it moves to the next item and gives it to you.\n",
    "- StopIteration: When you reach the end of the collection, next() will raise a StopIteration exception, signaling that there are no more items.\n",
    "\n",
    "- Example:\n",
    "\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_iterator = iter(my_list)\n",
    "\n",
    "print(next(my_iterator))  # Output: 1\n",
    "print(next(my_iterator))  # Output: 2\n",
    "print(next(my_iterator))  # Output: 3\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "722b422c-6eef-46ab-8a6e-76d67cfcb835",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "# 6. Write a code that generates the squares of numbers from 1 to n using a generator\n",
    "\n",
    "def squares_generator(n):\n",
    "\n",
    "  for num in range(1, n + 1):\n",
    "    yield num * num\n",
    "\n",
    "for square in squares_generator(5):\n",
    "    \n",
    "  print(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cd4330c1-053b-49b1-89bc-b6e37ed346d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "11\n",
      "22\n",
      "33\n",
      "44\n"
     ]
    }
   ],
   "source": [
    "# 7. Write a code that generates palindromic numbers up to n using a generator\n",
    "\n",
    "def palindrome_generator(n):\n",
    " \n",
    "  for num in range(1, n + 1):\n",
    "    num_str = str(num)\n",
    "    if num_str == num_str[::-1]: \n",
    "      yield num\n",
    "    \n",
    "for palindrome in palindrome_generator(50):\n",
    "    \n",
    "  print(palindrome)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "59f8b725-cbdc-4279-8460-a7937114023c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# 8. Write a code that generates even numbers from 2 to n using a generator\n",
    "\n",
    "def even_generator(n):\n",
    " \n",
    "  for num in range(2, n + 1, 2):\n",
    "    yield num\n",
    "    \n",
    "for even_num in even_generator(10):\n",
    "    \n",
    "  print(even_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c7f3dc6f-4669-4ed5-b49d-6262f2100272",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# 9. Write a code that generates powers of two up to n using a generator\n",
    "\n",
    "def powers_of_two(max_power):\n",
    "\n",
    "  power = 0\n",
    "  while power <= max_power:\n",
    "    yield 2 ** power  \n",
    "    power += 1 \n",
    "\n",
    "for power in powers_of_two(4):\n",
    "    \n",
    "  print(power)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "91956e41-8a62-4a5f-b189-fa3d898e3299",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "# 10. Write a code that generates prime numbers up to n using a generator\n",
    "\n",
    "def prime_generator(n):\n",
    "\n",
    "  def is_prime(num):\n",
    "    \n",
    "    if num <= 1:\n",
    "      return False\n",
    "    for i in range(2, int(num**0.5) + 1):\n",
    "      if num % i == 0:\n",
    "        return False\n",
    "    return True\n",
    "\n",
    "  for num in range(2, n + 1):\n",
    "    if is_prime(num):\n",
    "      yield num\n",
    "\n",
    "for prime in prime_generator(20):\n",
    "    \n",
    "  print(prime) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d5f77ff1-1952-42ff-b5a0-3f72177565c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# 11. Write a code that uses a lambda function to calculate the sum of two numbers\n",
    "\n",
    "add_numbers = lambda x, y: x + y\n",
    "\n",
    "result = add_numbers(5, 3)\n",
    "\n",
    "print(result)  \n",
    "# Output: 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f59453cf-eddf-4f72-8f1d-d2183c7808bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "# 12. Write a code that uses a lambda function to calculate the square of a given number\n",
    "\n",
    "square = lambda x: x * x\n",
    "\n",
    "result = square(5)\n",
    "\n",
    "print(result) \n",
    "\n",
    "# Output: 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6f79921c-7765-4796-8639-0ae8387d8c5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 is odd\n"
     ]
    }
   ],
   "source": [
    "# 13. Write a code that uses a lambda function to check whether a given number is even or odd\n",
    "\n",
    "is_even = lambda x: x % 2 == 0\n",
    "\n",
    "number = 7\n",
    "result = is_even(number)\n",
    "\n",
    "if result:\n",
    " print(f\"{number} is even\")\n",
    "else:\n",
    " print(f\"{number} is odd\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e021d6a3-c02d-4efa-a563-5eee6b3a1d38",
   "metadata": {},
   "source": [
    "# Question number : 14 is missing in Oops PDF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "00f36e00-d4a5-4c83-be07-d046a50647c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PW-Skills\n"
     ]
    }
   ],
   "source": [
    "# 15. # 15. Write a code that uses a lambda function to concatenate two strings\n",
    "\n",
    "combine_strings = lambda x, y: x + y\n",
    "\n",
    "string1 = \"PW\"\n",
    "string2 = \"-Skills\"\n",
    "\n",
    "result = combine_strings(string1, string2)\n",
    "\n",
    "print(result)  \n",
    "\n",
    "# Output: PW-Skills"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "589af90c-9dc2-4479-92b2-9d0d97c80a0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "# 16. Write a code that uses a lambda function to find the maximum of three given numbers\n",
    "\n",
    "find_max = lambda x, y, z: max(x, y, z)\n",
    "\n",
    "result = find_max(5, 2, 9)\n",
    "print(result)  \n",
    "\n",
    "# Output: 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "8d275234-c4a6-4054-b99f-1b79d9fa2deb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64, 100]\n"
     ]
    }
   ],
   "source": [
    "# 17. Write a code that generates the squares of even numbers from a given list\n",
    "\n",
    "def square_even_numbers(numbers):\n",
    " \n",
    "  squares = []\n",
    "  for num in numbers:\n",
    "    if num % 2 == 0:\n",
    "      squares.append(num * num)\n",
    "  return squares\n",
    "\n",
    "numbers_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "result = square_even_numbers(numbers_list)\n",
    "print(result) \n",
    "\n",
    "# Output: [4, 16, 36, 64, 100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d118cf60-7842-4c64-ab62-46e30c465322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n"
     ]
    }
   ],
   "source": [
    "# 18. Write a code that calculates the product of positive numbers from a given list\n",
    "\n",
    "def product_of_positives(numbers):\n",
    " \n",
    "  product = 1\n",
    "  for num in numbers:\n",
    "    if num > 0:\n",
    "      product *= num\n",
    "  return product\n",
    "\n",
    "numbers_list = [-2, 1, 0, 4, -3, 6]\n",
    "result = product_of_positives(numbers_list)\n",
    "print(result)  \n",
    "\n",
    "# Output: 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "baafd5fb-e8c7-4f86-b815-5399db743d94",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 6, 4, 10, 6, 14, 8, 18, 10]\n"
     ]
    }
   ],
   "source": [
    "# 19. Write a code that doubles the values of odd numbers from a given list\n",
    "\n",
    "def double_odd_numbers(numbers):\n",
    "  \n",
    "  doubled = []\n",
    "  for num in numbers:\n",
    "    if num % 2 != 0: \n",
    "      doubled.append(num * 2)\n",
    "    else:\n",
    "      doubled.append(num)  \n",
    "  return doubled\n",
    "\n",
    "numbers_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "result = double_odd_numbers(numbers_list)\n",
    "print(result) \n",
    "\n",
    "# Output: [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "11042985-1dab-4aa6-a5a2-db936efba31d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "225\n"
     ]
    }
   ],
   "source": [
    "# 20. Write a code that calculates the sum of cubes of numbers from a given list\n",
    "\n",
    "def sum_of_cubes(numbers):\n",
    " \n",
    "  cube_sum = 0\n",
    "  for num in numbers:\n",
    "    cube_sum += num ** 3  \n",
    "  return cube_sum\n",
    "\n",
    "numbers_list = [1, 2, 3, 4, 5]\n",
    "result = sum_of_cubes(numbers_list)\n",
    "print(result) \n",
    "\n",
    "# Output: 225"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dbbc04c0-dc3d-4046-b627-e345f4490961",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "# 21. Write a code that filters out prime numbers from a given list\n",
    "\n",
    "def filter_primes(numbers):\n",
    " \n",
    "  def is_prime(num):\n",
    "    if num <= 1:\n",
    "      return False\n",
    "    for i in range(2, int(num**0.5) + 1):\n",
    "      if num % i == 0:\n",
    "        return False\n",
    "    return True\n",
    "\n",
    "  primes = [num for num in numbers if is_prime(num)]\n",
    "  return primes\n",
    "\n",
    "numbers_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "primes = filter_primes(numbers_list)\n",
    "print(primes) \n",
    "\n",
    "# Output: [2, 3, 5, 7]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "804701f0-df95-4e11-a553-60f3ec1823af",
   "metadata": {},
   "source": [
    "# Questions 22 to 26 are repeated questions => Question : 11 to 16 are same \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85fe97f5-0d19-4a40-a186-c4ae0d6ab380",
   "metadata": {},
   "source": [
    "# 27. What is encapsulation in OOP?\n",
    "\n",
    "Encapsulation in OOP is like putting a protective shield around data and methods within a class, controlling access and preventing misuse. It's about data hiding and using methods as the only way to interact with the data.\n",
    "\n",
    "- Benefits: Data protection, modularity, flexibility, and reusability."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3388f686-d4bc-48c4-a4d2-9fd89f93ddbd",
   "metadata": {},
   "source": [
    "# 28. Explain the use of access modifiers in Python classes\n",
    "\n",
    "Access Modifiers in Python: A Convention for Organization\n",
    "While Python doesn't have strict access modifiers like some other languages (e.g., private or public), it uses a convention to indicate the intended level of access for attributes and methods within a class:\n",
    "\n",
    " # 1. Public:\n",
    "No prefix: By default, attributes and methods are considered public. This means they can be accessed from anywhere, both inside and outside the class.\n",
    "- Example:\n",
    "\n",
    "class MyClass:\n",
    "    def __init__(self, data):\n",
    "        self.data = data  # Public attribute\n",
    "\n",
    "    def get_data(self):\n",
    "        return self.data  # Public method\n",
    "\n",
    " # 2. Protected:\n",
    "Single underscore prefix (_): This indicates that an attribute or method is intended for internal use within the class and its subclasses. It's a convention, not a strict rule, so external code can still access it, but it's a signal that it shouldn't be modified directly.\n",
    "- Example:\n",
    "\n",
    "class MyClass:\n",
    "    def __init__(self, data):\n",
    "        self._data = data  # Protected attribute\n",
    "\n",
    "    def _process_data(self):\n",
    "        # Internal processing\n",
    "        pass\n",
    "\n",
    " # 3. Private:\n",
    "Double underscore prefix (__): This triggers name mangling, which makes it harder to access the attribute or method from outside the class. It's not truly private, but it discourages direct access.\n",
    "- Example:\n",
    "\n",
    "class MyClass:\n",
    "    def __init__(self, data):\n",
    "        self.__data = data  # Private attribute\n",
    "\n",
    "    def get_data(self):\n",
    "        return self.__data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a39c20f-575b-433b-8947-62564973818b",
   "metadata": {},
   "source": [
    "# 29. What is inheritance in OOP\n",
    "\n",
    "# Inheritance: Building on Existing Foundations\n",
    "Inheritance is a powerful mechanism in Object-Oriented Programming (OOP) that allows you to create new classes (child classes or subclasses) that inherit properties and behavior from existing classes (parent classes or superclasses). It's like building new houses based on a pre-existing blueprint, but with the ability to add your own custom features.\n",
    "# Key Concepts:\n",
    "- Parent Class (Superclass): The existing class from which the child class inherits.\n",
    "- Child Class (Subclass): The new class that inherits from the parent class.\n",
    "- Inheritance: The process of acquiring properties and behavior from the parent class.\n",
    "# Benefits of Inheritance:\n",
    "- Code Reusability: Avoid rewriting code by inheriting functionality from parent classes.\n",
    "- Extensibility: Easily extend existing functionality by adding new features to child classes.\n",
    "- Hierarchy and Organization: Create a structured hierarchy of classes, making code easier to understand and maintain.\n",
    "- Polymorphism: Allows objects of different classes to be treated as objects of a common parent class, enabling flexible and dynamic interactions.\n",
    "\n",
    "# Types of Inheritance:\n",
    "- Single Inheritance: A child class inherits from only one parent class.\n",
    "- Multiple Inheritance: A child class inherits from multiple parent classes. (This can get complex and is not supported in all OOP languages.)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "487caf88-3680-41a9-ab66-1bef6cb526cd",
   "metadata": {},
   "source": [
    "# 30. Define polymorphism in OOP \n",
    "\n",
    "## Polymorphism: Many Forms, One Interface\n",
    "- Polymorphism, meaning \"many forms,\" is a core principle in OOP that allows objects of different classes to be treated as objects of a common superclass. It's like having different types of shapes (circle, square, triangle) that can all be treated as \"shapes\" and respond to the same actions (e.g., calculate_area()) in their own unique ways.\n",
    "## Key Concepts:\n",
    "- Inheritance: Polymorphism typically relies on inheritance. Child classes inherit methods from a parent class and can provide their own implementations.\n",
    "- Method Overriding: Child classes can redefine (override) methods inherited from the parent class to implement specific behavior.\n",
    "- Dynamic Binding: The actual method that gets called is determined at runtime based on the object's type, not the variable's type.\n",
    "## Benefits of Polymorphism:\n",
    "- Flexibility: Write code that can work with objects of different classes without needing to know their specific types.\n",
    "- Extensibility: Easily add new classes without changing existing code that uses polymorphism.\n",
    "- Code Reusability: Reduce code duplication by using common interfaces for different objects.\n",
    "## Types of Polymorphism:\n",
    "- Method Overriding\n",
    "- Method Overloading (Not available in Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7332393-ebf1-4e6a-a167-ff69bef5b2f6",
   "metadata": {},
   "source": [
    "# 31. Explain method overriding in Python\n",
    "\n",
    "In Python, method overriding lets a child class provide its own version of a method that already exists in its parent class. This allows for more specific and customized behavior in the child class.\n",
    "- **Key points:**\n",
    "Child class method must have the same name and parameters as the parent method.\n",
    "Child's version is used when called on a child class object.\n",
    "Access parent version using super().\n",
    "- **Benefit:** Adapts parent behavior for specific child needs and promotes code reusability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "08fd0ec7-cf8f-419d-b2de-75228e1a062b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 32. Explain method overriding in Python Define a parent class Animal with a method make_sound that prints \"Generic animal sound\". Create a child class Dog inheriting from Animal with a method make_sound that prints \"Woof!\"\n",
    "\n",
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "821606c2-c2cd-4761-9cfd-4c3269b6fbde",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 33. Define a method move in the Animal class that prints \"Animal moves\". Override the move method in the Dog class to print \"Dog runs.\n",
    "\n",
    "class Animal:\n",
    "    def make_sound(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "    def move(self):\n",
    "        print(\"Animal moves\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "    def move(self):\n",
    "        print(\"Dog runs\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3504bbe0-b838-4efc-9d7d-a5fcce991419",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 34. Create a class Mammal with a method reproduce that prints \"Giving birth to live young.\" Create a class DogMammal inheriting from both Dog and Mammal\n",
    "\n",
    "class Mammal:\n",
    "    def reproduce(self):\n",
    "        print(\"Giving birth to live young.\")\n",
    "\n",
    "class DogMammal(Dog, Mammal):  # Inheriting from Dog and Mammal\n",
    "    pass "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f678d301-35bb-44dd-8b2b-a68b71b96653",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 35. Create a class GermanShepherd inheriting from Dog and override the make_sound method to print \"Bark!\n",
    "\n",
    "class GermanShepherd(Dog):\n",
    "    def make_sound(self):\n",
    "        print(\"Bark!\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "692ad8e0-80f0-48d3-9e2a-402a516c2b9f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 36. Define constructors in both the Animal and Dog classes with different initialization parameters\n",
    "\n",
    "class Animal:\n",
    "    def __init__(self, age):\n",
    "        self.age = age\n",
    "\n",
    "    def make_sound(self):\n",
    "        print(\"Generic animal sound\")\n",
    "\n",
    "    def move(self):\n",
    "        print(\"Animal moves\")\n",
    "\n",
    "class Dog(Animal):\n",
    "    def __init__(self, age, breed):\n",
    "        super().__init__(age) \n",
    "        self.breed = breed\n",
    "\n",
    "    def make_sound(self):\n",
    "        print(\"Woof!\")\n",
    "\n",
    "    def move(self):\n",
    "        print(\"Dog runs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54b6bdd6-738f-4a6a-a731-c86f3263f3f5",
   "metadata": {},
   "source": [
    "# 37. What is abstraction in Python? How is it implemented\n",
    "\n",
    "## Abstraction in Python: Hiding the Complexity\n",
    "Abstraction is a core principle of object-oriented programming (OOP) that focuses on exposing only essential information about an object while hiding its internal implementation details. This simplifies interactions with the object and makes the code easier to understand, maintain, and modify.\n",
    "\n",
    "### Implementation in Python:\n",
    "Python provides two primary ways to achieve abstraction:\n",
    "1. **Classes and Objects:**\n",
    "Classes act as blueprints for creating objects. They encapsulate data (attributes) and behavior (methods) together.\n",
    "Objects are instances of classes. They hide their internal data and implementation, exposing only the necessary methods to interact with them.\n",
    "\n",
    "2. **Abstract Base Classes (ABCs):**\n",
    "ABCs define a common interface for a group of subclasses. They specify methods that subclasses must implement.\n",
    "This ensures consistency and enforces a specific behavior across different classes.\n",
    "\n",
    "### Benefits of Abstraction:\n",
    "- **Simplified Complexity:** Focus on what an object does, not how it does it.\n",
    "- **Increased Maintainability:** Changes to internal implementation don't affect external usage.\n",
    "- **Enhanced Code Reusability:** Abstract classes define common interfaces for related classes.\n",
    "- **Improved Modularity:** Separates design from implementation, making code easier to manage."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e0de609-da14-4477-bb70-e2dc665688f8",
   "metadata": {},
   "source": [
    "# 38. Explain the importance of abstraction in object-oriented programming\n",
    "\n",
    "Abstraction is a cornerstone of object-oriented programming (OOP) for several crucial reasons:\n",
    "## 1. Managing Complexity:\n",
    "- Simplified Interactions: By hiding internal details, abstraction allows developers to focus on how to use an object rather than how it works internally. This makes code easier to understand, write, and maintain.\n",
    "- Reduced Cognitive Load: Dealing with fewer details at once improves developer productivity and reduces errors.\n",
    "## 2. Code Reusability and Modularity:\n",
    "- Abstract Classes and Interfaces: Promote code reuse by defining a common blueprint for related classes. Subclasses inherit and implement specific behavior, ensuring consistency and flexibility.\n",
    "- Modular Design: Separation of concerns allows for independent development and testing of different parts of the system.\n",
    "## 3. Easier Maintenance and Evolution:\n",
    "- Changes Isolated: Modifications to internal implementation details don't affect external usage, as long as the public interface remains the same.\n",
    "- Flexible Design: Abstraction allows for easier adaptation to changing requirements and future extensions.\n",
    "## 4. Real-World Modeling:\n",
    "- Focus on Essential Characteristics: Abstraction helps represent real-world entities by capturing their key attributes and behaviors, ignoring irrelevant details.\n",
    "- Improved Conceptual Understanding: Promotes a clear and concise understanding of the problem domain.\n",
    "## 5. Encapsulation and Data Protection:\n",
    "- Information Hiding: By hiding internal data, abstraction prevents accidental or malicious modification, ensuring data integrity.\n",
    "- Controlled Access: Methods provide a controlled way to interact with data, preventing invalid states and inconsistencies."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "574b4a38-6d54-4663-86f7-abafadd8ef2c",
   "metadata": {},
   "source": [
    "# 39. ow are abstract methods different from regular methods in Python\n",
    "\n",
    "## Abstract vs. Regular Methods in Python: A Key Distinction\n",
    "While both play roles in defining class behavior, abstract methods and regular methods have a fundamental difference:\n",
    "## Regular Methods:\n",
    "- Provide implementation: They contain the actual code that executes when the method is called.\n",
    "- Found in any class: Can be part of any class, abstract or concrete (non-abstract).\n",
    "- Example:\n",
    "\n",
    "class Dog:\n",
    "\n",
    "    def bark(self):\n",
    "        \n",
    "        print(\"Woof!\")\n",
    "\n",
    "## Abstract Methods:\n",
    "Define an interface, not implementation: They declare the method signature (name, parameters) but do not provide a body.\n",
    "- Found in Abstract Base Classes (ABCs): Only exist within classes that inherit from ABC.\n",
    "- Force subclass implementation: Subclasses must provide concrete implementations for all inherited abstract methods.\n",
    "- Example:\n",
    "\n",
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Animal(ABC):\n",
    "\n",
    "    @abstractmethod\n",
    "    \n",
    "    def make_sound(self):\n",
    "    \n",
    "        pass  # No implementation here\n",
    "\n",
    "class Dog(Animal):\n",
    "\n",
    "    def make_sound(self):\n",
    "    \n",
    "        print(\"Woof!\") \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5520eb90-9947-4778-ac5a-11b647532cab",
   "metadata": {},
   "source": [
    "# 40. How can you achieve abstraction using interfaces in Python\n",
    "\n",
    "## Use Abstract Base Classes (ABCs):\n",
    "- **Inherit from abc.ABC:** Create a base class that acts as the interface.\n",
    "- **Mark methods with @abstractmethod:** Define method signatures without implementations.\n",
    "- **Subclasses must implement:** Concrete classes inherit and provide implementations for abstract methods.\n",
    "This enforces a common structure and promotes code consistency across different classes."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fec46ff5-713a-4e17-968b-b47c57b354ea",
   "metadata": {},
   "source": [
    "# 41. Can you provide an example of how abstraction can be utilized to create a common interface for a group a of related classes in Python?\n",
    "\n",
    "**Scenario:** We want a common way to handle different file formats (CSV, JSON, XML) for data processing.\n",
    "### Solution:\n",
    "- **Abstract Class DataFile:**\n",
    "Defines abstract methods like read_data and write_data.\n",
    "- **Concrete Classes:**\n",
    "CSVFile, JSONFile, XMLFile inherit from DataFile.\n",
    "Each implements the abstract methods specific to their format.\n",
    "- **Usage:**\n",
    "We can process data without worrying about the specific file type:\n",
    "\n",
    "def process_data(file_obj):\n",
    "\n",
    "    data = file_obj.read_data()\n",
    "    # ... process data ...\n",
    "    file_obj.write_data(data)\n",
    "\n",
    "file = JSONFile(\"data.json\")  # Could be CSVFile, XMLFile, etc.\n",
    "process_data(file)\n",
    "\n",
    "- **Benefit:**\n",
    "Abstraction allows us to handle different file formats uniformly through a common interface, promoting flexibility and code reuse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a663fe04-784d-4e89-a0b0-7eabf073313f",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 42. How does Python achieve polymorphism through method overriding?\n",
    "\n",
    "In Python, polymorphism is achieved when subclasses provide their own implementations of methods inherited from a parent class. This allows objects of different classes to respond to the same method call in their own way.\n",
    "**Example:**\n",
    "- Base class Animal has a method make_sound().\n",
    "- Subclasses Dog and Cat override make_sound() to produce specific sounds (bark/meow).\n",
    "\n",
    "When calling make_sound() on an animal object, Python determines the object's actual class at runtime and executes the appropriate overridden method, leading to polymorphic behavior."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "114ed6b0-fee2-4d72-9731-7d0275e6052c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 43. Define a base class with a method and a subclass that overrides the method.\n",
    "\n",
    "class Animal:  # Base class\n",
    "    def speak(self):\n",
    "        print(\"Generic animal sound\")\n",
    "class Dog(Animal):  # Subclass\n",
    "    def speak(self):\n",
    "        print(\"Woof!\")  # Overrides the base class method\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "08773b6f-eff3-4600-877b-79de272a96f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a Circle.\n",
      "Area: 78.53975\n",
      "Perimeter: 31.4159\n",
      "--------------------\n",
      "I am a Square.\n",
      "Area: 16\n",
      "Perimeter: 16\n",
      "--------------------\n"
     ]
    }
   ],
   "source": [
    "# 44. Define a base class and multiple subclasses with overridden methods.\n",
    "\n",
    "class Shape:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    def area(self):\n",
    "        pass  # Abstract method - needs to be implemented in subclasses\n",
    "    def perimeter(self):\n",
    "        pass  # Abstract method - needs to be implemented in subclasses\n",
    "    def describe(self):\n",
    "        print(f\"I am a {self.name}.\")\n",
    "        \n",
    "class Circle(Shape):\n",
    "    def __init__(self, radius):\n",
    "        super().__init__(\"Circle\")\n",
    "        self.radius = radius\n",
    "    def area(self):\n",
    "        return 3.14159 * self.radius * self.radius\n",
    "    def perimeter(self):\n",
    "        return 2 * 3.14159 * self.radius\n",
    "    \n",
    "class Square(Shape):\n",
    "    def __init__(self, side):\n",
    "        super().__init__(\"Square\")\n",
    "        self.side = side\n",
    "    def area(self):\n",
    "        return self.side * self.side\n",
    "    def perimeter(self):\n",
    "        return 4 * self.side\n",
    "\n",
    "shapes = [Circle(5), Square(4)]\n",
    "\n",
    "for shape in shapes:\n",
    "    shape.describe()\n",
    "    \n",
    "    print(\"Area:\", shape.area())\n",
    "    print(\"Perimeter:\", shape.perimeter())\n",
    "    print(\"-\" * 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41e2d513-0fd2-411f-9d14-740ef00e9f02",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 45. How does polymorphism improve code readability and reusability?\n",
    "\n",
    "Polymorphism significantly enhances both code readability and reusability in several ways:\n",
    "\n",
    "### Improved Readability:\n",
    "- **Abstraction:** Polymorphism encourages focusing on what objects can do (their interface) rather than how they do it (implementation details). This makes code easier to understand at a higher level.\n",
    "- **Consistency:** With polymorphism, you can use the same method name (e.g., area()) for different objects, even if the underlying calculations differ. This creates a consistent interface and reduces cognitive load for the reader.\n",
    "- **Intent Clarity:** Code becomes more expressive as it directly reflects the intent (e.g., shape.area() clearly conveys the goal of calculating the area of a shape).\n",
    "### Enhanced Reusability:\n",
    "- **Base Class as Foundation:** Common code and functionality are placed in the base class, avoiding duplication in subclasses. This promotes code reuse and reduces maintenance effort.\n",
    "- **Flexibility with Subclasses:** New subclasses can be added easily without modifying existing code. They inherit the base functionality and can override methods as needed.\n",
    "- **Generic Programming:** Polymorphic functions or methods can work with objects of different types through a common interface, leading to more versatile and reusable code.\n",
    "\n",
    "**Example:**\n",
    "\n",
    "def total_area(shapes):\n",
    "\n",
    "    total = 0\n",
    "    for shape in shapes:\n",
    "        total += shape.area()  # Polymorphism in action!\n",
    "    return total"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "860aee3e-50f5-4d6c-9c3a-c59fa6abd79d",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 46. Describe how Python supports polymorphism with duck typing\n",
    "\n",
    "Python's support for duck typing plays a key role in enabling polymorphism, promoting flexibility and code reusability.\n",
    "\n",
    "**Duck Typing Principle:**\n",
    "\n",
    "\"If it walks like a duck and quacks like a duck, then it must be a duck.\"\n",
    "\n",
    "In simpler terms, duck typing focuses on an object's behavior (what it can do) rather than its specific type. If an object has the necessary methods or attributes to fulfill a task, it can be used for that purpose, regardless of its class hierarchy.\n",
    "\n",
    "### Polymorphism with Duck Typing:\n",
    "- No Explicit Interface: Unlike traditional object-oriented languages, Python doesn't require defining explicit interfaces or abstract classes to achieve polymorphism.\n",
    "- Focus on Behavior: Functions or methods are written to expect objects that exhibit certain behaviors (e.g., having a read() method).\n",
    "- Dynamic Type Checking: Python checks for the presence of required methods or attributes at runtime, not during compile time. This allows objects of different classes to be used interchangeably as long as they provide the necessary behavior.\n",
    "\n",
    "### Benefits of Duck Typing:\n",
    "\n",
    "- Flexibility: Allows using objects of different classes that fulfill the required behavior without being related through inheritance.\n",
    "- Loose Coupling: Reduces dependencies between components, making code more adaptable to changes.\n",
    "- Dynamic Nature: Encourages focusing on behavior and promotes a more pragmatic approach to programming.\n",
    "\n",
    "However, duck typing can also lead to runtime errors if an object doesn't have the expected methods or attributes. It's essential to ensure that objects used in a polymorphic way fulfill the necessary behavior to avoid unexpected issues."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "916408d9-6e3f-425e-95b1-d1faf4d9f020",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 47.How do you achieve encapsulation in Python?\n",
    "\n",
    "Encapsulation in Python\n",
    "Encapsulation, a fundamental concept in object-oriented programming, involves bundling data (attributes) and methods that operate on that data within a single unit (class). This helps protect data integrity and promotes modularity.\n",
    "\n",
    "**Python achieves encapsulation through:**\n",
    "\n",
    "**1. Attributes (Data):**\n",
    "- Public Attributes: Directly accessible from anywhere using the dot notation (e.g., object.attribute).\n",
    "- Protected Attributes: Prefixed with an underscore (_attribute) to indicate they are intended for internal use within the class and its subclasses. Access from outside the class is discouraged but still possible.\n",
    "- Private Attributes: Prefixed with double underscores (__attribute). Python performs name mangling, making them difficult to access directly from outside the class. This enforces stricter access control.\n",
    "\n",
    "**2. Methods (Behavior):**\n",
    "- Public Methods: Can be called from anywhere, providing the primary interface to interact with the object.\n",
    "- Protected Methods: Similar to protected attributes, intended for internal use but can be accessed from subclasses.\n",
    "- Private Methods: Name mangling applies here as well, restricting access to within the class.\n",
    "- Properties: Provide a controlled way to access and modify attributes. They allow defining getter, setter, and deleter methods to manage attribute access:\n",
    "\n",
    "class MyClass:\n",
    "\n",
    "    def __init__(self):\n",
    "        self._hidden_value = 0  # \"Protected\" attribute\n",
    "    @property\n",
    "    def value(self):\n",
    "        return self._hidden_value\n",
    "    @value.setter\n",
    "    def value(self, new_value):\n",
    "        self._hidden_value = new_value\n",
    "        \n",
    "**Benefits of Encapsulation:**\n",
    "- Data Protection: Prevents accidental modification of internal data, ensuring data integrity and consistency.\n",
    "- Modularity: Classes become self-contained units, making code easier to maintain and understand.\n",
    "- Flexibility: Implementation details can be changed without affecting external code, as long as the public interface remains consistent.\n",
    "\n",
    "It's important to note that Python's encapsulation is based on convention rather than strict enforcement. While private attributes and methods are made harder to access, they can still be accessed with some effort. The emphasis is on guiding developers towards proper usage and maintaining code organization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b9fd437-5553-45f3-90e0-a2e988f248f7",
   "metadata": {},
   "source": [
    "# 48. Can encapsulation be bypassed in Python? If so, how ?\n",
    "\n",
    "Yes, Python's encapsulation can be bypassed, primarily by directly accessing name-mangled attributes using the _ClassName__AttributeName syntax. However, this practice is discouraged as it goes against the intended design and can lead to code fragility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d05c568c-8b3b-4baf-8677-01cb4059c8bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 49. Implement a class BankAccount with a private balance attribute. Include methods to deposit, withdraw, and check the balance\n",
    "\n",
    "class BankAccount:\n",
    "    def __init__(self, initial_balance=0):\n",
    "        self.__balance = initial_balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        if amount > 0:\n",
    "            self.__balance += amount\n",
    "        else:\n",
    "            raise ValueError(\"Deposit amount must be positive\")\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        if 0 < amount <= self.__balance:\n",
    "            self.__balance -= amount\n",
    "        else:\n",
    "            raise ValueError(\"Withdrawal amount must be positive and not exceed balance\")\n",
    "\n",
    "    def get_balance(self):\n",
    "        return self.__balance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "acd85da4-eed8-4b33-b955-e26136f9eb9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 50. Develop a Person class with private attributes name and email, and methods to set and get the email\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, email):\n",
    "        self.__name = name\n",
    "        self.__email = email\n",
    "\n",
    "    def get_email(self):\n",
    "        return self.__email\n",
    "\n",
    "    def set_email(self, new_email):\n",
    "        # Add email validation if needed\n",
    "        self.__email = new_email\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75aae0d4-c1ce-4678-ad99-f7534fc104ed",
   "metadata": {},
   "source": [
    "# 51. Why is encapsulation considered a pillar of object-oriented programming (OOP)?\n",
    "\n",
    "## Encapsulation: A Cornerstone of OOP\n",
    "\n",
    "Encapsulation is a fundamental principle of object-oriented programming (OOP) and is often considered one of its core pillars due to several key reasons:\n",
    "\n",
    "**1. Data Protection:**\n",
    "Encapsulation safeguards an object's internal state (data) from unauthorized access and modification. By making attributes private, we restrict direct manipulation from outside the object, preventing accidental corruption and ensuring data integrity.\n",
    "\n",
    "**2. Increased Code Maintainability:**\n",
    "Encapsulation promotes modularity and separation of concerns. By hiding internal implementation details, we can modify an object's internal structure without affecting other parts of the program, as long as the public interface remains consistent. This simplifies maintenance and evolution of the codebase.\n",
    "\n",
    "**3. Controlled Access:**\n",
    "Encapsulation allows us to control how data is accessed and modified through methods (getters and setters). This enables us to enforce constraints, perform validation, and implement additional logic before changing an object's state.\n",
    "\n",
    "**4. Abstraction and Information Hiding:**\n",
    "Encapsulation facilitates abstraction by hiding the complexity of an object's internal workings. Users of the object only need to understand its public interface (methods and properties) without worrying about the underlying implementation details. This simplifies interaction with the object and reduces cognitive load.\n",
    "\n",
    "**5. Reusability and Flexibility:**\n",
    "Well-encapsulated objects are easier to reuse in different parts of a program or even across different projects. The clear separation between internal implementation and external interface makes them more adaptable and flexible to changing requirements.\n",
    "\n",
    "**In summary, encapsulation enhances data protection, improves code maintainability, provides controlled access, facilitates abstraction, and promotes reusability, making it a crucial aspect of building robust and well-structured object-oriented programs.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c99b94a4-22ec-40c5-9b42-7bfc6afbf8d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before function execution\n",
      "Hello, Ram!\n",
      "After function execution\n"
     ]
    }
   ],
   "source": [
    "# 52. Create a decorator in Python that adds functionality to a simple function by printing a message before and after the function execution\n",
    "\n",
    "def my_decorator(func):\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(\"Before function execution\")\n",
    "        result = func(*args, **kwargs)\n",
    "        print(\"After function execution\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "# How to Use the Decorator:\n",
    "    \n",
    "@my_decorator\n",
    "\n",
    "def say_hello(name):           \n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "say_hello(\"Ram\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "be50dfab-c790-4c02-95e8-94ea88032dd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting executing say_hello\n",
      "Hello, Sumit!\n",
      "Finished executing say_hello\n"
     ]
    }
   ],
   "source": [
    "# 53. Modify the decorator to accept arguments and print the function name along with the message\n",
    "\n",
    "def my_decorator(before_msg=\"Before\", after_msg=\"After\"):\n",
    "    def decorator(func):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            print(f\"{before_msg} executing {func.__name__}\")\n",
    "            result = func(*args, **kwargs)\n",
    "            print(f\"{after_msg} executing {func.__name__}\")\n",
    "            return result\n",
    "        return wrapper\n",
    "    return decorator\n",
    "\n",
    "# How to Use (with arguments):\n",
    "\n",
    "@my_decorator(before_msg=\"Starting\", after_msg=\"Finished\")\n",
    "def say_hello(name):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "say_hello(\"Sumit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1a314df1-89c4-475f-996f-df7598468bd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 54. Create two decorators, and apply them to a single function. Ensure that they execute in the order they are applied\n",
    "\n",
    "def decorator1(func):\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(\"Decorator 1: Before\")\n",
    "        result = func(*args, **kwargs)\n",
    "        print(\"Decorator 1: After\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "def decorator2(func):\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(\"Decorator 2: Before\")\n",
    "        result = func(*args, **kwargs)\n",
    "        print(\"Decorator 2: After\")\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "@decorator1\n",
    "@decorator2\n",
    "\n",
    "def say_hi():\n",
    "    \n",
    "    print(\"Hello World!\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "183057e9-a01d-44fa-813c-b6569e819a72",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decorator 1: Before\n",
      "Decorator 2: Before\n",
      "Hello World!\n",
      "Decorator 2: After\n",
      "Decorator 1: After\n"
     ]
    }
   ],
   "source": [
    "say_hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2969df96-eb6f-4415-8229-ee100020cde6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before function execution\n",
      "Hello, Sumit!\n",
      "After function execution\n",
      "Before function execution\n",
      "Hi, Dev!\n",
      "After function execution\n"
     ]
    }
   ],
   "source": [
    "# 55. Modify the decorator to accept and pasdef my_decorator(func):\n",
    "\n",
    "def my_decorator(func):\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        \n",
    "        print(\"Before function execution\")\n",
    "        result = func(*args, **kwargs)  \n",
    "        print(\"After function execution\")\n",
    "        return result\n",
    "    \n",
    "    return wrapper\n",
    "\n",
    "@my_decorator\n",
    "\n",
    "def greet(name, greeting=\"Hello\"):\n",
    "    print(f\"{greeting}, {name}!\")\n",
    "\n",
    "greet(\"Sumit\")         \n",
    "greet(\"Dev\", \"Hi\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "de65dd8c-e046-4b20-81d0-ace99db107df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function my_function in module __main__:\n",
      "\n",
      "my_function(x, y)\n",
      "    This function adds two numbers.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 56. Create a decorator that preserves the metadata of the original function\n",
    "\n",
    "import functools\n",
    "\n",
    "def preserve_metadata(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper(*args, **kwargs):\n",
    "        # Do something before\n",
    "        result = func(*args, **kwargs)\n",
    "        # Do something after\n",
    "        return result\n",
    "    return wrapper\n",
    "\n",
    "@preserve_metadata\n",
    "def my_function(x, y):\n",
    "    \"\"\"This function adds two numbers.\"\"\"\n",
    "    return x + y\n",
    "\n",
    "help(my_function)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9f6600a7-70a7-49a2-a011-ea86210f95b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "# 57. Create a Python class `Calculator` with a static method `add` that takes in two numbers and returns their sum\n",
    "\n",
    "class Calculator:\n",
    "    @staticmethod\n",
    "    def add(x, y):\n",
    "        return x + y\n",
    "\n",
    "result = Calculator.add(5, 3)  \n",
    "print(result) \n",
    "\n",
    "# Output: 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "edc7ba3f-5f25-4187-aac1-88cd1647f40c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "# 58. Create a Python class `Employee` with a class `method get_employee_count` that returns the total number of employees created\n",
    "\n",
    "class Employee:\n",
    "    employee_count = 0\n",
    "\n",
    "    def __init__(self, name, department):\n",
    "        self.name = name\n",
    "        self.department = department\n",
    "        Employee.employee_count += 1\n",
    "\n",
    "    @classmethod\n",
    "    def get_employee_count(cls):\n",
    "        return cls.employee_count\n",
    "    \n",
    "emp1 = Employee(\"Alice\", \"IT\")\n",
    "emp2 = Employee(\"Bob\", \"HR\")\n",
    "\n",
    "total_employees = Employee.get_employee_count()\n",
    "print(total_employees)  \n",
    "\n",
    "# Output: 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "5983c4f7-9e20-46f4-bd30-0339bb0bc396",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olleH\n"
     ]
    }
   ],
   "source": [
    "# 59. Create a Python class `StringFormatter` with a static method `reverse_string` that takes a string as input and returns its reverse\n",
    "\n",
    "class StringFormatter:\n",
    "    \n",
    "    @staticmethod\n",
    "    def reverse_string(text):\n",
    "        return text[::-1]\n",
    "    \n",
    "reversed_text = StringFormatter.reverse_string(\"Hello\")\n",
    "print(reversed_text) \n",
    "\n",
    "# Output: olleH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "007599a3-ed73-41d8-acf7-5c2978f03a25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.53981633974483\n"
     ]
    }
   ],
   "source": [
    "# 60. Create a Python class `Circle` with a class method `calculate_area` that calculates the area of a circle given its radius\n",
    "\n",
    "import math\n",
    "\n",
    "class Circle:\n",
    "    @classmethod\n",
    "    def calculate_area(cls, radius):\n",
    "        return math.pi * (radius ** 2)\n",
    "\n",
    "area = Circle.calculate_area(5)\n",
    "print(area) \n",
    "\n",
    "# Output: 78.53981633974483 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "dcab7e0a-24fe-4c94-8c88-68e786ed144c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77.0\n"
     ]
    }
   ],
   "source": [
    "# 61. Create a Python class `TemperatureConverter` with a static method `celsius_to_fahrenheit` that converts Celsius to Fahrenheit\n",
    "\n",
    "class TemperatureConverter:\n",
    "    @staticmethod\n",
    "    def celsius_to_fahrenheit(celsius):\n",
    "        return (celsius * 9/5) + 32\n",
    "\n",
    "# Usage\n",
    "fahrenheit = TemperatureConverter.celsius_to_fahrenheit(25)\n",
    "print(fahrenheit)  \n",
    "\n",
    "# Output: 77.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "826496ec-8827-4055-8155-e4a20fcd1cdd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Lord of the Rings by J.R.R. Tolkien\n"
     ]
    }
   ],
   "source": [
    "# 62. What is the purpose of the __str__() method in Python classes? Provide an example\n",
    "\n",
    "\"\"\" __str__(): Object to String Conversion\n",
    "\n",
    "The __str__() method in Python classes defines how an object is represented as a string when printed or used in string formatting. It provides a human-readable representation of the object's state.\"\"\"\n",
    "\n",
    "\n",
    "class Book:\n",
    "    def __init__(self, title, author):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.title} by {self.author}\"\n",
    "\n",
    "book = Book(\"The Lord of the Rings\", \"J.R.R. Tolkien\")\n",
    "print(book) \n",
    "\n",
    "# Output: The Lord of the Rings by J.R.R. Tolkien"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebb0aee0-ea11-4158-ad05-6e03faa47ec3",
   "metadata": {},
   "source": [
    "# 63. How does the __len__() method work in Python? Provide an example\n",
    "\n",
    "## __len__(): Determining the Length of an Object\n",
    "\n",
    "The __len__() method in Python allows you to customize the behavior of the built-in len() function when applied to your custom objects.\n",
    "\n",
    "### How it Works:\n",
    "\n",
    "- Define the __len__() method within your class.\n",
    "- This method should return an integer representing the \"length\" of the object. The interpretation of \"length\" depends on the context of your class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1c718f27-5c0e-45f4-bc5b-b3f1d12c6000",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    " # Example : \n",
    "    \n",
    "class BookShelf:\n",
    "    def __init__(self, books=None):\n",
    "        self.books = books or []\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.books)\n",
    "\n",
    "shelf = BookShelf([\"The Hobbit\", \"Pride and Prejudice\"])\n",
    "print(len(shelf))  \n",
    "\n",
    "# Output: 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7feac62f-6f5d-4e07-86d4-6a7ddb6c52d9",
   "metadata": {},
   "source": [
    "# 64. Explain the usage of the __add__() method in Python classes. Provide an example\n",
    "\n",
    "## Usage of __add__(): Adding Custom Objects\n",
    "\n",
    "The __add__() method allows you to define how objects of your class are added together using the + operator.\n",
    "\n",
    "**Example:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7e3733aa-b28f-409d-a9f6-373dd5a309a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 8\n"
     ]
    }
   ],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __add__(self, other):\n",
    "        return Point(self.x + other.x, self.y + other.y)\n",
    "\n",
    "p1 = Point(2, 3)\n",
    "p2 = Point(4, 5)\n",
    "p3 = p1 + p2  # Calls p1.__add__(p2)\n",
    "print(p3.x, p3.y)  # Output: 6 8"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd8ee7c5-3a36-47ff-9236-0b50fa2365a3",
   "metadata": {},
   "source": [
    "# 65. What is the purpose of the __getitem__() method in Python? Provide an example\n",
    "\n",
    "## __getitem__(): Accessing Elements Like a Sequence\n",
    "\n",
    "The __getitem__() method in Python allows you to define how elements of your custom object are accessed using indexing (e.g., object[key]). This makes your object behave like a sequence (e.g., a list or a tuple).\n",
    "**Purpose:**\n",
    "\n",
    "- Custom Indexing: You can define how an object responds when a specific index or key is used to access its elements. This gives you flexibility in representing data structures and providing access to internal data in a controlled manner.\n",
    "- Sequence-like Behavior: By implementing __getitem__(), your object can be used with many built-in functions and methods that work with sequences, such as slicing, iteration, and the in operator.\n",
    "\n",
    "**Example:**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "47f63352-e716-4579-99be-f6dcf00ebcf0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "[10, 20]\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "class DataStore:\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.data[index]\n",
    "\n",
    "data_store = DataStore([10, 20, 30, 40])\n",
    "print(data_store[1])   # Output: 20\n",
    "print(data_store[:2])  # Output: [10, 20] \n",
    "for item in data_store:\n",
    "    print(item)        \n",
    "    \n",
    "# Output: 10, 20, 30, 40 (iteration)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f36e83b-91a5-435f-b703-697c746c5625",
   "metadata": {},
   "source": [
    "# 66. Explain the usage of the __iter__() and __next__() methods in Python. Provide an example using iterators\n",
    "\n",
    "## __iter__() and __next__(): The Core of Iterators\n",
    "\n",
    "The __iter__() and __next__() methods are fundamental for creating custom iterators in Python. They define how an object can be iterated over using a for loop or other iteration mechanisms.\n",
    "\n",
    "### 1. __iter__():\n",
    "- **Purpose:** This method should return an iterator object. The iterator object itself will be used for the actual iteration.\n",
    "- **Requirement**: It must return an object that implements the __next__() method.\n",
    "### 2. __next__():\n",
    "- **Purpose:** This method should return the next item in the sequence.\n",
    "- **Behavior:**\n",
    "- If there are more items to return, it returns the next item.\n",
    "- If there are no more items, it should raise a StopIteration exception to signal the end of the iteration.\n",
    "\n",
    "**Example:** Custom Iterator for Even Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "0c1769e8-7f8a-45a0-8162-e3a9b5d5bf1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Example : \n",
    "\n",
    "class EvenNumbers:\n",
    "    def __init__(self, max_value):\n",
    "        self.max_value = max_value\n",
    "        self.current = 0\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self  \n",
    "\n",
    "    def __next__(self):\n",
    "        if self.current > self.max_value:\n",
    "            raise StopIteration\n",
    "        else:\n",
    "            self.current += 2\n",
    "            return self.current - 2\n",
    "\n",
    "even_numbers = EvenNumbers(10)\n",
    "for num in even_numbers:\n",
    "    print(num)  \n",
    "    \n",
    "# Output: 0, 2, 4, 6, 8, 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a477725c-de67-45cc-a42d-88e809670870",
   "metadata": {},
   "source": [
    "# 67. What is the purpose of a getter method in Python? Provide an example demonstrating the use of a getter method using property decorators\n",
    "\n",
    "## Getter Methods: Controlled Access to Attributes\n",
    "In Python, a getter method is a special type of method used to access the value of an attribute in a controlled manner. While direct access to attributes is possible, using getter methods provides several advantages:\n",
    "### Purposes of Getter Methods:\n",
    "### 1. Encapsulation and Data Protection:\n",
    "- Getters allow you to control how attribute values are accessed, preventing accidental modification from outside the class and ensuring data integrity.\n",
    "### 2. Validation and Calculation:\n",
    "- You can add validation logic within the getter to ensure that the returned value meets certain criteria.\n",
    "- Getters can also perform calculations or transformations on the underlying data before returning it.\n",
    "### 3. Read-Only Access:\n",
    "- By providing only a getter and not a setter, you can create read-only attributes, preventing external code from modifying the value.\n",
    "\n",
    "**Example with @property Decorator:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "01731f9d-646d-4f4b-aa25-97a1937e1865",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ram Sumit\n"
     ]
    }
   ],
   "source": [
    "class Employee:\n",
    "    def __init__(self, first_name, last_name):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "\n",
    "    @property\n",
    "    def full_name(self):\n",
    "        return f\"{self.first_name} {self.last_name}\"\n",
    "\n",
    "employee = Employee(\"Ram\", \"Sumit\")\n",
    "print(employee.full_name)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7dbf6308-34ef-4cc0-b935-d8e50d70868d",
   "metadata": {},
   "source": [
    "# 68. Explain the role of setter methods in Python. Demonstrate how to use a setter method to modify a class attribute using property decorators\n",
    "\n",
    "## Setter Methods: Controlled Attribute Modification\n",
    "Setter methods in Python provide a mechanism to modify the value of an attribute in a controlled and safe manner. While directly assigning to attributes is possible, using setters offers several benefits:\n",
    "\n",
    "### Roles of Setter Methods:\n",
    "**1. Data Validation:**\n",
    "- Setters can include validation logic to ensure that the new value being assigned meets specific criteria. This helps prevent invalid data from being stored in the object's attributes, maintaining data integrity.\n",
    "\n",
    "**2. Additional Actions:**\n",
    "- Apart from setting the attribute value, setters can perform additional actions like updating related attributes, triggering events, or logging changes.\n",
    "\n",
    "**3. Encapsulation:**\n",
    "- Setters help maintain encapsulation by hiding the internal implementation details of how an attribute is stored or updated.\n",
    "\n",
    "**Example with @property and Setter:**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "e4869aaf-4e0a-4158-b3b3-c41e7b1b8575",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sumit\n",
      "Ram\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self._name = name  # Using _name convention for internal attribute\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @name.setter\n",
    "    def name(self, new_name):\n",
    "        if not isinstance(new_name, str):\n",
    "            raise TypeError(\"Name must be a string\")\n",
    "        self._name = new_name\n",
    "\n",
    "person = Person(\"Sumit\")\n",
    "print(person.name)  \n",
    "\n",
    "person.name = \"Ram\" \n",
    "print(person.name)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b75cb8f5-64ca-4441-b301-408b2da6d853",
   "metadata": {},
   "source": [
    "# 69. What is the purpose of the @property decorator in Python? Provide an example illustrating its usage\n",
    "\n",
    "## @property: Transforming Methods into Attributes\n",
    "The @property decorator in Python is a powerful tool that allows you to define methods that can be accessed like attributes. It enhances code readability and provides a controlled way to manage attribute access and modification.\n",
    "\n",
    "**Purpose:**\n",
    "\n",
    "- **Attribute-like Access:** Methods decorated with @property can be accessed directly without using parentheses, just like regular attributes. This makes the code cleaner and more intuitive.\n",
    "- **Encapsulation:** While providing attribute-like access, you still have the flexibility to control how the attribute is accessed and modified within the underlying methods (getter and setter).\n",
    "\n",
    "**Example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "d1315aea-5886-4afd-b37c-fb2999a5c00d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "78.53975\n"
     ]
    }
   ],
   "source": [
    "\n",
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    @property\n",
    "    def area(self):\n",
    "        return 3.14159 * self.radius ** 2\n",
    "\n",
    "circle = Circle(5)\n",
    "print(circle.area)  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d23492a-9b59-4b6d-bfe7-652762242d0b",
   "metadata": {},
   "source": [
    "# 70. Explain the use of the @deleter decorator in Python property decorators. Provide a code example demonstrating its application\n",
    "\n",
    "## @deleter: Controlling Attribute Deletion\n",
    "The @deleter decorator, used in conjunction with the @property decorator, allows you to define custom behavior when an attribute of an object is deleted using the del keyword.\n",
    "\n",
    "**Purpose:**\n",
    "\n",
    "- **Custom Deletion Logic:** You can implement specific actions to be performed when an attribute is deleted. This might involve cleaning up resources, updating related attributes, or logging the deletion.\n",
    "- **Controlled Access:** Just like with getters and setters, @deleter provides controlled access to attribute deletion, preventing accidental or unauthorized removal of attributes.\n",
    "\n",
    "**Example:**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "bdc15745-089a-4735-bdf2-3f9b8ad6ee4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deleting value...\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    \n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "\n",
    "    @property\n",
    "    \n",
    "    def value(self):\n",
    "        return self._value\n",
    "\n",
    "    @value.deleter\n",
    "    \n",
    "    def value(self):\n",
    "        print(\"Deleting value...\")\n",
    "        del self._value\n",
    "\n",
    "obj = MyClass(10)\n",
    "del obj.value "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb20f4e6-2b39-4203-bfc3-a996e0b8a526",
   "metadata": {},
   "source": [
    "# 71. How does encapsulation relate to property decorators in Python? Provide an example showcasing encapsulation using property decorators.\n",
    "\n",
    "## Encapsulation and Property Decorators: A Powerful Combination\n",
    "\n",
    "Encapsulation, a core principle of object-oriented programming, involves bundling data (attributes) and methods that operate on that data within a single unit (a class). Property decorators in Python provide a powerful mechanism to implement encapsulation effectively.\n",
    "\n",
    "**How they Relate:**\n",
    "\n",
    "- **Controlled Access:** Property decorators allow you to define getter, setter, and deleter methods for class attributes. This enables you to control how attributes are accessed, modified, and deleted, preventing direct manipulation from outside the class.\n",
    "- **Data Protection:** By encapsulating attributes and providing access through methods, you can enforce validation rules, perform calculations, or trigger side effects, ensuring data integrity and consistency.\n",
    "- **Abstraction:** Property decorators help hide internal implementation details. Users of the class only need to know how to interact with the attributes through the defined methods without worrying about the underlying data structures or logic.\n",
    "\n",
    "**Example: Encapsulating a Bank Account**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "1ec5f8b4-4922-4a35-8187-9a1c07bfbbce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000\n"
     ]
    }
   ],
   "source": [
    "class BankAccount:\n",
    "    \n",
    "    def __init__(self, balance):\n",
    "        self._balance = balance\n",
    "\n",
    "    @property\n",
    "    def balance(self):\n",
    "        return self._balance\n",
    "\n",
    "    @balance.setter\n",
    "    def balance(self, amount):\n",
    "        if amount < 0:\n",
    "            raise ValueError(\"Balance cannot be negative\")\n",
    "        self._balance = amount\n",
    "\n",
    "account = BankAccount(1000)\n",
    "print(account.balance)  \n",
    "account.balance += 500  \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c7152ee-ee54-475b-8dcf-ea1cf91cadad",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}