Python Encapsulation

« Previous Next »

Python Encapsulation

Encapsulation is an object-oriented programming concept that focuses on hiding internal data and allowing access only through controlled methods.

In Python, encapsulation:

    • Keeps data (variables) and behavior (methods) together inside a class

    • Restricts direct access to sensitive data

    • Protects objects from accidental misuse

This improves data safety, control, and maintainability.

Private Properties

Python allows you to make class properties private by using a double underscore (__) before the variable name.

Example

Create a private property inside a class:

class Account: def __init__(self, owner, balance): self.owner = owner self.__balance = balance # Private property acc = Account("Rahul", 10000) print(acc.owner) # print(acc.__balance) # This will raise an error

Try it Yourself

Note:

Private properties cannot be accessed directly from outside the class.

Accessing Private Data (Getter Method)

To read a private value safely, you should create a getter method.

Example

Using a getter to access a private property:

class Account: def __init__(self, owner, balance): self.owner = owner self.__balance = balance def get_balance(self): return self.__balance acc = Account("Sneha", 15000) print(acc.get_balance())

Try it Yourself

Modifying Private Data (Setter Method)

To update private data, use a setter method.

Setter methods can also validate values before saving them.

Example

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: self.__balance = amount else: print("Balance cannot be negative") acc = Account("Sneha", 15000) print(acc.get_balance()) acc.set_balance(18000) print(acc.get_balance())

Try it Yourself

Why Encapsulation Is Important

Encapsulation offers several advantages:

    • Data Protection: Prevents unauthorized access

    • Validation: Ensures correct data values

    • Flexibility: Internal code can change without affecting users

    • Control: You decide how data is read or modified

Practical Encapsulation Example

Example

Encapsulating and validating marks in a class:

class ExamResult: def __init__(self, student_name): self.student_name = student_name self.__marks = 0 def set_marks(self, marks): if 0 <= marks <= 100: self.__marks = marks else: print("Marks must be between 0 and 100") def get_marks(self): return self.__marks def get_result(self): return "Pass" if self.__marks >= 40 else "Fail" result = ExamResult("Amit") result.set_marks(78) print(result.get_marks()) print(result.get_result())

Try it Yourself

Protected Properties

Python uses a single underscore (_) as a convention for protected members.

Protected properties:

    • Are meant for internal use

    • Can still be accessed, but should not be used directly

Example

Using a protected property:

class Employee: def __init__(self, name, bonus): self.name = name self._bonus = bonus # Protected property emp = Employee("Kiran", 5000) print(emp.name) print(emp._bonus) # Allowed, but discouraged

Try it Yourself

Note:

Protected members are not enforced by Python—this is a naming convention only.

Private Methods

Just like properties, methods can also be made private using double underscores.

Example

Creating a private method:

class MathTool: def __init__(self): self.total = 0 def __is_valid(self, value): return isinstance(value, (int, float)) def add(self, value): if self.__is_valid(value): self.total += value else: print("Invalid input") tool = MathTool() tool.add(10) tool.add(5) print(tool.total) # tool.__is_valid(5) # This will raise an error

Try it Yourself

Private methods can only be called inside the class.

Name Mangling in Python

Python internally modifies private names using name mangling.

    • __value becomes _ClassName__value

    • This avoids accidental access and conflicts in subclasses

Example

Understanding name mangling:

class User: def __init__(self, username, pin): self.username = username self.__pin = pin user = User("admin", 4321) # Internally renamed by Python print(user._User__pin) # Works, but not recommended

Try it Yourself

« Previous Next »