If you are writing a class in Python and want to follow Encapsulation OOPS concept in Python then how will you stop outside access to the variables as there are no explicit access modifiers like public, private, protected in Python and all the variables are public by default. In Python there is limited support for making class member private and that process is known as name mangling in Python.
Python name mangling mechanism
In name mangling mechanism any identifier with at least two leading underscores, at most one trailing underscore is textually replaced with _classname__identifier where classname is the current class name. For example if there is a variable __test in the class then it is replaced with _classname__test.
Since the name is changed internally by the interpreter so you can’t access the variable using its original name that’s how you get data hiding in Python.
Name mangling is helpful for letting subclasses override methods without breaking intraclass method calls.
Name mangling Python example
class User:
def __init__(self, name, age):
self.name = name
self.__age = age
def display_user(self):
print('User Name:', self.name)
print('User Age:', self.__age)
user = User('Mike Dallas', 34)
# calling class method
user.display_user()
# Accessing variables directly
print(user.name)
print(user.__age)
Output
User Name: Mike Dallas
User Age: 34
Mike Dallas
Traceback (most recent call last):
File "F:/knpcode/Python/Programs/NameMangling.py", line 16, in
print(user.__age)
AttributeError: 'User' object has no attribute '__age'
In the class User there is a field __age (declared with double underscores) when it is accessed using the class method that is OK but trying to access it directly results in an error as its name is changed to (_User__age) by the name mangling mechanism.
You can check the name change by using the dir() function which returns a list of valid attributes for the passed object.
class User:
def __init__(self, name, age):
self.name = name
self.__age = age
def display_user(self):
print('User Name:', self.name)
print('User Age:', self.__age)
user = User('Mike Dallas', 34)
print(dir(user))
Output
['_User__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'display_user', 'name']
Here you can see that __age is changed to _User__age.
Name mangling with method names
Since any class member with at least two leading underscores, at most one trailing underscore is textually replaced with _classname__identifier so name mangling is applied to the method name too.
class User:
def __init__(self, name, age):
self.name = name
self.__age = age
def __display_user(self):
print('User Name:', self.name)
print('User Age:', self.__age)
user = User('Mike Dallas', 34)
user.__display_user()
Output
Traceback (most recent call last):
File "F:/knpcode/Python/Programs/NameMangling.py", line 12, in
user.__display_user()
AttributeError: 'User' object has no attribute '__display_user'
How to access name mangled variable
In name mangling process name is replaced with _classname__membername so you can still access the member name by using the mangled name. That’s why Python states that there is only limited support for making class member private.
class User:
def __init__(self, name, age):
self.name = name
self.__age = age
def display_user(self):
print('User Name:', self.name)
print('User Age:', self.__age)
user = User('Mike Dallas', 34)
# calling class method
user.display_user()
# Accessing variables directly
print(user.name)
# Accessing using the mangled name
print(user._User__age)
Output
User Name: Mike Dallas User Age: 34 Mike Dallas 34
Python name mangling with method overriding
Name mangling is also helpful in method overriding in Python. It lets subclasses override methods without breaking intraclass method calls. Consider following example where class B extends class A and overrides parent class test method. In the init() of class A there is also a call to test method.
class A:
def __init__(self):
print('in init')
self.test()
def test(self):
print('In test method of class A')
class B(A):
def test(self):
print('In test method of class B')
obj = B()
obj.test()
Output
in init In test method of class B In test method of class B
As you can see test() method of class B is getting called both of the times as the reference is of class B. But what you intended was to call test() method of class A when doing self.test(). To avoid breaking intraclass method calls in such scenario you can create a private copy of the original method.
class A:
def __init__(self):
print('in init')
self.__test()
def test(self):
print('In test method of class A')
# private copy
__test = test
class B(A):
def test(self):
print('In test method of class B')
obj = B()
obj.test()
Output
in init In test method of class A In test method of class B
That's all for the topic Name Mangling in Python With Examples. If something is missing or you have something to share about the topic please write a comment.
You may also like
- Python Classes and Objects
- Polymorphism in Python With Examples
- Java Lambda Expressions With Examples
- HikariCP Connection Pooling Java Example
- Spring Data JPA @Query Annotation Example
- How to Check For Which Compressors Native Libraries Are Present
- React Fragments With Examples
- UEFI Compatibilty for Ubuntu Installation
