Lesson 18: Encapsulation, Properties & Magic Methods

Encapsulation — Protecting Data

Encapsulation keeps an object's internal state safe by controlling how it is read and changed. Python uses conventions and tools rather than hard enforcement:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance    # protected by convention

Mental model: _ is a "staff only" sign. Nothing in Python stops you from entering — but the convention says "you probably shouldn't". __ (double underscore) actually renames the attribute internally, making accidental access fail loudly.

What You'll Learn in This Lesson

• Protect internal state with private conventions
• Build smart attribute access with @property
• Customize objects with magic (dunder) methods

Name Mangling — How __ Works

self.__balance is renamed by Python to self._ClassName__balance at runtime:

class Account:
    def __init__(self):
        self.__secret = 42

acc = Account()
# print(acc.__secret)   # AttributeError! renamed internally
print(acc._Account__secret)   # 42 — the mangled name

The double underscore exists mainly to prevent accidental clashes in inheritance — a child class can't accidentally overwrite the parent's __secret. It is not true security.

@property — Smart Attribute Access

The @property decorator turns a method into an attribute. account.balance reads like plain data but runs code:

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance

    @property
    def balance(self):              # read like an attribute
        return self._balance

    @balance.setter
    def balance(self, amount):      # validate on write
        if amount < 0:
            raise ValueError("Balance cannot be negative")
        self._balance = amount

acc = BankAccount("Amol", 1000)
print(acc.balance)                  # 1000 — no parentheses!
acc.balance = 1500                  # setter validates

Why bother? You can add validation now without breaking existing code that reads acc.balance as a plain attribute.

Mental model: @property is a guarded door. Reading is safe; writing goes through a check (the setter).

The getter-only property (read-only): omit the @setter and the attribute becomes read-only — assignment raises AttributeError. Perfect for computed values:

class Rectangle:
    def __init__(self, w, h):
        self.w, self.h = w, h

    @property
    def area(self):          # computed, read-only
        return self.w * self.h

r = Rectangle(3, 4)
print(r.area)    # 12
# r.area = 99    # AttributeError: can't set attribute

Magic (Dunder) Methods — Customize Your Objects

Double-underscore methods ("dunder" = double underscore) hook your objects into Python's operators and built-ins:

class BankAccount:
    ...
    def __str__(self):
        return f"{self.owner}'s account: Rs.{self._balance}"

    def __eq__(self, other):
        return self._balance == other._balance

print(acc)                    # Amol's account: Rs.1000  (uses __str__)
print(acc == other)           # uses __eq__

str vs repr: str() is for people; repr() is for developers. Implement both; __str__ falls back to __repr__ if missing.

More dunder methods worth knowing:

Implementing __eq__ and __lt__ together gives you ==, sorting, and min/max for free — professional objects behave exactly like built-ins.

Common Mistakes to Avoid

• Mistake: Forgetting self in property methods — Fix: properties are methods; self first.
• Mistake: Naming a property and its backing attribute the same (self.balance + @property balance) — Fix: back it with self._balance.
• Mistake: Implementing only __eq__ without __hash__ and putting objects in sets — Fix: if you define __eq__, set __hash__ = None or define __hash__ explicitly.
• Mistake: Expecting __ attributes to be truly private — Fix: it's name mangling, not security; use _ for the convention.
• Mistake: Returning a value from a setter — Fix: setters must return None.

Professional Tips & Tricks

• Use @property to add validation without breaking existing code that reads attributes.
• Always implement __str__ for user-facing classes — debugging and printing become readable.
• Implement __eq__ and __lt__ together so your objects work with ==, sorting, and min/max.
• Use getter-only properties for computed values that must stay consistent.
• Prefer _ conventions over __ for most "private" data — simpler and idiomatic.

Key Takeaways

• Encapsulation controls access to internal state: _name by convention, __name via name mangling.
• @property + @setter give attribute-like access with validation.
• Dunder methods hook objects into Python operators and built-ins.
• Implement __str__, __repr__, __eq__, and __lt__ for professional objects.
• Getter-only properties make clean, computed, read-only attributes.

Next up: Dataclasses — modern, boilerplate-free OOP.