Output of below program show A=30, B-30 and C=30 any on can explain why not A=10, B=20 and C=30?

class A:
    def __init__(self, x):
        self.x
    def show(self):
        print("A:", self.x)


class B(A):
    def __init__(self):
        self.x = 20

    def show(self):
        super().show()
        print("B:", self.x)


class C(B):
    def __init__(self):
        self.x = 30

    def show(self):
        super().show()
        print("C:", self.x)


obj = C()
obj.show()

Tried the code and different cobbination but got answer A=30, B-30 and C=30 Need A=10, B=20 and C=30 in mentioned.

There's only one object (which is an instance of C), so x refers to the same variable in each case. Thus, when you print the value of x, it couldn't possibly refer to separate values in the base classes.

Also, as indicated in the comments, the __init__s for B and A are never actually called (and even if they were, you'd just be overwriting the current value of x every time, so it would always show the same value).

Only C's __init__ method gets invoked, self.x is only ever set to 30. Even if you did use super().__init__(), each assignment to x would overwrite any previous assignment - you'd still end up with one value, which one would depend on the order of the super calls vs. assignments. An instance can only have one value for a given attribute name.

If you really do want the different classes to have different values, and assuming that the rest of the public interface is correct, a working implementation would look something like:

class A:

    def __init__(self, x):
        self.__x = x

    def show(self):
        print("A:", self.__x)


class B(A):

    def __init__(self):
        super().__init__(10)
        self.__x = 20

    def show(self):
        super().show()
        print("B:", self.__x)


class C(B):

    def __init__(self):
        super().__init__()
        self.__x = 30

    def show(self):
        super().show()
        print("C:", self.__x)

Using __x as the attribute name invokes name mangling (see Designing for Inheritance), which means A actually has _A__x, B has _B__x, and so on. This is deliberately intended to prevent subclasses overriding the attributes of their superclasses - it's not a good idea generally (it's not the idiomatic way to make "private" attributes, for example), but if you want each one to have a separate value this is how you do it. In use:

>>> obj = C()
>>> obj.show()
A: 10
B: 20
C: 30

However, note that external access to __x is also prevented, you have to be specific about which __x:

>>> obj.__x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute '__x'
>>> obj._A__x
10
>>> obj._B__x
20
>>> obj._C__x
30