An Outline of Python Encapsulation
Python, like other object-oriented programming languages, provides a security mechanism known as encapsulation, which helps to prevent unauthorised or accidental access to variables and methods that are used to represent critical parts of the programme.
Mangling Names in Python Python implies a limitation on data access. Because Python lacks traditional access modifiers, it is nevertheless possible to manage permissions via the use of Name Mangling. Python makes all its methods and variables accessible to the public by default. Hence, in Python, if an identifier includes two leading underscores, it is treated as a private instance. To further grasp encapsulation, we would define instance variables and methods as private here. If a method or variable’s name begins with a single “_” or two “__” double underscores, it is private and may only be used inside the same class in which it was created. Non-public instance variables similarly begin with two underscores and have scope limited to the class or method in which they are declared. If we omit the second underscore, the method is no longer private but instead public. Python’s Encapsulation concept is best grasped with a firm grounding on the difference between public and non-public instance variables and methods.
Hidden Variables in Private Examples
Python does not have a concept of “private,” and no Python attribute may be considered secret (We will be discussing the underlying alternative later in the article). We refer to them instead as NPI Variables, or Non-Public Variables in Instances. As such, we will refer to the secret data and procedures as “private” throughout this document.
An example of a non-public instance variable’s cod e in Python is as follows:
If we want to access a class variable, we have to utilise the self keyword. You will get a picture as the result.
Adding print(abc. a) to the code allows us to verify whether or not the non-public instance variable has global scope:
As for the result, it is:
image@@@3
We may deduce from this that private instance variables are not accessible from outside the class.
Excluding the General Public from the Processes
Unlike public methods, non-public methods may only be invoked from inside the class and not on the object itself.
image@@@4
There are two _methods in this code sample, one of which is private and the other of which is public. Any instance of the class abc may be used to use the public method, which will then display the object’s contents.
image@@@5
Trying to use the same procedure for the private instance throws the following error.
image@@@6
This is what the code will output:
_
image@@@7
Thus, calling a non-public instance method via object creation is not feasible. In order to use the private instance method, we may use it through the public show2() method of the same class by first using the __show1() method. Here’s how you expose a class’s private instance method to the world using the exposed public counterpart.
Outpu t:
image@@@9
Hence, you can’t invoke the non-public instance method from outside the class in which it was defined.
This is the backdoor method of getting to the Non-Public Instance Variable.
While the value of a non-public instance variable cannot be directly modified or accessed by objects outside of the class, there is a roundabout approach to do it. We’ll have a look at the code sample below:
image@@@10
Out put:
image@@@11
The aforementioned code snippet consists of two public methods—getNumber(self,num) and displayNumber()—and one private instance variable. When we use the second method, displayNumber(), we take the number we just got from the first method and save it in the private instance variable.
The value of the private instance variable is changed using the setter method. This comes in handy if you ever need to modify the value of a non-public instance variable after it has already been used to create objects.
Advantages
With the use of encapsulation, we can ensure that our data is safe and that it may move more freely across applications. Encapsulation allows the programme to function independently. Encapsulation is very useful during the implementation phase since it removes the complexity of the when and where questions while focusing on the how. Encapsulation is simplified and data security is increased when information is hidden inside a unit.
Python Encapsulation: Why Do We Need It?
These are a few of the scenarios where the notion of encapsulation may be useful to developers, as well as why Object-oriented principles are now dominating most programming languages in use.
- There is a need for well-defined interaction in every application; encapsulations help in achieving that.
- The concept of Object Orientation Programming in python focuses on making reusable code. This is also abbreviated as DRY(Don’t Repeat Yourself).
- Maintenance of application is easier, and there is security ensured.
- Clarity on the coding procedure as developers are to be concerned at the objective of the class, and the complexities are dealt with systematically.
- Proper organization of the codes helps with the flexibility of the code and also aids in Unit Testing.
- Users find it easy to use the system as they are hidden away from the complex design involved at the backend.
- Having all similar data in one place and encapsulated increases the cohesion inside a module.
- Improves the readability of the codes, and changes in one part of the code do not disrupt other parts of the code.
- Encapsulation prevents the part of the code from being accessed by accident, but not intentionally, as objects hold critical data for applications, and it should be changed anywhere in the code.
Conclusion
Encapsulation in Python is a technique for keeping an object’s internal representation private from contexts outside of its specification. As a result, the developer is better able to create a safe system that is also pleasant for end users.