Python Encapsulation

Introduction

Encapsulation is one of the fundamental concepts in object-oriented programming (OOP). It refers to the bundling of data (attributes) and methods (functions) that operate on the data into a single unit, or class. Encapsulation helps in restricting access to certain components of an object and can prevent the accidental modification of data.

Key Concepts

Public, Protected, and Private Members

• Public Members: Accessible from outside the class. They are defined without any leading underscores.
• Protected Members: Indicated by a single underscore (_). They are meant to be accessed within the class and its subclasses.
• Private Members: Indicated by a double underscore (__). They are meant to be accessed only within the class.

Syntax

Defining a Class with Encapsulation

class MyClass: def __init__(self, public, protected, private): self.public = public # Public attribute self._protected = protected # Protected attribute self.__private = private # Private attribute def get_private(self): return self.__private def set_private(self, value): self.__private = value 

Example

Let’s consider a simple example of a Car class to demonstrate encapsulation.

Car Class

class Car: def __init__(self, brand, model, price): self.brand = brand # Public attribute self._model = model # Protected attribute self.__price = price # Private attribute def get_price(self): return self.__price def set_price(self, price): if price > 0: self.__price = price else: print("Invalid price") # Creating an object my_car = Car("Toyota", "Corolla", 20000) 

Explanation

1. Public Attribute (brand): Accessible from outside the class directly.
2. Protected Attribute (_model): Intended to be accessed within the class and its subclasses.
3. Private Attribute (__price): Only accessible within the class using methods.

Using the Car Class

# Accessing public attribute print(my_car.brand) # Output: Toyota # Accessing protected attribute print(my_car._model) # Output: Corolla # Accessing private attribute using getter method print(my_car.get_price()) # Output: 20000 # Modifying private attribute using setter method my_car.set_price(25000) print(my_car.get_price()) # Output: 25000 # Trying to access private attribute directly (will raise an AttributeError) try: print(my_car.__price) except AttributeError as e: print(e) # Output: 'Car' object has no attribute '__price' 

Real-World Example: Bank Account

Let’s consider a real-world example of a bank account system.

BankAccount Class

class BankAccount: def __init__(self, account_number, balance): self.__account_number = account_number # Private attribute self.__balance = balance # Private attribute def get_balance(self): return self.__balance def deposit(self, amount): if amount > 0: self.__balance += amount return f"Deposited {amount}. New balance is {self.__balance}." else: return "Invalid amount" def withdraw(self, amount): if 0 < amount <= self.__balance: self.__balance -= amount return f"Withdrew {amount}. New balance is {self.__balance}." else: return "Invalid amount or insufficient balance" # Creating an object of the BankAccount class account = BankAccount("1234567890", 10000) 

Explanation

1. Private Attributes (__account_number, __balance): These are only accessible within the class using methods.
2. Public Methods (get_balance, deposit, withdraw): These methods provide controlled access to the private attributes.

Using the BankAccount Class

# Accessing and modifying balance using methods print(account.get_balance()) # Output: 10000 print(account.deposit(5000)) # Output: Deposited 5000. New balance is 15000. print(account.get_balance()) # Output: 15000 print(account.withdraw(3000)) # Output: Withdrew 3000. New balance is 12000. print(account.get_balance()) # Output: 12000 # Trying to access private attribute directly (will raise an AttributeError) try: print(account.__balance) except AttributeError as e: print(e) # Output: 'BankAccount' object has no attribute '__balance' 

Conclusion

Encapsulation in Python helps to protect the internal state of an object and prevents unauthorized access and modification. By using public, protected, and private attributes, you can control the access level of each attribute and method. This not only enhances the security of the code but also makes it more modular and maintainable. The real-world example of a bank account demonstrates how encapsulation can be applied to manage sensitive data effectively.