Day78 - Revision of Encapsulation in OOP in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Revision Of Encapsulation - OOP in Python**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation is one of the fundamental principles of object-oriented programming (OOP) and is supported in Python, just like in many other object-oriented languages. It refers to the concept of bundling data (attributes) and the methods (functions) that operate on that data into a single unit called a class. Additionally, it restricts direct access to some of the object's components, providing a controlled and well-defined interface to interact with the object.\n",
    "\n",
    "In Python, encapsulation is implemented using access modifiers and naming conventions:\n",
    "\n",
    "1. **Public:** Attributes and methods that are accessible from outside the class without any restrictions. By default, all attributes and methods in Python are public.\n",
    "\n",
    "2. **Protected:** Attributes and methods that are intended to be used only within the class and its subclasses. In Python, you can denote a protected attribute or method by prefixing it with a single underscore (e.g., `_my_attribute`).\n",
    "\n",
    "3. **Private:** Attributes and methods that are intended to be used only within the class. In Python, you can denote a private attribute or method by prefixing it with a double underscore (e.g., `__my_attribute`).\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if we have a one class\n",
    "\n",
    "class Myclass:\n",
    "    def __init__(self):\n",
    "        self.public_attribute = 55\n",
    "        self._protected_attribute = 'Hello'\n",
    "        self.__private_attribute = 'World'\n",
    "        \n",
    "    def public_method(self):\n",
    "        return \"This is public method\"\n",
    "    \n",
    "    def _protected_method(self):\n",
    "        return \"This is Protected Method\"\n",
    "    \n",
    "    def __private_method(self):\n",
    "        return \"this is private Method\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj = Myclass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "This is public method\n"
     ]
    }
   ],
   "source": [
    "# we have to access the public attribaute dirctly and don't give any tyoe of error or messages\n",
    "\n",
    "print(obj.public_attribute)\n",
    "print(obj.public_method())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "This is Protected Method\n"
     ]
    }
   ],
   "source": [
    "# so now we try for Protected attribute\n",
    "print(obj._protected_attribute)\n",
    "print(obj._protected_method()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Myclass' object has no attribute '__private_attribute'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\disha\\Downloads\\Pythoon 100 Days\\100_Days_OF_Python\\Day17 - Encapsulation in OOP in Python.ipynb Cell 7\u001b[0m line \u001b[0;36m2\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/disha/Downloads/Pythoon%20100%20Days/100_Days_OF_Python/Day17%20-%20Encapsulation%20in%20OOP%20in%20Python.ipynb#W6sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39m# Accessing private attributes and methods directly will result in an error:\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/disha/Downloads/Pythoon%20100%20Days/100_Days_OF_Python/Day17%20-%20Encapsulation%20in%20OOP%20in%20Python.ipynb#W6sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39mprint\u001b[39m(obj\u001b[39m.\u001b[39;49m__private_attribute)   \u001b[39m# Raises an AttributeError\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/disha/Downloads/Pythoon%20100%20Days/100_Days_OF_Python/Day17%20-%20Encapsulation%20in%20OOP%20in%20Python.ipynb#W6sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m \u001b[39mprint\u001b[39m(obj\u001b[39m.\u001b[39m__private_method())\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Myclass' object has no attribute '__private_attribute'"
     ]
    }
   ],
   "source": [
    "# Accessing private attributes and methods directly will result in an error:\n",
    "print(obj.__private_attribute)   # Raises an AttributeError\n",
    "print(obj.__private_method())    # Raises an AttributeError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can undestand with Encapsulation with this short story:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a bustling city, there was a high-tech security system protecting a valuable treasure. The system had a keypad (public interface) that allowed authorized personnel to enter a secret code. Behind the keypad was a locked room (protected layer) with advanced security features, and inside that room was a safe (private layer) holding the treasure. Only a select few knew the secret code, ensuring the treasure's safety while providing access to those who needed it. This is encapsulation in action, safeguarding valuable data while allowing controlled access."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Top five benefits of encapsulation:\n",
    "\n",
    "1. **Controlled Access:** Encapsulation restricts direct access to internal data, ensuring that it is only modified through well-defined methods, which helps prevent unintended errors and maintain data integrity.\n",
    "\n",
    "2. **Modularity:** Encapsulation promotes modular code by isolating the implementation details of a class. This makes it easier to update or replace components without affecting the rest of the system.\n",
    "\n",
    "3. **Information Hiding:** It hides complex internal details, reducing the complexity for users of a class and allowing developers to change the implementation without impacting external code.\n",
    "\n",
    "4. **Security:** By controlling access to sensitive data and methods, encapsulation enhances security, reducing the risk of unauthorized or malicious manipulation.\n",
    "\n",
    "5. **Reusability:** Encapsulation facilitates the creation of reusable and self-contained classes, which can be easily integrated into different parts of a program or shared across projects, saving development time and effort."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common uses of encapsulation in programming:\n",
    "\n",
    "1. **Data Protection:** Encapsulation restricts direct access to data, ensuring that it can only be modified through controlled methods. This protects data integrity and prevents unintended modifications or errors.\n",
    "\n",
    "2. **Abstraction:** It allows you to present a simplified and high-level view of an object, hiding the complex implementation details. This abstraction makes it easier for users of the class to understand and work with it.\n",
    "\n",
    "3. **Code Organization:** Encapsulation helps organize code by bundling related data and methods within a class. This modular approach enhances code readability and maintainability, making it easier to manage large codebases.\n",
    "\n",
    "4. **Security:** By encapsulating sensitive data and operations, you can control who has access to them. This enhances security by preventing unauthorized access or manipulation of critical information.\n",
    "\n",
    "5. **Reusability:** Encapsulated classes can be reused in different parts of a program or in different projects. This reusability saves development time and promotes the creation of robust, well-tested components."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}