Name mangling in Python - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to access the mangled private variable inside the class.

Python

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

obj = MyClass()
print(obj.[1])

Drag options to blanks, or click blank then click option'

Asecret

B__secret

C_MyClass__secret

D_secret

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access __secret directly causes an AttributeError.

Using _secret or secret does not match the mangled name.

In Python, variables with double underscores are name-mangled to include the class name. So __secret becomes _MyClass__secret.

2fill in blank

medium

Complete the code to define a method that accesses the mangled private variable.

Python

class SecretHolder:
    def __init__(self):
        self.__hidden = 'safe'
    def reveal(self):
        return self.[1]

Drag options to blanks, or click blank then click option'

A_SecretHolder__hidden

B__hidden

C_hidden

Dhidden

Attempts:

3 left

💡 Hint

Common Mistakes

Using __hidden directly inside the method.

Using _hidden or hidden which are not the mangled names.

The method must use the mangled name _SecretHolder__hidden to access the private variable.

3fill in blank

hard

Fix the error in accessing the private variable from outside the class.

Python

class Data:
    def __init__(self):
        self.__value = 100

obj = Data()
print(obj.[1])

Drag options to blanks, or click blank then click option'

A__value

B_Data__value

C_value

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access __value directly causes AttributeError.

Using _value or value does not match the mangled name.

Outside the class, the private variable must be accessed using the mangled name _Data__value.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps attribute names to their mangled values.

Python

class Info:
    def __init__(self):
        self.__a = 1
        self.__b = 2

obj = Info()
attrs = {name: getattr(obj, [1]) for name in ['a', 'b'] if hasattr(obj, [2])}

Drag options to blanks, or click blank then click option'

A'_Info__' + name

B'__' + name

C'_' + name

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using '__' + name misses the class name prefix.

Using '_' + name or just name does not match mangled names.

The mangled names are formed by prefixing the class name and double underscore to the attribute name, like _Info__a.

5fill in blank

hard

Fill all three blanks to define a class with a private variable, a method to access it, and external access using name mangling.

Python

class Secret:
    def __init__(self, val):
        self.[1] = val
    def get_secret(self):
        return self.[2]

s = Secret('hidden')
print(s.[3])

Drag options to blanks, or click blank then click option'

A__data

B_Secret__data

D__secret

Attempts:

3 left

💡 Hint

Common Mistakes

Using __secret instead of __data.

Accessing the variable outside the class without mangling.

The private variable is named __data. Inside the class, it is accessed as _Secret__data due to name mangling. Outside, the mangled name _Secret__data is used to access it.

Practice

1. What does name mangling do to an attribute starting with double underscores in a Python class?

easy

A. It adds the class name before the attribute name to avoid conflicts.

B. It makes the attribute public and accessible everywhere.

C. It deletes the attribute from the class.

D. It converts the attribute name to uppercase.

Solution

1. Step 1: Understand double underscore prefix

   Attributes starting with double underscores trigger name mangling in Python classes.

2. Step 2: Effect of name mangling

   Python adds the class name before the attribute name to avoid accidental access or conflicts.

3. Final Answer:

   It adds the class name before the attribute name to avoid conflicts. -> Option A

4. Quick Check:

   Name mangling = adds class name prefix [OK]

Hint: Double underscores add class name prefix to attribute [OK]

Common Mistakes:

• Thinking double underscores make attribute public
• Confusing name mangling with deleting attributes
• Assuming attribute name changes to uppercase

2. Which of the following is the correct way to define a private attribute using name mangling in a Python class?

easy

A. self.__my_attr = 5

B. def __my_attr(self): pass

C. self._my_attr = 5

D. self.my_attr__ = 5

Solution

1. Step 1: Identify private attribute syntax

   Private attributes use double underscores at the start of the name, like __my_attr.

2. Step 2: Check correct assignment

   Assigning with self.__my_attr = 5 correctly defines a private attribute with name mangling.

3. Final Answer:

   self.__my_attr = 5 -> Option A

4. Quick Check:

   Double underscore prefix = private attribute [OK]

Hint: Use double underscores before attribute name for private [OK]

Common Mistakes:

• Using single underscore instead of double
• Placing underscores after attribute name
• Defining private attribute as a method incorrectly

3. What will be the output of this code?

class A:
    def __init__(self):
        self.__x = 10

a = A()
print(hasattr(a, '__x'))
print(hasattr(a, '_A__x'))

medium

A. True\nTrue

B. False\nTrue

C. True\nFalse

D. False\nFalse

Solution

1. Step 1: Check attribute __x existence

   Due to name mangling, __x is stored as _A__x internally, so hasattr(a, '__x') returns False.

2. Step 2: Check mangled attribute _A__x existence

   hasattr(a, '_A__x') returns True because this is the mangled name storing the value.

3. Final Answer:

   False True -> Option B

4. Quick Check:

   __x hidden as _A__x = False, True [OK]

Hint: Check mangled name with _ClassName__attr [OK]

Common Mistakes:

• Assuming __x is directly accessible
• Confusing mangled name with original
• Expecting both hasattr calls to be True

4. What is the error in this code snippet?

class B:
    def __init__(self):
        self.__val = 5

b = B()
print(b.__val)

medium

A. SyntaxError due to double underscores

B. No error, prints 5

C. TypeError because __val is private

D. AttributeError because __val is name mangled

Solution

1. Step 1: Understand name mangling effect

   __val is mangled to _B__val internally, so b.__val does not exist.

2. Step 2: Accessing __val causes AttributeError

   Trying to print b.__val raises AttributeError because the attribute is hidden by name mangling.

3. Final Answer:

   AttributeError because __val is name mangled -> Option D

4. Quick Check:

   Accessing __val directly = AttributeError [OK]

Hint: Access mangled attribute with _ClassName__attr [OK]

Common Mistakes:

• Expecting no error when accessing __val
• Thinking double underscores cause syntax error
• Confusing AttributeError with TypeError

5. Given this class:

class C:
    def __init__(self):
        self.__data = 42
    def get_data(self):
        return self.__data

c = C()

How can you access the private attribute __data from outside the class without using the get_data method?

hard

A. c.__data

B. c._data

C. c._C__data

D. c.get_data()

Solution

1. Step 1: Understand name mangling for __data

   The attribute __data is stored internally as _C__data due to name mangling.

2. Step 2: Access mangled attribute directly

   You can access it from outside the class using c._C__data.

3. Final Answer:

   c._C__data -> Option C

4. Quick Check:

   Access private with _ClassName__attr [OK]

Hint: Use _ClassName__attr to access private attribute [OK]

Common Mistakes:

• Trying to access c.__data directly
• Using single underscore _data instead
• Confusing method call with attribute access