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
--
https://mail.python.org/mailman/listinfo/python-list
