Python Encapsulation

Learning Objectives

By the end of this lesson, you will understand how encapsulation helps control access to data and behavior inside Python classes.

What Is Encapsulation?

Encapsulation is the practice of keeping data and the methods that operate on that data together inside a class while controlling how the internal data is accessed.

In simple terms, encapsulation means:

Imagine a bank account. The account has an internal balance. You should not allow every part of the program to freely change that balance.

Instead, the account can provide methods such as:

deposit()
withdraw()
get_balance()

These methods can apply rules before changing or returning the account's internal state.

Why Encapsulation Matters

Without proper control over object data, other parts of a program may accidentally put objects into invalid states.

Consider this simple class:

class BankAccount:

    def __init__(self, balance):
        self.balance = balance


account = BankAccount(5000)

account.balance = -100000

print(account.balance)

-100000

The program allowed the balance to be changed directly, even though a negative balance may not be valid for the application's business rules.

Encapsulation lets us create controlled access and validation.

Classes and Data

When we create an object, its attributes represent the object's state.

class Student:

    def __init__(self, name, age):
        self.name = name
        self.age = age


student = Student("Ali", 20)

print(student.name)
print(student.age)

Ali
20

Both attributes are directly accessible because they are public attributes.

Python provides naming conventions that help developers communicate how attributes should be accessed.

Public Members

A normal attribute or method is considered public.

Public members can normally be accessed from outside the class.

class Product:

    def __init__(self, name, price):
        self.name = name
        self.price = price


product = Product("Laptop", 120000)

print(product.name)
print(product.price)

Here, both name and price are public attributes.

They can also be changed directly:

product.price = 110000

Protected Members

Python uses a single underscore before a name to indicate that a member is intended for internal or subclass use.

Example:

class Employee:

    def __init__(self, name, salary):
        self.name = name
        self._salary = salary


employee = Employee("Ali", 80000)

print(employee.name)
print(employee._salary)

Python does not technically prevent access to _salary.

The underscore is a convention telling developers:

This is different from languages that enforce protected access through strict access modifiers.

Private Members

Python uses a double underscore at the beginning of a name to trigger name mangling.

class BankAccount:

    def __init__(self, balance):
        self.__balance = balance

    def show_balance(self):
        print(self.__balance)


account = BankAccount(5000)

account.show_balance()

5000

The double underscore changes how Python stores the attribute name internally.

Direct access like this:

account.__balance

will not work normally.

Understanding Name Mangling

When Python encounters an attribute such as:

self.__balance

inside a class named BankAccount, Python internally transforms the name approximately into:

_BankAccount__balance

This process is called name mangling.

class BankAccount:

    def __init__(self, balance):
        self.__balance = balance


account = BankAccount(5000)

print(account._BankAccount__balance)

5000

Private Methods

Methods can also use the double underscore convention.

class Order:

    def __calculate_tax(self, amount):
        return amount * 0.10

    def final_price(self, amount):
        tax = self.__calculate_tax(amount)
        return amount + tax


order = Order()

print(order.final_price(1000))

1100.0

The internal tax calculation is hidden behind the public-facing final_price() method.

This makes the class easier to use because users of the class do not need to understand every internal calculation.

Getters

A getter is a method used to retrieve the value of an internal attribute.

class BankAccount:

    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance


account = BankAccount(5000)

print(account.get_balance())

5000

Instead of exposing the internal attribute directly, the class controls how the balance is retrieved.

Setters

A setter is a method used to modify an internal value while applying rules or validation.

class Student:

    def __init__(self, marks):
        self.__marks = marks

    def get_marks(self):
        return self.__marks

    def set_marks(self, marks):

        if 0 <= marks <= 100:
            self.__marks = marks
        else:
            print("Marks must be between 0 and 100.")


student = Student(85)

student.set_marks(92)

print(student.get_marks())

student.set_marks(150)

92
Marks must be between 0 and 100.

The setter prevents invalid values from entering the object's state.

The property() Function

Python provides the built-in property() function to create controlled attribute access.

A basic property can connect a getter and setter to an attribute-like interface.

class Student:

    def __init__(self, marks):
        self._marks = marks

    def get_marks(self):
        return self._marks

    def set_marks(self, marks):

        if 0 <= marks <= 100:
            self._marks = marks
        else:
            raise ValueError("Marks must be between 0 and 100.")

    marks = property(get_marks, set_marks)


student = Student(80)

print(student.marks)

student.marks = 95

print(student.marks)

80
95

Notice that we use:

student.marks

instead of:

student.get_marks()

This provides a cleaner interface.

The @property Decorator

In modern Python code, the @property decorator is usually more readable than manually creating a property().

class Student:

    def __init__(self, marks):
        self._marks = marks

    @property
    def marks(self):
        return self._marks

    @marks.setter
    def marks(self, value):

        if 0 <= value <= 100:
            self._marks = value
        else:
            raise ValueError(
                "Marks must be between 0 and 100."
            )


student = Student(85)

print(student.marks)

student.marks = 95

print(student.marks)

85
95

The getter is defined using:

@property

The setter is connected using:

@marks.setter

Data Validation

One of the most useful applications of encapsulation is validation.

Suppose an e-commerce product must have a positive price.

class Product:

    def __init__(self, name, price):
        self.name = name
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):

        if value < 0:
            raise ValueError(
                "Price cannot be negative."
            )

        self._price = value


product = Product("Laptop", 120000)

print(product.price)

product.price = 110000

print(product.price)

120000
110000

Now try:

product.price = -5000

The setter raises a ValueError instead of allowing an invalid price.

Read-Only Properties

A property does not always need a setter.

If you define only a getter, the property can effectively become read-only through the normal public interface.

class Circle:

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

    @property
    def area(self):
        return 3.14159 * self._radius ** 2


circle = Circle(5)

print(circle.area)

78.53975

There is no setter for area because the area is calculated from the radius.

A user can read:

circle.area

but should not directly assign a new area.

Real-World Examples

Encapsulation appears naturally in many real-world software systems.

Banking Applications

A bank account can protect its balance and expose controlled operations such as:

• deposit()
• withdraw()
• get_balance()

E-commerce Systems

A product can validate its price, stock quantity, discount, and other business rules.

User Accounts

Internal account information can be managed through methods instead of allowing unrestricted changes.

Employee Systems

Salary, employee status, and other attributes may require validation before being changed.

Inventory Systems

Stock quantities can be protected so that an order cannot accidentally reduce stock below an allowed value.

Benefits and Limitations

Benefits

• Protects object state from accidental modification.
• Allows validation before changing data.
• Keeps internal implementation details organized.
• Makes classes easier to maintain.
• Provides a cleaner public interface.
• Allows internal implementation to change without changing how users interact with the class.

Limitations

• Too many getters and setters can create unnecessary complexity.
• Python's access control is based heavily on conventions.
• Name mangling is not a security mechanism.
• Overengineering simple classes can make code harder to read.

Common Mistakes

1. Thinking a Single Underscore Creates True Privacy

A single underscore is mainly a convention.

self._salary

can still technically be accessed from outside the class.

2. Treating Double Underscore as Security

Name mangling does not encrypt or securely hide data.

3. Creating Getters and Setters for Everything

Not every attribute needs a getter and setter. If direct access is safe and clear, a public attribute may be better.

4. Forgetting Validation

A setter becomes much more useful when it protects the object's state.

5. Raising the Wrong Exception

Use an appropriate exception such as ValueError when a value is invalid.

6. Confusing Encapsulation with Abstraction

Encapsulation focuses on controlling access to internal state and implementation details. Abstraction focuses on exposing essential behavior while hiding unnecessary complexity.

Practice Exercises

Try these exercises yourself before moving to the challenge.

Mini Challenge — Secure Product System

Requirements

1. Create a class called Product.
2. Store the product name.
3. Store price internally.
4. Store stock internally.
5. Create a property called price.
6. Prevent negative prices.
7. Create a property called stock.
8. Prevent negative stock.
9. Create a method called sell(quantity).
10. Prevent customers from buying more items than available.

class Product:

    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):

        if value < 0:
            raise ValueError(
                "Price cannot be negative."
            )

        self._price = value

    @property
    def stock(self):
        return self._stock

    @stock.setter
    def stock(self, value):

        if value < 0:
            raise ValueError(
                "Stock cannot be negative."
            )

        self._stock = value

    def sell(self, quantity):

        if quantity <= 0:
            raise ValueError(
                "Quantity must be positive."
            )

        if quantity > self.stock:
            raise ValueError(
                "Not enough stock available."
            )

        self.stock -= quantity


product = Product("Laptop", 120000, 10)

print(product.price)
print(product.stock)

product.sell(2)

print(product.stock)

120000
10
8

Quick Knowledge Check

Test your understanding of encapsulation.

Lesson Summary

Encapsulation is an important principle of object-oriented programming that helps control how an object's internal state is accessed and modified.