question regarding python 3.x MRO and "super()"

This code shows error:
AttributeError: 'super' object has no attribute 'method'

this same code does not shows error when "super.method()" is removed in class C.
Why?

class A(object):
    def method(self):
        print("\n class A method")
        super().method()

class B(object):
    def method(self):
        print("\n class B method")
        super().method()

class C(object):
    def method(self):
        print("\n class C method")
        super().method()
        

class X(A, B):
    def method(self):
        print("\n class X method")
        super().method()

class Y(B, C):
    def method(self):
        print("\n class Y method")
        super().method()

class P(X, Y, C):
    def method(self):
        print("\n class P method")
        super().method()

p = P()
p.method()

print(P.mro())

I want to know, why this program is showing errors when "super().method" is included in class C,
and why this same program is NOT SHOWING ERROR, when "super().method" is removed in class C?

This is not a bug, but a feature of working with multiple inheritance and super. Let me answer your questions one by one:

> why this program is showing errors when "super().method" is included in class C?

The reason is that the base class object does not have a method called method. You will see the same exception when calling C().method() or simply object().method(). So I guess this is quite expected.

> why this same program is NOT SHOWING ERROR, when "super().method" is removed in class C?

This is the magic of python's method resolution order (MRO). If you execute

print(P.mro())

you should see

[__main__.P,
 __main__.X,
 __main__.A,
 __main__.Y,
 __main__.B,
 __main__.C,
 object]

Here, you see that a super call will not call all parents of a class until the top of the inheritance tree and then take the next class. Instead, it will call them according to their "generation".

Look at the following example:

class Base:
    def method(self):
        print("Base")

class ParentA(Base):
    def method(self):
        print('Parent A')
        super().method()
        
class ParentB(Base):
    def method(self):
        print("Parent B")
        
class Child(ParentA, ParentB):
    def method(self):
        print("Child")
        super().method()

print(Child.mro())
Child().method()

Which will give you

[<class '__main__.Child'>, <class '__main__.ParentA'>, <class '__main__.ParentB'>, <class '__main__.Base'>, <class 'object'>]
Child
Parent A
Parent B

You do not see the line Base, because super in ParentA is ignored due to the presence of ParentB which shares the same base.

However, if you swap the inheritance, you will see the line Base printed.
In short, follow the MRO, but if the last class in a generation does not call super, the chain stops.

I agree that this is not intuitive, but in practice this is rarely a problem, or if you have to think about the MRO to understand the code, it would be a good candidate for refactoring.

To understand the MRO, I recommend to read https://en.wikipedia.org/wiki/C3_linearization or other related questions at SO.