Encapsulation

Introduction

Imagine a bank account object that lets any piece of code directly set its balance to a negative number, or a car object that lets you set its speed to -50. Without some way to protect internal data, objects can end up in states that make no sense. Encapsulation is the OOP principle that solves this problem.

In this lesson you will learn what encapsulation means, how Python approaches "privacy" differently from languages like Java or C++, and how to control access to an object's internal state using naming conventions and the @property decorator.

What is Encapsulation?

Encapsulation means bundling data (attributes) and the methods that operate on that data into a single unit — a class — while restricting direct, uncontrolled access to some of that data from outside the class. Instead of letting outside code poke at internal values freely, the class exposes a controlled interface for reading or changing them.

You have already been using encapsulation informally since Lesson 35 — every class bundles attributes and methods together. This lesson focuses specifically on the "restricting access" half of that definition.

Public Attributes (The Default)

By default, every attribute in Python is public, meaning any code outside the class can read or modify it directly.

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

acc = Account("Riya", 1000)
print(acc.balance)

acc.balance = -5000   # Nothing stops this!
print(acc.balance)

1000
-5000

Nothing prevented us from setting an invalid, negative balance. This is exactly the problem encapsulation is designed to prevent.

Protected Attributes: Single Underscore

Prefixing an attribute name with a single underscore (for example _balance) is a convention that signals "this is intended for internal use — treat it as protected, not part of the public interface." Python does not actually enforce this; it is purely a signal to other developers (and to tools like IDEs and linters).

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

acc = Account("Riya", 1000)
print(acc._balance)   # still accessible, but discouraged

1000

Private Attributes: Double Underscore

Prefixing an attribute with two leading underscores (for example __balance) triggers Python's name mangling, which makes the attribute much harder — though still not impossible — to access accidentally from outside the class.

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance   # name-mangled

    def get_balance(self):
        return self.__balance

acc = Account("Riya", 1000)
print(acc.get_balance())

try:
    print(acc.__balance)
except AttributeError as e:
    print("Error:", e)

1000
Error: 'Account' object has no attribute '__balance'

Name Mangling

When Python sees an attribute named __balance inside a class named Account, it internally renames it to _Account__balance. This is called name mangling, and it is why accessing acc.__balance from outside fails, while the attribute still technically exists (and is reachable) under its mangled name.

acc = Account("Riya", 1000)
print(acc._Account__balance)   # works, but you should never write this

1000

Getters and Setters

A common pattern for controlling access to a private attribute is to write explicit getter and setter methods: a method to retrieve the value, and a method to change it, with the setter validating the new value before accepting it.

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance

    def get_balance(self):
        return self.__balance

    def set_balance(self, amount):
        if amount < 0:
            print("Balance cannot be negative.")
        else:
            self.__balance = amount

acc = Account("Riya", 1000)
acc.set_balance(-500)
print(acc.get_balance())

acc.set_balance(2500)
print(acc.get_balance())

Balance cannot be negative.
1000
2500

The setter rejects the invalid value, so the object never enters an invalid state. This is the core benefit of encapsulation in action.

The @property Decorator

Calling get_balance() and set_balance() everywhere works, but it is a bit clunky compared to plain attribute access. Python offers the @property decorator, which lets a method be accessed using attribute syntax (no parentheses) while still running your validation logic behind the scenes.

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance

    @property
    def balance(self):
        """Getter"""
        return self.__balance

    @balance.setter
    def balance(self, amount):
        """Setter"""
        if amount < 0:
            raise ValueError("Balance cannot be negative.")
        self.__balance = amount

acc = Account("Riya", 1000)
print(acc.balance)      # reads like an attribute, calls the getter

acc.balance = 3000      # looks like assignment, calls the setter
print(acc.balance)

try:
    acc.balance = -100
except ValueError as e:
    print("Error:", e)

1000
3000
Error: Balance cannot be negative.

Why Encapsulation Matters

Encapsulation is not just about hiding things for the sake of it — it directly improves how maintainable and reliable your code is.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Encapsulation protects an object's internal state by controlling how it can be read or changed. Python achieves this not through strict access modifiers, but through naming conventions — single underscores for protected attributes, double underscores for name-mangled ones — combined with getter/setter methods or the cleaner @property decorator.

With encapsulation covered, you are ready to explore inheritance — how classes can build on top of one another to reuse and extend behavior.