Understanding Data Encapsulation and Private Attributes in Object‑Oriented Programming (Python Examples)

Data encapsulation is a core concept of object‑oriented programming that binds data together with the operations that manipulate it, hiding internal implementation details and exposing only necessary information to the outside world.

Many OOP languages such as Java and C++ provide access modifiers (public, private, protected) to control the visibility of class members. The private modifier is the most restrictive, allowing access only within the class where the member is declared.

Private attributes serve three main purposes: they hide implementation details, enhance security by preventing external code from modifying the object's state, and improve maintainability because changes to the attribute can be made internally without affecting external code.

Below is a simple Python class that demonstrates the use of a private attribute __balance to store an account balance.

class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance  # private attribute
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False
    def withdraw(self, amount):
        if amount <= self.__balance and amount > 0:
            self.__balance -= amount
            return True
        return False
    def get_balance(self):
        return self.__balance

# Create BankAccount object
account = BankAccount()
account.deposit(100)
print(account.get_balance())  # Output: 100
account.withdraw(50)
print(account.get_balance())  # Output: 50
# Attempting direct access to the private attribute will fail
print(account.__balance)

In this example, __balance cannot be accessed directly from outside the class, but the public methods deposit , withdraw , and get_balance provide controlled interaction with the private data.

Advanced examples illustrate additional patterns:

Example 1 – Simple class with multiple private attributes

class Account:
    def __init__(self, account_number, balance=0):
        self.__account_number = account_number  # private attribute
        self.__balance = balance  # private attribute
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
    def get_balance(self):
        return self.__balance

# Use Account class
acc = Account("123456789")
acc.deposit(1000)
acc.withdraw(500)
print(acc.get_balance())  # Output: 500

Example 2 – Private method

class Calculator:
    def __init__(self):
        self.__result = 0  # private attribute
    def add(self, num):
        self.__result += num
    def subtract(self, num):
        self.__result -= num
    def get_result(self):
        return self.__result
    def reset(self):
        self.__result = 0
    def __operate(self, operation, num):
        # private method, used internally only
        if operation == "add":
            self.add(num)
        elif operation == "subtract":
            self.subtract(num)

# Use Calculator class
calc = Calculator()
calc.__operate("add", 10)
calc.__operate("subtract", 5)
print(calc.get_result())  # Output: 5

Example 3 – Inheritance with private attributes

class BaseCar:
    def __init__(self, brand):
        self.__brand = brand  # private attribute
    def get_brand(self):
        return self.__brand

class SportsCar(BaseCar):
    def __init__(self, brand, model):
        super().__init__(brand)
        self.__model = model  # private attribute
    def get_model(self):
        return self.__model

# Use SportsCar class
car = SportsCar("Ferrari", "488 GTB")
print(car.get_brand())  # Output: Ferrari
print(car.get_model())  # Output: 488 GTB

Example 4 – Property decorator for controlled access

class User:
    def __init__(self, username):
        self.__username = username  # private attribute
    @property
    def username(self):
        return self.__username
    @username.setter
    def username(self, value):
        if isinstance(value, str):
            self.__username = value
        else:
            raise ValueError("Username must be a string")

# Use User class
u = User("john_doe")
print(u.username)  # Output: john_doe
u.username = "jane_doe"
print(u.username)  # Output: jane_doe

Example 5 – Descriptor for value validation

class NonNegative:
    def __init__(self, value=0):
        self.value = value
    def __get__(self, instance, owner):
        return self.value
    def __set__(self, instance, value):
        if value >= 0:
            self.value = value
        else:
            raise ValueError("Value must be non-negative")

class Order:
    total_price = NonNegative()
    def __init__(self, total_price):
        self.total_price = total_price

# Use Order class
order = Order(100)
print(order.total_price)  # Output: 100
order.total_price = 200
print(order.total_price)  # Output: 200
try:
    order.total_price = -100
except ValueError as e:
    print(e)  # Output: Value must be non-negative

These examples demonstrate how private attributes and methods can be used to protect data, enforce invariants, and provide a clean public interface in Python classes.