Purpose of encapsulation in Python - Mini Project: Build & Apply

Understanding the Purpose of Encapsulation in Python

📖 Scenario: Imagine you are creating a simple bank account system. You want to keep the account balance safe so that no one can change it directly by mistake. Instead, you want to control how the balance is changed using special methods.

🎯 Goal: Build a Python class that shows how encapsulation protects the account balance by making it private and allowing controlled access through methods.

📋 What You'll Learn

Create a class called BankAccount with a private variable __balance set to 1000

Add a method deposit that adds money to __balance

Add a method withdraw that subtracts money from __balance only if there is enough balance

Add a method get_balance that returns the current __balance

Show that direct access to __balance is not allowed

💡 Why This Matters

🌍 Real World

Encapsulation is used in real bank software to protect account balances and prevent unauthorized changes.

💼 Career

Understanding encapsulation is important for writing safe and reliable code in software development jobs.

1

Create the BankAccount class with a private balance

Create a class called BankAccount with a private variable __balance set to 1000 inside the __init__ method.

Python

class BankAccount:
    def __init__(self):
        # Your code here

Hint

Use self.__balance = 1000 inside the __init__ method to make the balance private.

2

Add deposit and withdraw methods

Add a method called deposit that takes amount and adds it to self.__balance. Add another method called withdraw that takes amount and subtracts it from self.__balance only if self.__balance is greater than or equal to amount.

Python

class BankAccount:
    def __init__(self):
        self.__balance = 1000

    # Your code here

Hint

Use self.__balance += amount in deposit and check balance before subtracting in withdraw.

3

Add a method to get the current balance

Add a method called get_balance that returns the value of self.__balance.

Python

class BankAccount:
    def __init__(self):
        self.__balance = 1000

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount

    # Your code here

Hint

Return the private variable self.__balance in the get_balance method.

4

Show encapsulation by using the class and printing the balance

Create an object called account from BankAccount. Use deposit(500) and withdraw(200) methods on account. Then print the balance using print(account.get_balance()). Also, try to print account.__balance to show it is not accessible.

Python

class BankAccount:
    def __init__(self):
        self.__balance = 1000

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# Your code here

Hint

Use the methods to change balance and print it. Accessing __balance directly should cause an error.

Practice

1. What is the main purpose of encapsulation in Python classes?

easy

A. To allow unlimited access to all variables

B. To hide internal data and protect it from outside access

C. To make the program run faster

D. To print data directly to the screen

Solution

1. Step 1: Understand encapsulation concept

   Encapsulation means hiding data inside a class to protect it from outside changes.

2. Step 2: Identify the main goal

   The goal is to keep data safe and control access through methods.

3. Final Answer:

   To hide internal data and protect it from outside access -> Option B

4. Quick Check:

   Encapsulation = Data protection [OK]

Hint: Encapsulation means hiding data inside classes [OK]

Common Mistakes:

• Thinking encapsulation speeds up code
• Believing encapsulation allows free access
• Confusing encapsulation with printing data

2. Which of the following is the correct way to make a variable private in a Python class?

easy

A. variable

B. _variable

C. __variable

D. public_variable

Solution

1. Step 1: Recall Python private variable syntax

   In Python, prefixing a variable with double underscore __ makes it private.

2. Step 2: Compare options

   Only __variable uses double underscore, so it is private.

3. Final Answer:

   __variable -> Option C

4. Quick Check:

   Double underscore = private variable [OK]

Hint: Use double underscore to make variables private [OK]

Common Mistakes:

• Using single underscore which is only a convention
• Using no underscore which is public
• Confusing variable names with public keywords

3. What will be the output of this code?

class Box:
    def __init__(self):
        self.__content = 'secret'
    def reveal(self):
        return self.__content

b = Box()
print(b.reveal())
print(b.__content)

medium

A. secret
secret

B. AttributeError
AttributeError

C. AttributeError
secret

D. secret
AttributeError

Solution

1. Step 1: Understand private variable access

   The variable __content is private and cannot be accessed directly outside the class.

2. Step 2: Check print statements

   Calling b.reveal() returns 'secret'. But b.__content causes AttributeError because it's private.

3. Final Answer:

   secret AttributeError -> Option D

4. Quick Check:

   Private variable accessed via method only [OK]

Hint: Private variables cause error if accessed directly [OK]

Common Mistakes:

• Expecting direct access to private variables
• Ignoring AttributeError on private access
• Assuming private variables print normally

4. Find the error in this code related to encapsulation:

class Person:
    def __init__(self, name):
        self.__name = name

p = Person('Anna')
print(p.__name)

medium

A. AttributeError because __name is private

B. SyntaxError due to private variable

C. No error, prints 'Anna'

D. TypeError because __name is missing

Solution

1. Step 1: Identify private variable usage

   The variable __name is private and cannot be accessed directly outside the class.

2. Step 2: Analyze print statement

   Trying to print p.__name causes AttributeError because it is private.

3. Final Answer:

   AttributeError because __name is private -> Option A

4. Quick Check:

   Private variables cause AttributeError on direct access [OK]

Hint: Private variables cause AttributeError if accessed directly [OK]

Common Mistakes:

• Thinking private variables print normally
• Confusing syntax error with attribute error
• Trying to access private variables without methods

5. You want to protect a bank account balance so it cannot be changed directly. Which encapsulation approach is best?

hard

A. Use a private variable for balance and provide methods to deposit and withdraw

B. Make balance a public variable and change it anywhere

C. Use global variables for balance

D. Print balance directly without storing it

Solution

1. Step 1: Understand the need for protection

   Bank balance should not be changed directly to avoid mistakes or fraud.

2. Step 2: Apply encapsulation best practice

   Use a private variable for balance and provide public methods to safely update it.

3. Final Answer:

   Use a private variable for balance and provide methods to deposit and withdraw -> Option A

4. Quick Check:

   Private variable + methods = safe data access [OK]

Hint: Use private variables with methods to control changes [OK]

Common Mistakes:

• Making balance public and changing it anywhere
• Using global variables which are unsafe
• Not controlling how balance is updated