What is encapsulation in Python with example?

What is encapsulation in Python with example?

I'm happy to help!

Encapsulation is one of the fundamental concepts in object-oriented programming (OOP) that allows you to bundle data and methods that manipulate that data into a single unit. This helps to hide the implementation details from the outside world, making your code more organized, maintainable, and less prone to errors.

In Python, encapsulation is achieved through the use of classes and objects. A class defines the blueprint for creating objects, and an object represents an instance of that class. When you create an object, it has its own set of attributes (data) and methods that can be used to manipulate those attributes.

Here's a simple example:

class BankAccount:
def init(self, balance):
self.__balance = balance  # encapsulated attribute
def deposit(self, amount):
self.__balance += amount
def get_balance(self):
return self.__balance
account = BankAccount(1000)  # create an object
print(account.get_balance())  # prints 1000
account.deposit(500)
print(account.get_balance())  # prints 1500

In this example, the BankAccount class encapsulates the balance attribute. The deposit method modifies the balance, and the get_balance method allows you to retrieve the current balance.

Notice that:

Benefits of encapsulation:

In Python, encapsulation is particularly useful when working with complex objects that have many attributes and methods. By grouping related code together, you can create more robust and maintainable code.

That's a brief introduction to encapsulation in Python! If you have any questions or would like to see more examples, feel free to ask.

Python encapsulation example w3schools

Here is a Python encapsulation example using W3Schools:

Encapsulation is a fundamental concept in object-oriented programming (OOP). It is the idea of bundling data and methods that operate on that data into a single unit, known as a class.

In Python, you can use classes to achieve encapsulation. Here's an example:

class BankAccount:
def init(self):
self.balance = 0
def deposit(self, amount):
self.balance += amount
def withdraw(self, amount):
if amount > self.balance:
raise ValueError("Insufficient funds")
self.balance -= amount
def get_balance(self):
return self.balance
account = BankAccount()
print(account.get_balance())  # prints: 0
account.deposit(100)
print(account.get_balance())  # prints: 100
account.withdraw(50)
print(account.get_balance())  # prints: 50

In this example, we define a BankAccount class. This class has three methods: deposit, withdraw, and get_balance. The class also has an instance variable balance that represents the account balance.

The __init__ method is used to initialize the object when it's created. It sets the initial balance to 0.

The deposit method adds the given amount to the current balance. The withdraw method subtracts the given amount from the current balance, but only if there are enough funds in the account. If not, it raises a ValueError with the message "Insufficient funds".

The get_balance method returns the current account balance.

To use this class, we create an instance of BankAccount, and then call its methods to simulate depositing and withdrawing money:

account = BankAccount()
print(account.get_balance())  # prints: 0
account.deposit(100)
print(account.get_balance())  # prints: 100
account.withdraw(50)
print(account.get_balance())  # prints: 50

This example demonstrates encapsulation by hiding the internal state (balance) and behavior (deposit/withdraw/get balance) within the BankAccount class. The outside world only interacts with the class through its publicly accessible methods.

Encapsulation provides several benefits, including:

In this example, encapsulation helps ensure that the bank account's balance is modified only through the approved deposit and withdrawal methods, preventing accidental or malicious changes to the balance.