Name mangling in Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is name mangling in Python?

Name mangling is a way Python changes the name of class attributes that start with two underscores (__). It helps avoid name conflicts in subclasses by making the attribute name unique to the class.

beginner

How does Python transform a variable named __var inside a class MyClass?

Python changes <code>__var</code> to <code>_MyClass__var</code> internally. This makes it harder to accidentally access or override it from outside the class or in subclasses.

intermediate

Why does Python use name mangling instead of making variables truly private?

Python follows a philosophy of 'we are all consenting adults'. Name mangling is a gentle way to avoid accidental access but does not make variables truly private. Programmers can still access mangled names if needed.

beginner

What happens if a variable name starts with a single underscore _var instead of double underscores?

A single underscore is a convention to indicate 'internal use' but Python does not change the name. It is just a hint to programmers, not enforced by the language.

intermediate

Can name mangling prevent all access to a variable?

No. Name mangling only changes the variable name to include the class name. You can still access it by using the mangled name directly. It is meant to avoid accidental access, not to enforce strict privacy.

What prefix triggers name mangling in Python class attributes?

A No underscore

B Single underscore (_)

C Double underscore (__)

D Triple underscore (___)

Only variables starting with double underscores are name mangled by Python.

If a class is named Car and has an attribute __speed, what is the mangled name?

A __Car_speed

B speed__Car

C _speed__Car

D _Car__speed

Python changes __speed to _Car__speed by adding an underscore and the class name.

What is the main purpose of name mangling?

A To avoid accidental name conflicts in subclasses

B To make variables completely private

C To speed up variable access

D To encrypt variable names

Name mangling helps avoid accidental overwriting or access in subclasses, not full privacy.

Can you access a mangled variable from outside the class?

A Yes, by using the mangled name

B No, it is impossible

C Only inside the class

D Only in subclasses

You can access it if you know the mangled name, but it is discouraged.

What does a single underscore prefix (e.g., _var) mean in Python?

A It deletes the variable

B It is a convention for internal use only

C It makes the variable public

D It triggers name mangling

A single underscore is a hint to programmers that the variable is for internal use, but Python does not enforce it.

Explain what name mangling is and why Python uses it.

Think about how Python changes variable names inside classes.

Describe the difference between a single underscore prefix and a double underscore prefix in Python variable names.

Consider how Python treats each prefix differently.

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