Encapsulation in python
Encapsulation in C++ programming is a fundamental popular programming concept in object-oriented programming (OOP) that combines class data (attributes) and class functions (methods) together to create a framework that manipulates class data attributes, and protects class attributes and class methods from external interference and misuse. It is often used as a “data hide” in Python classes, as it hides the internal condition of a class object from direct external access.
Principles of Encapsulation in Python.
Data Security – Encapsulation in Python program classes blocks direct access to the internal condition (attributes) of a class object, ensuring that class data is accessed and modified through well-defined methods (getters and setters). It manages data integrity and consistency in the program.
Abstraction – Encapsulation enhances class abstraction by displaying only essential information while hiding the complexity of the class object. Users of the class communicate directly with the object using the interface (public methods), without needing to understand the internal execution details.
Modularity – Python class encapsulation provides program modularity features by separating the execution details of a particular part of the program from other parts, thereby making complex class programs easier to maintain and increasing program scalability.
Example of Encapsulation Program in Python.
So let’s understand encapsulation in Python with the example of Food class.
class food:
def __init__(select, name, price):
select.__name = name # class name Private attribute use
select.__price = price # price Private attribute use
def get_name(select):
return select.__name
def set_name(select, name):
select.__name = name
def get_price(select):
return select.__price
def set_price(select, price):
select.__price = price
def show_info(select):
print(f”vegetarian – {select.__name} {select.__price}”)
# create instance for food class
select_food = food(‘indian food’, ‘punjabi food’)
# let access attributes with getter methods
print(select_food.get_name())
print(select_food.get_price())
# let Modifying attributes with setter methods
select_food.set_name(‘south indian food’)
select_food.select_food()
In the above example.
The Food class has private attributes (__name and __price) which are accessed and modified using getter (get_name(), get_price()) and setter (set_name(), set_price()) class methods.
The double underscore (__) prefix before the class attribute names (__name, __price) makes them private class instances, indicating that they cannot be accessed directly outside the class.
Benefits of Encapsulation in Python.
Improved security – Encapsulation protects sensitive data in Python classes from unauthorized access and modification.
Controlled access – Encapsulation class provides controlled access to attributes and behavior through well-defined interfaces (methods), ensuring consistent conditions and behavior of objects.
Ease of change – In Python encapsulation allows modification of the internal execution of the class without affecting external code, as long as the public interface remains unchanged.
Encapsulation Methods in Python Programming.
Private attributes and methods – In Python programming, private attributes and methods are represented using the double underscore operator (__) in front of their defined name. Although Python programming does not enforce strict private access like some other programming languages (e.g., Java, C++), it suggests that they should not be accessed directly from outside the class.
Property decorator – @property decorator provides features to define getters and setters in a more Pythonic way in Python programming, making class program syntax clearer and more readable.
Encapsulation in Python Short Description.
Encapsulation methods is a powerful programming concept in OOP. It provides class security, class modularity and class abstraction features by encapsulating class data and methods within a class. It increases code reusability, program maintainability and scalability by controlling access to class object condition and behavior, thereby improving Python overall software design and program architecture.
