Multiple inheritance problem in Python!

Question

Why does c.print_a() output 'B'?

class A(object):
 def __init__(self):
 self.some_name = 'A'
 def print_a(self):
 print self.some_name
class B(object):
 def __init__(self):
 self.some_name = 'B'
 def print_b(self):
 print self.some_name
class C(A, B):
 def __init__(self):
 A.__init__(self)
 B.__init__(self)
if __name__ == '__main__':
 c = C()
 c.print_a()

---

class A(object):
 def __init__(self, some_name='A'):
 self.some_name = some_name
 def print_a(self):
 print self.some_name
class B(object):
 def __init__(self, some_name='B'):
 self.some_name = some_name
 def print_b(self):
 print self.some_name
class C(A, B):
 def __init__(self):
 A.__init__(self, some_name='AAAAA')
 B.__init__(self, some_name='BBBBB')
if __name__ == '__main__':
 c = C()
 c.print_a()

• kriss: Let's try to clarify: you want C to set names for some objects of types A and B and later calling some print_a and print_b function get these names back ?
• Suge: Yes! why couldn't I format the code well as above?
• kriss: you must put 4 leading spaces before every line for the formatter to understand it's code. There is also an icon to do that on selected block.
• Suge: I used the '{}' icon to format the code but failed, what's the problem?
• aaronasterling: @zkz, do these actually need to be instance attributes or will they be the same for every instance of a given class?

Answer 1

You only have a single object here; the some_name property is shared between methods from all inherited classes. You call A.__init__, which sets it to A, then B.__init__, which changes it to B.

Also note that you're calling base methods incorrectly; use super:

class A(object):
 def __init__(self):
 self.some_name = 'A'
 super(A, self).__init__()
 def print_a(self):
 print self.some_name
class B(object):
 def __init__(self):
 self.some_name = 'B'
 super(B, self).__init__()
 def print_b(self):
 print self.some_name
class C(A, B):
 def __init__(self):
 super(C, self).__init__()
if __name__ == '__main__':
 c = C()
 c.print_a()

• Suge: What should I do at the second case above, Where I want afferent parameters with the same key when the super class init?
• Glenn Maynard: I'm not sure what you're asking, but you can't have different properties on the same object with the same name. They're the same object, stored in the same place: c.__dict__, which is simply a regular Python dictionary.
• Glenn Maynard: Note that you can say self.__some_name, which will create a semi-"private" attribute to that class; it will actually create attributes named eg. _A__some_name and _B__some_name. This is very rarely used, though, and I don't recommend it.

Answer 2

There's only one self, and you're overwriting its some_name in B.__init__. Maybe you're used to C++, where there would be two separate fields, A.some_name and B.some_name. This concept doesn't apply to Python, where attributes are created dynamically on assignment.

• kriss: @zkz: What's the problem ? That's the expected python behavior.
• Matthew Flaschen: @zkz, you need to choose unique names for each attribute, and prevent the classes from stepping on each other.

Answer 3

Say you want C to set names for some objects of types A and B and later calling some print_a and print_b methods on objects of type C get these names back ?

You can get this type of behavior using C++ inheritance model, but python model is very different. Only one object with one set of fields. If you want the C++ behavior, the simplest way is probably to declare subobjects (and it looks like a common abuse of inheritance over composition).

Looks like you are trying to do something like below:

class Printable(object):
 def __init__(self, name):
 self.name = name
 def myprint(self):
 print self.name
class C(object):
 def __init__(self):
 self.a = Printable('A')
 self.b = Printable('B')
 def print_a(self):
 self.a.myprint()
 def print_b(self):
 self.a.myprint()
if __name__ == '__main__':
 c = C()
 c.print_a()

• Suge: The example above is just a abstract of my problem.It's more complex in my case, where I can not satisfy my need from your way.I need a way like C++.
• kriss: @zkz: you should explain your actual problem, because what you are saying is very unlikely. all C++ like inheritance models can be managed using composition. If your problem is with finding method name from subobjects it is very easy to do using python introspection tools (getattr). Or is the problem with some common base class ? Actually, inheritance is never mandatory, just a facility for mapping concepts to code and in many, many cases I saw it is used to do things that should definitely not be done using inheritance.