Encapsulation in python

Encapsulation is a fundamental concept in object-oriented programming (OOP) that refers to the practice of hiding the internal details of an object and exposing only the necessary information or functionality to the outside world. It allows the programmer to control access to an object's properties and methods, and to protect them from being modified or accessed in unintended ways.

In Python, encapsulation can be achieved through the use of access modifiers. These are special keywords that define the level of access to an object's properties and methods. The three access modifiers used in Python are public, protected, and private.

Public: Public members (methods and properties) can be accessed from anywhere outside the class.
Protected: Protected members can be accessed from within the class and its subclasses.
Private: Private members can only be accessed from within the class.

Here's an example Python program that demonstrates encapsulation using access modifiers:

class Person:
    def __init__(self, name, email):
        self.name = name  # public member
        self._email = email # protected member
        self.__password = "password" # private member

    # methods
    def get_email(self):
        return self._email

    def get_password(self):
        return self.__password

p = Person('Alice', 'alice@gmail.com')
print(p.name)  # public member can be accessed from anywhere
print(p.get_email()) # protected member can be accessed from within the class
print(p.get_password()) # private member can only be accessed from within the class

In this program, we define a Person class with three properties: name, _email, and __password. The name property is a public member and can be accessed from anywhere outside the class. The _email property is a protected member and can only be accessed from within the class and its subclasses. The __password property is a private member and can only be accessed from within the class.

We also define two methods get_email() and get_password() that returns the value of the _email and __password properties respectively. These methods provide controlled access to the protected and private members of the class.

In the main program, we create an instance of the Person class and access its public and protected members using the name property and get_email() method. We also access its private member using the get_password() method. This demonstrates how encapsulation allows us to control access to an object's properties and methods and protect them from being modified or accessed in unintended ways.

In conclusion, encapsulation is implemented through the use of underscores to indicate private and protected variables and methods. However, it's important to note that Python does not enforce strict encapsulation like some other object-oriented programming languages. Nevertheless, encapsulation remains an important concept in Python programming, and understanding it can help you write better, more maintainable code.

Encapsulation in Python: Understanding the Benefits of Object-Oriented Programming