Book 01 · Programming FundamentalsPage 17 of 56

Encapsulation

Q: Does Python support encapsulation?

Python has no enforced private keyword. By convention a leading underscore, as in _balance, marks a member as internal, and a double underscore triggers name mangling, which makes accidental access from outside harder but not impossible.

In Turkish: Kapsülleme

Updated September 30, 20262 min read

In short

Encapsulation is the practice of bundling data with the methods that use it and hiding internal details, so outside code works only through a public interface.

What is encapsulation in programming?

Encapsulation means keeping an object's data and the code that works on that data together in one unit, usually a class, and hiding the internal details from the rest of the program. Outside code interacts through a small set of public methods instead of reading and changing the data directly. It is one of the core principles of object-oriented programming, together with inheritance, polymorphism, and abstraction.

Languages enforce encapsulation with access modifiers, keywords that control who can see a member. In Java, C#, and TypeScript, private members can be used only inside their own class while public members form the outside interface; JavaScript marks private fields with a # prefix, and Python relies on the convention of starting a name with an underscore. Because every change goes through methods, the class can validate input and keep its data consistent, for example by refusing to let a bank balance go negative.

A car is a good analogy: you drive with the steering wheel and pedals and never touch the fuel injectors or time the spark plugs yourself. Because those internals are hidden, the manufacturer can redesign the engine without changing how you drive, just as a class can change its internal code without breaking the code that uses it.

Encapsulation is often confused with abstraction. Abstraction is about deciding which essential features an object exposes and ignoring the rest, while encapsulation is the mechanism that bundles the data and hides everything else. Adding a public getter and setter for every private field gives little real encapsulation, since outside code can still change anything; good encapsulation exposes meaningful operations such as deposit() instead.

Key takeaways

Encapsulation bundles data and the methods that operate on it in one unit.
Access modifiers such as private and public control what outside code can see.
All changes go through methods, which can validate input and keep data consistent.
Internals can change without breaking code that uses the public interface.
Abstraction decides what to expose; encapsulation hides the rest.

Example

A class with a private field in JavaScriptjavascript

class BankAccount {
  #balance = 0; // private: only code inside the class can touch it
  deposit(amount) {
    if (amount <= 0) throw new Error("Deposit must be positive");
    this.#balance += amount;
  }
  get balance() {
    return this.#balance; // read-only from the outside
  }
}

const account = new BankAccount();
account.deposit(50);
console.log(account.balance); // 50
// account.#balance = 1000000; // SyntaxError: private field

Readers ask

What is the difference between encapsulation and abstraction?

Abstraction is about exposing only the essential features of something, such as a send() method on an email client. Encapsulation is how you achieve that in code: bundling data with its methods and hiding the internal details behind access modifiers.

Why is encapsulation important?

It protects data from being changed in invalid ways, keeps related code in one place, and lets you change a class's internals without breaking the code that uses it. That makes large programs easier to maintain and debug.

Does Python support encapsulation?

Python has no enforced private keyword. By convention a leading underscore, as in _balance, marks a member as internal, and a double underscore triggers name mangling, which makes accidental access from outside harder but not impossible.