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.

[Image visualizing the concept of OOP Encapsulation: a capsule or safe protecting internal data (variables) while exposing controlled methods (getters/setters) to the outside]

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 AttributeError

Rahul

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())

15000

Modifying Private Data (Setter Method)

To update private data, use a setter method. Setter methods can also validate values before saving them.

Example

Using a setter with validation:

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()) acc.set_balance(-500) # Fails validation

15000 18000 Balance cannot be negative

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())

78 Pass

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 outside the class hierarchy

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

Kiran 5000

Note: Protected members are not strictly enforced by Python—this is a naming convention to signal intent to other developers.

Private Methods

Just like properties, methods can also be made private using double underscores (__). Private methods can only be called from inside the class itself.

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 AttributeError

15

Name Mangling in Python

Python internally modifies private names using a process called name mangling.

• __value internally becomes _ClassName__value
• This avoids accidental access and naming 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 strictly defeats the purpose of encapsulation!

4321

« Previous Next »

AI Code Explanation Python

Powered by Gocourse AI