Python - Encapsulation

In Python, the single underscore (_) convention in attribute names is a naming convention used to indicate that a particular attribute is intended for internal use within a class or module. While it doesn't enforce any access restrictions, it serves as a signal to other developers that the attribute is considered internal and should not be accessed directly from outside the class or module. The use of a single underscore is more of a convention and a form of documentation, indicating that a variable is meant to be treated as semi-private. Developers should exercise caution when accessing such attributes directly, as they are considered part of the internal implementation and are subject to change. Let's illustrate the significance of the single underscore convention with an example:

class MyClass:
    def __init__(self):
        # Public attribute
        self.public_var = 10

        # Protected attribute (single underscore convention)
        self._protected_var = 20

    def get_protected_var(self):
        return self._protected_var

    def set_protected_var(self, value):
        self._protected_var = value

# Creating an instance of the class
obj = MyClass()

# Accessing public and protected attributes directly
print(obj.public_var)           # Output: 10
print(obj._protected_var)       # Output: 20

# Modifying protected attribute directly
obj._protected_var = 30

# Displaying the modified value
print(obj.get_protected_var())  # Output: 30

In this example, _protected_var is a protected attribute following the single underscore convention. While it can be accessed and modified directly, it is recommended to use public methods like get_protected_var and set_protected_var to interact with the attribute. This convention helps in signaling that the attribute is part of the internal implementation and should be treated with caution.

Output:

10
20
30

In Python, name mangling is a technique that involves altering the names of variables to make them less accessible from outside the class. The double underscore (__) is used as a prefix to the attribute name, leading to name mangling. This is particularly useful when dealing with inheritance and avoiding unintentional attribute name conflicts between classes. The purpose of name mangling is to make it more difficult for external code to accidentally access or override attributes in a class. It is not a security feature but a convention to avoid accidental name clashes. Let's illustrate the purpose of double underscore name mangling with an example:

class NameManglingExample:
    def __init__(self):
        # Double underscore name mangling
        self.__private_var = 10

# Creating an instance of the class
obj = NameManglingExample()

# Accessing private attribute directly (before mangling)
# This will result in an AttributeError
# Uncommenting the next line will raise an error
# print(obj.__private_var)

# Accessing private attribute after name mangling
print(obj._NameManglingExample__private_var)  # Output: 10

In this example, __private_var is a private attribute. Before name mangling, attempting to access it directly from outside the class will result in an AttributeError. After name mangling, the attribute name is altered to include the class name as a prefix, making it accessible using the modified name _NameManglingExample__private_var.

Output:

10

In Python, read-only properties can be created using the property decorator. The property decorator allows you to define getter methods for attributes, making them read-only. This is a way to encapsulate data and control access to it, ensuring that certain attributes can only be read, not modified directly. Let's explore how to create read-only properties in a class with an example:

class ReadOnlyPropertiesExample:
    def __init__(self, initial_value):
        # Private variable
        self.__value = initial_value

    @property
    def value(self):
        return self.__value

# Creating an instance of the class
obj = ReadOnlyPropertiesExample(5)

# Accessing the read-only property
print(obj.value)  # Output: 5

# Attempting to modify the read-only property directly
# This will result in an AttributeError
# Uncommenting the next line will raise an error
# obj.value = 10

In this example, the value attribute is made read-only using the property decorator. The @property decorator defines a getter method named value that can be accessed like a regular attribute. Attempting to modify the read-only property directly will result in an AttributeError, enforcing encapsulation.

Output:

5

In Python, private and protected access modifiers are used to control the visibility of class members (attributes and methods) from outside the class. These modifiers help in achieving encapsulation and data hiding in object-oriented programming. 1. Private Access Modifier (Double Underscore - __): When an attribute or method is marked as private using a double underscore prefix, it is not accessible from outside the class. This is known as name mangling, and the attribute becomes harder to access directly. 2. Protected Access Modifier (Single Underscore - _): When an attribute or method is marked as protected using a single underscore prefix, it is considered a convention to indicate that the attribute should not be accessed directly from outside the class or its subclasses. However, it is not enforced by the Python interpreter, and the attribute can still be accessed if needed. Let's explore the differences between private and protected access modifiers with an example:

class AccessModifiersExample:
    def __init__(self):
        # Private attribute
        self.__private_var = 10

        # Protected attribute
        self._protected_var = 20

    def get_private_var(self):
        return self.__private_var

    def set_private_var(self, value):
        self.__private_var = value

    def get_protected_var(self):
        return self._protected_var

    def set_protected_var(self, value):
        self._protected_var = value

# Creating an instance of the class
obj = AccessModifiersExample()

# Accessing private and protected attributes using public methods
print(obj.get_private_var())     # Output: 10
print(obj.get_protected_var())   # Output: 20

# Modifying private and protected attributes using public methods
obj.set_private_var(30)
obj.set_protected_var(40)

# Displaying the modified values
print(obj.get_private_var())     # Output: 30
print(obj.get_protected_var())   # Output: 40

In this example, __private_var is a private attribute, and _protected_var is a protected attribute. While both can be accessed and modified through public methods, the main difference lies in the naming convention and the level of enforcement. Private attributes are harder to access directly due to name mangling, whereas protected attributes rely on developer conventions to avoid direct access.

Output:

10
20
30
40