Code Mastery Centre
8 Oct, 2025

Understanding Access Modifiers in Python: Public, Protected, and Private

Understanding Access Modifiers in Python

In Python’s object-oriented programming (OOP), access modifiers control the visibility and accessibility of class attributes and methods. Unlike languages like Java or C++, Python does not enforce strict access control but uses naming conventions to indicate the intended visibility: public, protected (denoted by a single underscore _), and private (denoted by a double underscore __). This article explores these access modifiers, their conventions, use cases, and practical examples to clarify their roles in Python.

Overview of Access Modifiers in Python

Python relies on conventions rather than strict enforcement for access control:

  • Public: Attributes and methods are accessible from anywhere. No special prefix is used.
  • Protected: Indicated by a single underscore (_), suggesting restricted access, but it’s a convention and not enforced.
  • Private: Indicated by a double underscore (__), triggering name mangling to make access harder from outside the class.

These modifiers guide developers on how class members should be used, promoting encapsulation and data protection.

1. Public Access Modifier

Public attributes and methods are accessible from anywhere—inside the class, subclasses, or external code. By default, all class members in Python are public unless prefixed with underscores.

Characteristics of Public Members

  • No prefix in the name (e.g., attribute, method()).
  • Can be accessed and modified by any code that has a reference to the object or class.
  • Used for attributes and methods intended to be part of the class’s public interface.

Example: Public Attributes and Methods

class Car:
    def __init__(self, brand, model):
        self.brand = brand  # Public attribute
        self.model = model  # Public attribute

    def drive(self):  # Public method
        return f"{self.brand} {self.model} is driving!"

# Accessing public members
car = Car("Toyota", "Camry")
print(car.brand)        # Output: Toyota
print(car.drive())      # Output: Toyota Camry is driving!
car.model = "Corolla"   # Modifying public attribute
print(car.model)        # Output: Corolla

The brand and model attributes, and the drive method, are public and can be accessed or modified directly from outside the class.

2. Protected Access Modifier

Protected members are indicated by a single underscore prefix (_). This is a convention signaling that the member is intended for internal use within the class and its subclasses, though Python does not enforce this restriction.

Characteristics of Protected Members

  • Prefixed with a single underscore (e.g., _attribute, _method()).
  • Accessible from anywhere, but the underscore signals to developers that the member should not be accessed directly outside the class or its subclasses.
  • Commonly used for attributes or methods that are part of the internal implementation but may be useful in subclasses.

Example: Protected Attributes and Methods

class Employee:
    def __init__(self, name, salary):
        self.name = name        # Public
        self._salary = salary   # Protected

    def _calculate_bonus(self):  # Protected method
        return self._salary * 0.1

class Manager(Employee):
    def get_bonus(self):
        return self._calculate_bonus()  # Accessing protected method in subclass

# Accessing protected members
emp = Employee("Alice", 50000)
print(emp._salary)           # Output: 50000 (accessible, but not recommended)
print(emp._calculate_bonus()) # Output: 5000.0 (accessible, but not recommended)

mgr = Manager("Bob", 80000)
print(mgr.get_bonus())       # Output: 8000.0

The _salary attribute and _calculate_bonus method are protected, indicating they should primarily be used within Employee or its subclasses like Manager. External access is possible but discouraged.

3. Private Access Modifier

Private members are indicated by a double underscore prefix (__), triggering Python’s name mangling mechanism. This makes it harder (but not impossible) to access these members from outside the class, promoting stronger encapsulation.

Characteristics of Private Members

  • Prefixed with a double underscore (e.g., __attribute, __method()).
  • Name mangling changes the member name to _ClassName__attribute, making it less accessible outside the class.
  • Intended for internal use within the class to protect sensitive data or implementation details.
  • Still accessible using the mangled name, but this is considered bad practice.

Example: Private Attributes and Methods

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # Public
        self.__balance = balance    # Private

    def __calculate_interest(self):  # Private method
        return self.__balance * 0.05

    def get_balance(self):  # Public method to access private attribute
        return self.__balance

    def add_interest(self):  # Public method to use private method
        self.__balance += self.__calculate_interest()

# Using the class
account = BankAccount("Alice", 1000)
print(account.get_balance())    # Output: 1000
account.add_interest()
print(account.get_balance())    # Output: 1050.0

# Attempting to access private members
# print(account.__balance)      # Error: AttributeError
print(account._BankAccount__balance)  # Output: 1050.0 (name mangling, not recommended)

The __balance attribute and __calculate_interest method are private. Direct access raises an AttributeError, but they can be accessed using the mangled name _BankAccount__balance, though this should be avoided.

Access Modifiers in Inheritance

Access modifiers behave differently in subclasses:

  • Public: Fully accessible in subclasses.
  • Protected: Accessible in subclasses (by convention), as Python does not enforce restrictions.
  • Private: Not directly accessible in subclasses due to name mangling, but can be accessed using mangled names (not recommended).
class Base:
    def __init__(self):
        self.public_var = "Public"
        self._protected_var = "Protected"
        self.__private_var = "Private"

class Derived(Base):
    def access_vars(self):
        return (self.public_var, self._protected_var)  # Public and protected accessible
        # self.__private_var  # Error: AttributeError

base = Base()
derived = Derived()
print(derived.access_vars())  # Output: ('Public', 'Protected')
print(base._Base__private_var)  # Output: Private (name mangling, not recommended)

The Derived class can access public_var and _protected_var, but __private_var requires name mangling to access, which should be avoided.

Best Practices for Access Modifiers

  • Follow naming conventions: Use no prefix for public, _ for protected, and __ for private to clearly communicate intent.
  • Use private for sensitive data: Protect critical attributes (e.g., account balances) with __ and provide public methods (getters/setters) for access.
  • Respect protected conventions: Avoid accessing _protected members outside the class or its subclasses unless necessary.
  • Avoid name mangling hacks: Accessing private members via _ClassName__member defeats encapsulation and can break code if class names change.
  • Provide public interfaces: Use public methods to interact with protected or private members, ensuring controlled access.
  • Document access intent: Clearly document whether attributes/methods are public, protected, or private in docstrings.

Limitations of Access Modifiers in Python

  • No strict enforcement: Python’s access control is based on conventions, not strict rules, unlike Java or C++.
  • Name mangling is not foolproof: Private members can still be accessed using mangled names, so it’s more about signaling intent than absolute protection.
  • Overuse of private members: Excessive use of __ can make code harder to debug or extend, so use sparingly for truly sensitive data.

Conclusion

Python’s access modifiers—public, protected (_), and private (__)—provide a way to control access to class members through conventions and name mangling. Public members are fully accessible, protected members signal restricted use, and private members offer stronger encapsulation via name mangling. By following these conventions and using appropriate access levels, you can write clear, maintainable, and encapsulated Python code. Experiment with the examples above to master access modifiers in your OOP projects!

Next Post Previous Post