Home

Learning Hub

Articles

Encapsulation in Python – Explained with Examples

The Object-Oriented Programming language has four principles. In this article, we will discuss the Encapsulation principle, a simple yet powerful concept in Python. It involves bundling data members and functions inside a single class, making your code more organised and easier to manage. The benefits of this are immense, and we’ll explore them in detail. Let’s dive deep into Encapsulation in the Python language for more information.

What is Encapsulation in Python?

Encapsulation in Python refers to the bundling of data and methods into a single unit, which is called a class. The idea behind encapsulation is to hide an object’s internal state and only expose the necessary functionalities. This can be achieved by marking certain attributes or methods. Encapsulation in Python also ensures that objects are self-sufficient functioning pieces and work independently.

Why Do We Need Encapsulation in Python?

Let’s see why we need an Encapsulation in Python language:

1. Data Protection:  Encapsulation helps protect data by restricting direct access to certain attributes and methods. This prevents accidental modification of data and promotes better control over how data is accessed and manipulated.
2. Information Hiding: Encapsulation hides a class’s internal implementation details from the outside world. It exposes only the necessary interface. By hiding unnecessary information details, encapsulation reduces complexity and minimises the risk of unintended side effects.
3. Flexibility and Maintainability: Encapsulation improves the flexibility and maintainability of code by decoupling different system components. Developers can make changes to individual components without affecting the rest of the computing system. It also makes it easier to extend, modify, and refactor code, leading to better software quality.
4. Code Reusability: Encapsulation promotes code reusability by using the same code many times. Encapsulation encourages modular design, allowing developers to build reusable components that can be easily integrated into various applications.

Access Modifiers in Python encapsulation

In Python language, sometimes we have to restrict or limit access to certain variables of function while programming. That is where access modifiers come into the picture in Python. There are three types of access modifiers:

• Public Members
• Private Member
• Protected Member

Encapsulation in Python using public members

In this section, we will use the public modifier that allows variables and functions to be accessible from anywhere within the class and from any part of the program. All the members’ variables have the access modifier as public or default.

The following program demonstrates the Encapsulation in Python using the public modifiers:

Program

Output

Also Read: Polymorphism in Python

Encapsulation in Python using private members

In this section, we will use a private access modifier that allows member methods and variables to be accessed only within the class.  To specify a private access modifier for a member, we make use of the double underscore__

The following program demonstrates the Encapsulation in Python using private members:

Program

Output

In the above code, we have received an AttributeError in the output. In the above example, we tried to access it outside the class, which is why we received the above error. We can access private members from the outside of a class using the following two approaches:

• Public method to access private members
• Name Mangling to access private members

Public method to access private members

The following program demonstrates the Public method of accessing private members:

Program

Output

Name Mangling to access private members

In this section, we can directly access private and protected variables from the outside of a class. The name mangling is created on an identifier by adding two leading underscores and one trailing underscore, like this _classname_dataMember, where the class name is the current class, and the data is the private variable name.

The following program demonstrates Name Mangling to access private members:

Program

Output

In this section, we will use the protected member in the Python language. That allows the members to access the class and allows them to be accessed by the sub-class involved. In Python language, we demonstrated a protected member. we know that if the members have a protected access specifier, it can be referenced within the class and the subsequent sub-class. The following program demonstrates the Encapsulation in Python using the protected members:

Program

Output

Disadvantages of Encapsulation

Encapsulation in Python offers numerous advantages. There are also some potential disadvantages of Encapsulation:

• Increased Complexity: Encapsulation increases the complexity of the code base when the developer uses it accessible or inappropriately. For example, Creating numerous getter and setter methods for accessing and modifying private attributes may lead to verbose and harder-to-read code.

• Performance Overhead: Accessing private members through methods like getters and setters may incur a slight performance overhead compared to direct access. It can become a concert in performance-critical applications.

• Debugging Challenges: Encapsulation makes debugging more challenging. If the internal state of objects is hidden or difficult to inspect. Debugging tools and techniques may be less effective when dealing with heavily encapsulated source code.

Conclusion

In this article, we have explored encapsulation in the Python language. Encapsulation is a powerful concept that allows developers to control access to certain parts of an object, thereby protecting its internal state and preventing unintended modification of the code. By using encapsulation, we can hide the implementation details of a class and only expose the necessary components of the code. It promotes better code readability, maintenance and security.