How does name mangling work in Python?

Name mangling in Python is a mechanism used to prevent name clashes in subclasses by altering the way certain variable names are stored. This is particularly useful for attributes that are intended to be private to a class.

How Name Mangling Works

1. Double Underscore Prefix:

   • When a variable name starts with two underscores (__) and does not end with two underscores, Python performs name mangling. This means that the interpreter changes the name of the variable in a way that makes it harder to create subclasses that accidentally override the private attributes.

2. Name Transformation:

   • The name of the variable is transformed by prefixing it with _ClassName, where ClassName is the name of the class in which the variable is defined.
   • For example, if you have a class MyClass with a variable __my_var, it will be internally renamed to _MyClass__my_var.

Example

class MyClass:
    def __init__(self):
        self.__private_var = 42  # This will be name-mangled

    def get_private_var(self):
        return self.__private_var

# Create an instance of MyClass
obj = MyClass()

# Accessing the mangled variable directly will raise an AttributeError
# print(obj.__private_var)  # This will raise an error

# Correct way to access the mangled variable
print(obj.get_private_var())  # Outputs: 42

# Accessing the mangled name directly
print(obj._MyClass__private_var)  # Outputs: 42 (not recommended)

Key Points

• Purpose: Name mangling is primarily used to avoid naming conflicts in subclasses and to indicate that a variable is intended for internal use.
• Not True Privacy: Name mangling does not make the variable truly private; it merely changes its name. It can still be accessed using the mangled name.
• Single Underscore: A single underscore (_) before a variable name is a convention indicating that the variable is intended for internal use, but it does not trigger name mangling.

Conclusion

Name mangling is a useful feature in Python for managing variable scope and preventing accidental overrides in subclasses. However, it should be used judiciously, as it can lead to confusion if not properly understood. If you have further questions or need clarification, feel free to ask!