Python Encapsulation – Private Attributes and Property Decorators

Python's Underscore Convention

Python uses naming conventions rather than strict access modifiers. Single underscore = "internal use". Double underscore = name-mangled (harder to access from outside).

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner        # Public
        self._balance = balance   # Protected (convention only)
        self.__pin = "1234"       # Private (name-mangled)

acc = BankAccount("Alice", 1000)
print(acc.owner)      # Alice — OK
print(acc._balance)   # 1000 — works but discouraged
# print(acc.__pin)    # AttributeError!
print(acc._BankAccount__pin)  # "1234" — mangled name

@property – Clean Getters and Setters

@property lets you use attribute-style access while running code behind the scenes.

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

t = Temperature(25)
print(t.celsius)     # 25
print(t.fahrenheit)  # 77.0
t.celsius = 100
print(t.fahrenheit)  # 212.0

Using Properties for Validation

Properties enforce data integrity by validating values before setting them.

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade  # calls setter

    @property
    def grade(self):
        return self._grade

    @grade.setter
    def grade(self, value):
        if not 0 <= value <= 100:
            raise ValueError(f"Grade must be 0-100, got {value}")
        self._grade = value

s = Student("Alice", 95)
print(s.grade)   # 95
s.grade = 110    # Raises ValueError

Read-Only Properties

Omit the setter to make a property read-only.

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self): return self._radius

    @property
    def area(self):   # Computed, read-only
        import math
        return math.pi * self._radius ** 2

c = Circle(5)
print(round(c.area, 2))  # 78.54
# c.area = 100           # AttributeError: can't set

Encapsulation in Python: Convention, Not Enforcement

Python has no truly private attributes. Instead it uses naming conventions plus a light "name mangling" trick. The philosophy: "we're all adults here" — signal intent, don't build walls.

class Account:
    def __init__(self):
        self._balance = 0          # protected by convention

    @property
    def balance(self):             # read-only public interface
        return self._balance

    @balance.setter
    def balance(self, amt):
        if amt < 0:
            raise ValueError("negative balance")
        self._balance = amt

a = Account()
a.balance = 100     # goes through the setter — validated
a.balance = -5      # ValueError

The @property pattern is the real tool: expose attributes directly, but route reads/writes through methods so you can validate or compute without changing the public API. Start with a plain attribute; promote it to a property only when you need logic. Double-underscore mangling is mainly for avoiding name clashes in subclasses, not security.

Interview Questions on Encapsulation

• What is encapsulation and why is it useful?
• Does Python have truly private attributes?
• What is the difference between a single underscore (_x) and double underscore (__x) prefix?
• What is name mangling and when does it happen?
• How does the @property decorator work?
• How do you create a read-only attribute in Python?
• Why use a property instead of a plain attribute?

Related Topics