06-Object_oriented_programming/03_encapsulation_and_abstraction.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7d1c1893",
   "metadata": {},
   "source": [
    "# Module 6: Object oriented programming\n",
    "\n",
    "## Part 3: Encapsulation and abstraction\n",
    "\n",
    "### 3.1. Encapsulation and information hidding\n",
    "\n",
    "Encapsulation is a fundamental concept in Object-Oriented Programming (OOP) that involves bundling data (attributes) and behaviors (methods) together within a class. It allows for information hiding, ensuring that the internal state of an object is not directly accessible from outside the class. Encapsulation promotes data integrity, security, and code maintainability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efbba5ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BankAccount:\n",
    "    def __init__(self, account_number, balance):\n",
    "        self._account_number = account_number  # Encapsulated attribute\n",
    "        self._balance = balance  # Encapsulated attribute\n",
    "        \n",
    "    def deposit(self, amount):\n",
    "        self._balance += amount\n",
    "        \n",
    "    def withdraw(self, amount):\n",
    "        if self._balance >= amount:\n",
    "            self._balance -= amount\n",
    "        else:\n",
    "            print(\"Insufficient funds.\")\n",
    "\n",
    "# Creating an instance of the BankAccount class\n",
    "account = BankAccount(\"1234567890\", 1000)\n",
    "\n",
    "# Accessing attributes and calling methods\n",
    "account.deposit(500)\n",
    "account.withdraw(200)\n",
    "print(account._balance)   # Output: 1300"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c9918d0b",
   "metadata": {},
   "source": [
    "In this example, the _account_number and _balance attributes are encapsulated within the BankAccount class using the single underscore convention. These attributes are intended to be accessed and modified within the class methods but are not intended for direct access from outside the class.\n",
    "\n",
    "### 3.2. Abstraction and data hiding\n",
    "\n",
    "Abstraction is a concept closely related to encapsulation. It involves presenting only essential information to the outside world while hiding unnecessary details. Abstraction allows us to focus on the essential features and behaviors of an object, without exposing the underlying implementation.\n",
    "\n",
    "In Python, abstraction can be achieved by defining abstract classes and interfaces using the abc module. Abstract classes provide a blueprint for other classes and cannot be instantiated themselves. They can contain abstract methods, which are methods without implementation, meant to be overridden by subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0dc6757e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class Shape(ABC):\n",
    "    @abstractmethod\n",
    "    def calculate_area(self):\n",
    "        pass\n",
    "\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "    \n",
    "    def calculate_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "rectangle = Rectangle(4, 5)\n",
    "print(rectangle.calculate_area())  # Output: 20\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d5d64740",
   "metadata": {},
   "source": [
    "In this example, Shape is an abstract class with the calculate_area method defined as an abstract method. The Rectangle class is a subclass of Shape and provides the implementation for the calculate_area method. By defining abstract classes and abstract methods, we can enforce a common interface and ensure that subclasses implement necessary behaviors.\n",
    "\n",
    "### 3.3. Access modifiers: public, private, and protected\n",
    "\n",
    "In Python, access modifiers are conventions used to indicate the level of visibility and accessibility of class members (attributes and methods). Although Python does not enforce strict access control, the following conventions are commonly used:\n",
    "\n",
    "- Public Access (+)\n",
    "\n",
    "    Public members are accessible from anywhere. By convention, public attributes and methods have no leading underscores.\n",
    "\n",
    "- Private Access (-)\n",
    "\n",
    "    Private members are intended to be accessed only within the class. By convention, private attributes and methods have a double leading underscore.\n",
    "\n",
    "- Protected Access (#) \n",
    "\n",
    "    Protected members are intended to be accessed only within the class and its subclasses. By convention, protected attributes and methods have a leading underscore, but this convention is not strictly enforced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ef3d8e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name  # Public attribute\n",
    "        self._age = age  # Protected attribute\n",
    "        self.__address = '123 Street'  # Private attribute\n",
    "\n",
    "    def __display_address(self):\n",
    "        print(self.__address)  # Private method\n",
    "\n",
    "person = Person('John', 25)\n",
    "print(person.name)  # Output: John\n",
    "print(person._age)  # Output: 25\n",
    "#print(person.__address)  Error: AttributeError\n",
    "#person.__display_address()   Error: AttributeError"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "080d535b",
   "metadata": {},
   "source": [
    "In this example, name is a public attribute, _age is a protected attribute, and __address is a private attribute. Private attributes and methods are not intended for direct access from outside the class.\n",
    "\n",
    "### 3.4. Using properties to control attribute access\n",
    "\n",
    "Properties provide a way to control attribute access and allow for attribute validation, computation, and protection. They enable encapsulation by providing getter and setter methods for accessing and modifying attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c29ea4a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Circle:\n",
    "    def __init__(self, radius):\n",
    "        self._radius = radius\n",
    "        \n",
    "    @property\n",
    "    def radius(self):\n",
    "        return self._radius\n",
    "    \n",
    "    @radius.setter\n",
    "    def radius(self, value):\n",
    "        if value > 0:\n",
    "            self._radius = value\n",
    "        else:\n",
    "            raise ValueError(\"Radius must be positive.\")\n",
    "            \n",
    "circle = Circle(5)\n",
    "print(circle.radius)  # Output: 5\n",
    "\n",
    "circle.radius = 7\n",
    "print(circle.radius)  # Output: 7\n",
    "\n",
    "# circle.radius = -2  Error: ValueError"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "e80cc59b",
   "metadata": {},
   "source": [
    "In this example, the radius attribute is encapsulated, and its access is controlled using the @property decorator and a corresponding setter method. The setter method performs validation to ensure that the assigned value is positive.\n",
    "\n",
    "### 3.5. Summary\n",
    "\n",
    "In this third section on \"Encapsulation and Abstraction,\" we explored the concepts of encapsulation and information hiding, as well as the related concept of abstraction. \n",
    "\n",
    "Encapsulation involves bundling data and behaviors within a class to promote data integrity and code maintainability. It allows for information hiding, ensuring that the internal state of an object is not directly accessible from outside the class.\n",
    "\n",
    "Abstraction, on the other hand, focuses on presenting essential information while hiding unnecessary details. We discussed the use of abstract classes and abstract methods to achieve abstraction in Python. Abstract classes provide a blueprint for other classes and cannot be instantiated themselves, while abstract methods are meant to be overridden by subclasses to provide specific implementations.\n",
    "\n",
    "Additionally, we discussed how properties can be used to control attribute access and provide validation, computation, and protection. Properties enable us to encapsulate attributes and provide controlled access through getter and setter methods.\n",
    "\n",
    "Understanding encapsulation and abstraction is crucial for building robust and maintainable code. Encapsulation helps in organizing code and protecting sensitive data, while abstraction allows us to focus on essential features and hide unnecessary implementation details."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}