Python Name Mangling Explained with Example
Going through this complete tutorial, you will learn one of the very important concepts- Python Name Mangling.
It’s not so difficult as it seems to be if you follow this complete tutorial and executing code I have shared in this tutorial.
Why Name Mangling?
In Python programming, you can provide the access modifier (public/private) to the class members (variable or function).
Basically, access modifier is used to define- whether the given to class members should be accessible to outside the class or not.
In most of the programming, if you mention access modifier as private for any class members, your program cannot access that class member outside of the class.
As Python doesn’t have access modifier, you can not restrict the class members getting access outside of the class.
To overcome this, Python has a concept Name Mangling.
Don’t bother. I will explain it with very simple manner- step-by-step
What is Python Name Mangling?
Let’s take a simple Class example.
class myClass: def __init__(self): self.x=10 self.__y=20 obj=myClass() print(obj.__y)
You will get an error as
Traceback (most recent call last): File "/home/1af1225c50e8214f40613eda2aa27751.py", line 7, in <module> print(obj.__y) AttributeError: 'myClass' object has no attribute '__y'
Even though we have initialized
__y variable inside the
__init__(), you can not access it outside of the class using the object.
__ as a prefix makes member private.
Why is there no attribute associated with the object
Let’s see all the attributes associated with the object
You can simply print all the attributes corresponds to the object using
Here is a simple program.
class myClass: def __init__(self): self.x=10 self.__y=20 obj=myClass() print(dir(obj))
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_myClass__y', 'x']
If you look at the output list, there is no attribute
__y. Whereas, attribute
x that we have initialized is present.
Interestingly, instead of
__y, you can find the attribute
While executing your program, the name of the attribute
__y is renamed to
Every attribute prefixed with
__ (double underscores) will be changed to
This concept is called as Python name mangling.
Here is your program. You can rewrite to access the name mangling attribute.
class myClass: def __init__(self): self.x=10 self.__y=20 obj=myClass() print(obj._myClass__y)
In the above example, I explained you the name mangling for the variable attribute. This concept also holds true for the function name.
Python Name Mangling with Function Name
Try this simple Python class function.
class myClass: def myFunc(self): print("Hello, World!") obj=myClass() obj.myFunc()
Now rename function name from
__myFunc() and run the program again.
class myClass: def __myFunc(self): print("Hello World!") obj=myClass() obj.__myFunc()
Traceback (most recent call last): File "/home/22c0364aa126811fe5f362040f5a1c91.py", line 7, in <module> obj.__myFunc() AttributeError: 'myClass' object has no attribute __myFunc
As you have given
__ before the function name, as per the name mangling concept in Python, this function name is renamed to
class myClass: def __myFunc(self): print("Hello, World!") obj=myClass() obj._myClass__myFunc()
Use of Name Mangling in Function Overriding
Using inheritance, you can override the base class (parent class) function with a derived class (child class) function.
You can write a function with the same name in the parent as well as in the child class.
To avoid this ambiguity, you can add
__ (double underscore) in front of the function name. With the Name Mangling mechanism, both the function will be renamed as below.
Name Mangling in the base class:
Name Mangling in the derived class:
Now you can distinguish override function.
Function overriding without Name Managing.
class baseClass: def myFunc(self): print("I'm a parent.") class derivedClass(baseClass): def myFunc(self): print("I'm a child.") obj=derivedClass() obj.myFunc()
I'm a child.
myFunc() is defined in the base and derived class, the object of the derived class always calls the method from a derived class.
Function overriding with Name Mangling
class baseClass: def __myFunc(self): print("I'm a parent.") class derivedClass(baseClass): def __myFunc(self): print("I'm a child.") obj=derivedClass() obj._derivedClass__myFunc() obj._baseClass__myFunc()
I'm a child. I'm a Parent.
Now you can call the same method in the base class as well as in derived class using Name Mangling mechanism.
Some points to be remembered.
- Name mangling concept applies when the attribute is prefixed with
- If the attribute is prefixed with
_(single underscore), it will work as normal attribute.
- As a part of name mangling, attribute name will be changed to
_<class_name><atrribute>. This format is used by a class object to access the attribute outside of the class.
- Using name mangling we can access the members outside of the class. This means name mangling is closest to making members private, but it is not the exact way of making members private.
This concept is very important and was asked in many of the interviews. Check Name Mangling question asked in PwC interview round for Python developer.
This is all about Python Name Mangling. Any doubt? Let’s connect by writing in the comment. I will reply to every question.