Name mangling in Python - Step-by-Step Execution

Concept Flow - Name mangling

Define class with __private attribute

↓

Create instance of class

↓

Access __private attribute inside class method

↓

Access __private attribute outside class

↓

Python changes __private to _ClassName__private

↓

Access succeeds using mangled name

Name mangling changes __private names inside classes to _ClassName__private to avoid accidental access from outside.

Execution Sample

Python

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

obj = MyClass()
print(obj._MyClass__secret)

This code shows how Python changes __secret to _MyClass__secret and how to access it.

Execution Table

Step	Action	Variable/Attribute	Value	Note
1	Define class MyClass	MyClass	class object	Class created with __secret attribute
2	Create instance obj	obj	MyClass instance	obj.__secret is not directly accessible
3	Inside __init__, set self.__secret	obj.__secret	42	Name mangled to obj._MyClass__secret internally
4	Try print(obj.__secret)	obj.__secret	AttributeError	Direct access fails, attribute is mangled
5	Print obj._MyClass__secret	obj._MyClass__secret	42	Access succeeds using mangled name

💡 Execution stops after printing the mangled attribute value 42

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5
obj.__secret	undefined	undefined	42 (mangled as _MyClass__secret)	42
obj._MyClass__secret	undefined	undefined	42	42

Key Moments - 2 Insights

Why can't we access obj.__secret directly?

Because Python changes __secret to _MyClass__secret internally (see step 4 in execution_table), so obj.__secret does not exist.

How does Python prevent accidental access to private attributes?

By name mangling: it renames __secret to _ClassName__secret, making it harder to access from outside (see step 3 and 5).

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 4 when trying to print obj.__secret?

A It raises AttributeError

B It prints 42

C It prints None

D It prints _MyClass__secret

💡 Hint

Check step 4 in execution_table where direct access to obj.__secret fails

At which step is the private attribute actually set inside the object?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look at step 3 where self.__secret is assigned the value 42

If the class name changes to YourClass, what would be the mangled name for __secret?

A _MyClass__secret

B _YourClass__secret

C __secret

D _secret

💡 Hint

Name mangling uses _ClassName__attribute format, see concept_flow and execution_table steps

Concept Snapshot

Name mangling in Python:
- Attributes starting with __ are renamed internally.
- Format: __attr becomes _ClassName__attr.
- Prevents accidental external access.
- Access with obj._ClassName__attr if needed.
- Not true private, just name changed.

Full Transcript

Name mangling is a Python feature that changes attribute names starting with double underscores inside classes. When you write __secret inside a class named MyClass, Python changes it to _MyClass__secret internally. This helps avoid accidental access from outside the class. For example, setting self.__secret = 42 inside __init__ actually creates obj._MyClass__secret. Trying to access obj.__secret directly causes an error because that name does not exist. To access the value, you use obj._MyClass__secret. This is not true privacy but a way to reduce naming conflicts. If the class name changes, the mangled name changes accordingly.

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