Encapsulation Checkpoint and Interactive Lab

20 min · Intermediate

This hands-on checkpoint synthesizes everything you have learned about encapsulation, private conventions, and properties. You will construct a production-ready BankAccount model that enforces business rules and audits transactions.

The BankAccount Domain Rules

Your BankAccount class must satisfy four strict business requirements:

Owner validation: Name must be a non-empty string; strip leading/trailing spaces.
Balance protection: Initial balance must be non-negative; balance cannot be directly mutated without validation.
Deposit method: Only positive amounts accepted; increment balance.
Withdraw method: Amount must be positive and cannot exceed current balance; decrement balance.

Guarding Invariants

Class invariant is a rule that every object of the class must always satisfy, such as balance >= 0. Methods that change state must check it before they save the change.

A bank account balance can never drop below zero. By encapsulating _balance behind property getters and dedicated transaction methods, callers cannot bypass business logic.

Python

1class BankAccount:2    def __init__(self, owner, initial_balance=0.0):3        self.owner = owner4        if initial_balance < 0:5            raise ValueError("Initial balance cannot be negative")6        self._balance = float(initial_balance)7        self._transactions = []

Example 1 · Withdraw that cannot overdraw

Python

1class Account:2    def __init__(self, owner, balance=0):3        self.owner = owner4        self._balance = balance5
6    @property7    def balance(self):8        return self._balance9
10    def withdraw(self, amount):11        if amount > self._balance:12            raise ValueError("insufficient funds")13        self._balance -= amount14
15acct = Account("Neha", 500)16acct.withdraw(200)17try:18    acct.withdraw(900)19except ValueError as e:20    print(e)21print(acct.balance)

Output

insufficient funds
300

What this code does

The check runs before the change, so a failed withdrawal leaves the balance as it was.
balance has no setter, so callers must use withdraw.

Notice _transactions is protected, keeping the transaction history safe from external corruption.

Audit Log Recording

Every time money moves, append an immutable record to self._transactions.

Python

def deposit(self, amount):    if amount <= 0:        raise ValueError("Deposit amount must be positive")    self._balance += amount    self._transactions.append(f"+{amount:.2f}")

Example 2 · Read-only view of the history

Python

1class Account:2    def __init__(self):3        self._history = []4
5    def deposit(self, amount):6        self._history.append(amount)7
8    @property9    def history(self):10        return tuple(self._history)11
12acct = Account()13acct.deposit(100)14acct.deposit(50)15view = acct.history16print(view)17try:18    view.append(999)19except AttributeError:20    print("history is read-only")21print(len(acct.history))

Output

(100, 50)
history is read-only
2

What this code does

Returning a tuple gives the caller a copy that cannot be changed.
Returning self._history itself would let outside code edit the audit log.

Example 3 · Statement built from the log

Python

1class Account:2    def __init__(self):3        self._log = []4
5    def deposit(self, amount):6        self._log.append(("deposit", amount))7
8    def withdraw(self, amount):9        self._log.append(("withdraw", amount))10
11    def statement(self):12        return [f"{kind}: {amount}" for kind, amount in self._log]13
14acct = Account()15acct.deposit(300)16acct.withdraw(120)17for line in acct.statement():18    print(line)

Output

deposit: 300
withdraw: 120

What this code does

The log is private state; statement is the public way to read it.
The class can change how it stores entries without breaking callers.

This pattern models real-world double-entry accounting engines.

Interactive Verification

Test both valid execution paths and edge cases (attempting negative deposits or overdrafts) to ensure your model behaves reliably under all conditions.

Verify normal operations produce correct balances.
Verify invalid operations raise expected ValueError exceptions.
Confirm internal state remains untouched when an exception is raised.

Next step

Check your understanding

12 quick questions

Guarding Invariants

Class invariant is a rule that every object of the class must always satisfy, such as balance >= 0. Methods that change state must check it before they save the change.

A bank account balance can never drop below zero. By encapsulating _balance behind property getters and dedicated transaction methods, callers cannot bypass business logic.

1class BankAccount:2 def __init__(self, owner, initial_balance=0.0):3 self.owner = owner4 if initial_balance < 0:5 raise ValueError("Initial balance cannot be negative")6 self._balance = float(initial_balance)7 self._transactions = []

1class Account:2 def __init__(self, owner, balance=0):3 self.owner = owner4 self._balance = balance5 6 @property7 def balance(self):8 return self._balance9 10 def withdraw(self, amount):11 if amount > self._balance:12 raise ValueError("insufficient funds")13 self._balance -= amount14 15acct = Account("Neha", 500)16acct.withdraw(200)17try:18 acct.withdraw(900)19except ValueError as e:20 print(e)21print(acct.balance)

1class Account:2 def __init__(self):3 self._history = []4 5 def deposit(self, amount):6 self._history.append(amount)7 8 @property9 def history(self):10 return tuple(self._history)11 12acct = Account()13acct.deposit(100)14acct.deposit(50)15view = acct.history16print(view)17try:18 view.append(999)19except AttributeError:20 print("history is read-only")21print(len(acct.history))

1class Account:2 def __init__(self):3 self._log = []4 5 def deposit(self, amount):6 self._log.append(("deposit", amount))7 8 def withdraw(self, amount):9 self._log.append(("withdraw", amount))10 11 def statement(self):12 return [f"{kind}: {amount}" for kind, amount in self._log]13 14acct = Account()15acct.deposit(300)16acct.withdraw(120)17for line in acct.statement():18 print(line)