Name mangling in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this code using name mangling?

Consider this Python class with a double underscore attribute. What will be printed when accessing the mangled attribute directly?

Python

class MyClass:
    def __init__(self):
        self.__hidden = 42

obj = MyClass()
print(obj._MyClass__hidden)

A SyntaxError

B AttributeError

C None

D 42

💡 Hint

Double underscore attributes are renamed internally with the class name prefix.

Python changes names starting with double underscores by adding _ClassName prefix to avoid name clashes. So __hidden becomes _MyClass__hidden.

❓ Predict Output

intermediate

What error does this code raise when accessing a double underscore attribute?

What happens if you try to access a double underscore attribute directly without name mangling?

Python

class Test:
    def __init__(self):
        self.__secret = 'hidden'

obj = Test()
print(obj.__secret)

A AttributeError

B SyntaxError

C 'hidden'

D TypeError

💡 Hint

Double underscore attributes are renamed internally, so direct access fails.

Accessing obj.__secret fails because the attribute is stored as _Test__secret internally, so __secret is not found.

🧠 Conceptual

advanced

Why does Python use name mangling for double underscore attributes?

Choose the best explanation for why Python applies name mangling to attributes starting with double underscores.

A To prevent accidental access and name clashes in subclasses

B To make attributes private and inaccessible everywhere

C To optimize attribute lookup speed

D To allow attributes to be accessed without self prefix

💡 Hint

Think about inheritance and attribute name conflicts.

Name mangling helps avoid attribute name conflicts in subclasses by changing the attribute name internally.

❓ Predict Output

advanced

What is the output of this code with inheritance and name mangling?

Given these classes, what will be printed?

Python

class Base:
    def __init__(self):
        self.__value = 'Base'

class Derived(Base):
    def __init__(self):
        super().__init__()
        self.__value = 'Derived'

obj = Derived()
print(obj._Base__value)
print(obj._Derived__value)

A Derived\nBase

B Base\nDerived

C AttributeError

D Base\nBase

💡 Hint

Each class has its own mangled attribute name.

The Base class attribute is stored as _Base__value and Derived class attribute as _Derived__value, so both exist separately.

🔧 Debug

expert

Why does this code fail to update the intended attribute?

This code tries to update a double underscore attribute in a subclass but fails. Why?

Python

class Parent:
    def __init__(self):
        self.__data = 10

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.__data = 20

obj = Child()
print(obj._Parent__data)

A AttributeError because _Parent__data does not exist

B It prints 20 because Child overrides Parent's attribute

C It prints 10 because Child's __data is a different mangled attribute

D SyntaxError due to double underscores

💡 Hint

Remember that name mangling depends on the class where the attribute is defined.

Child's __data is stored as _Child__data, separate from Parent's _Parent__data, so Parent's attribute remains 10.