What are Access Specifiers in Python?

In Python, public access is the default access level. Attributes and methods defined without any leading underscores are considered public and can be accessed from anywhere in the program. For instance:

class MyClass:
    def __init__(self):
        self.public_attr = 'I am public'

obj = MyClass()
print(obj.public_attr)  # Output: I am public

In this example, the public_attr is accessible from outside the class. Public access is essential for methods that should be available to all users of the class. However, it’s important to use public attributes with caution, as exposing too much can lead to unintended modifications. Always consider the implications of making attributes public and whether they should be exposed to the outside world.

In Python, protected access is indicated by a single leading underscore _. This suggests that the attribute or method is intended for internal use within the class and its subclasses, but it is still possible to access it from outside. For example:

class Base:
    def __init__(self):
        self._protected_attr = 'I am protected'

class Derived(Base):
    def show(self):
        return self._protected_attr

obj = Derived()
print(obj.show())  # Output: I am protected

Here, _protected_attr is meant to be used within Base and its subclasses like Derived. While it can be accessed outside, it’s a convention that indicates it should be treated with care. This access level is useful for subclassing scenarios, providing a way to extend functionality while still protecting the base class's integrity.

In Python, private access is denoted by a double leading underscore __. This makes the attribute or method inaccessible from outside the class, effectively hiding it. For instance:

class MyClass:
    def __init__(self):
        self.__private_attr = 'I am private'

    def get_private_attr(self):
        return self.__private_attr

obj = MyClass()
print(obj.get_private_attr())  # Output: I am private

In this example, __private_attr cannot be accessed directly from outside the class, ensuring that sensitive data remains protected. The get_private_attr method is a public interface that safely exposes the private attribute. This access level is crucial for encapsulation, allowing developers to safeguard the internal state of an object while providing controlled access through public methods. It helps prevent unintended interference and promotes robust software design.