Name mangling vs qualified access to class attributes
paolieri at gmail.com
paolieri at gmail.com
Tue Dec 13 15:27:26 EST 2016
The official Python tutorial at
https://docs.python.org/3/tutorial/classes.html#private-variables
says that "name mangling is helpful for letting subclasses override methods without breaking intraclass method calls" and makes an interesting example:
class Mapping:
def __init__(self, iterable):
self.items_list = []
self.__update(iterable)
def update(self, iterable):
for item in iterable:
self.items_list.append(item)
__update = update # private copy of original update() method
class MappingSubclass(Mapping):
def update(self, keys, values):
# provides new signature for update()
# but does not break __init__()
for item in zip(keys, values):
self.items_list.append(item)
It seems to me that, in this example, one could just have:
class Mapping:
def __init__(self, iterable):
self.items_list = []
Mapping.update(self, iterable)
def update(self, iterable):
for item in iterable:
self.items_list.append(item)
and avoid copying 'Mapping.update' into 'Mapping.__update'. More generally, any time one needs to "let subclasses override methods without breaking intraclass method calls" (the goal stated in the tutorial), using qualified access to class attributes/methods should suffice.
Am I missing something? Is 'self.__update(iterable)' in 'Mapping.__init__' preferable to 'Mapping.update(self, iterable)'?
I think that, instead, name mangling is helpful to avoid accidental overrides of methods/attributes by the *current* class (rather than its subclasses). Given the way that C3 linearization works, you can't know in advance who will follow your class A in B.__mro__ when B extends A. Name mangling allows you to avoid overriding methods/attributes of classes that might follow.
Any thoughts?
Best,
-- Marco
More information about the Python-list
mailing list