How to use the second parent class methods which is inheriting from an interface in python?

I would not inherit class CO from either First or Second because you want to end up with an object that is either an instance of class First or class Second. The most straightforward way of doing this is to define method __new__ which will give you more control over instance creation.

Keep all of your code the same (after fixing the obvious errors, such as boto3 not being defined) and changing class CO as follows:

class CO:
    def __new__(cls):
        a = True

        if a:
            main_object = First()
        else:
            main_object = Second()
        return main_object

o = CO()
print(type(o))

Prints:

Inside First function
<class '__main__.First'>

If you want to better parameterize the instance creation (and simplify the code within __new__), then have variable a be an argument to CO:

class CO:
    def __new__(cls, a):
        return First() if a else Second()

o = CO(False)
print(type(o))

Prints:

Inside Second function
<class '__main__.Second'>

You could optionally have class CO have common as its base class to document that instantiating this class results in an instance that implements the common interface. But doing so will not result in enforcing the actual type that is returned by __new__:

class CO(common):
    def __new__(cls, a) -> common:
        # The Python interpreter is not type-checking what is returned:
        #return First() if a else Second()
        return []

o = CO(False)
print(type(o))

Prints:

<class 'list'>

You can also substitute a factory function for class CO:

def common_factory(a):
    return First() if a else Second()

o = common_factory(False)

Note

If you want to ensure that classes that inherit from base class common must override both firstfunction and secondfunction to more closely emulate a pure interface as implemented in other object-oriented languages, then you should define these functions in common so that they raise an NotImplementedError exception:

class common(ABC):
    @abstractmethod
    def firstfunction(self):
        raise NotImplementedError

    @abstractmethod
    def secondfunction(self):
        raise NotImplementedError

Unfortunately, the enforcement is done at run time with its attendant surprises instead of at compile time as is done in other object-oriented languages.

Okay I think in this situation, CO class must come from common class and implement the first and second function. In the implementation, it will use the First or Second classes functions depends on the result of jo function. Here is the correct Co class code:

class CO(common):

    def __init__(self):
        self.inst = self.jo()

    def jo(self):
        a = False

        if a:
            return First()

        return Second()

    def firstfunction(self):
        self.inst.firstfunction()

    def secondfunction(self):
        self.inst.secondfunction()


a = CO()
a.firstfunction()
a.secondfunction()

You can directly call the method you want by using the class name.

Unless you have some pressing reason to do this that you didn't include in your question, I would avoid this in favor of a factory function that returns either a First or Second instance depending on the inputs.

class common(ABC):
    @abstractmethod
    def firstfunction(self):
        pass 

    @abstractmethod
    def secondfunction(self):
        pass

class First(common):
    def __init__(self):
        self.ert = "danish"
        super().__init__(self)
    def firstfunction(self):
        print("My implementation of the first function in FIRST CLASS")

    def secondfunction(self):
        print("My implementation of the second function in FIRST CLASS")   

class Second(common):
    def __init__(self):
        self.rty = "pop"
        super().__init__(self)
    def firstfunction(self):
        print("My implementation of the first function in SECOND CLASS")

    def secondfunction(self):
        print("My implementation of the second function in SECOND CLASS")

class CO(First, Second):
    def __init__(self):
        super().__init__(self)
    def use_first(self):
        return True or False  # whatever logic you have for determining this
    def firstfunction(self):
        if self.use_first():
            return First.firstfunction(self)
        else:
            return First.firstfunction(self)