A class is more or less a fancy wrapper for a dict of attributes to objects. When you instantiate a class you can assign to its attributes, and those will be stored in foo.__dict__; likewise, you can look in foo.__dict__ for any attributes you have already written.

This means you can do some neat dynamic things like:

class Employee: pass
def foo(self): pass
Employee.foo = foo

as well as assigning to a particular instance. (EDIT: added self parameter)

When you create a new class, you are creating a new type. This newly created type may have some properties, or may not. These properties allow to hold data, methods etc.

Empty class that doesn't inherit any base class would be useful as placeholder.

class ServiceWrapper(object):
    pass

def sendMessage(svc:ServiceWrapper):
    #do something
    #pass

On the other hand, empty classes that inherit other classes is a very common pattern. Specially when defining user exceptions.

class Networkerror(RuntimeError):
    pass

try:
    raise Networkerror()
except Networkerror:
    #do something
    #pass

Also recently, the python collections.abc allows creating interface like functionalities.

class ServiceWrapper(ABC):
    @abstractmethod
    def send(self):...

def sendMessage(svc:ServiceWrapper):
    svc.send()
    #pass

This is just fine:

class Parent:
    # the __init__ is inherited from parent
    pass

class Child(Parent):
    # the __init__ is inherited from parent
    pass

This is also fine:

class Parent:
    # the __init__ is inherited from parent
    pass

class Child(Parent):
    def __init__(self):
        # __init__ is called on parent
        super().__init__()

This may seem ok, and will usually work fine, but not always:

class Parent:
    # the __init__ is inherited from parent
    pass

class Child(Parent):
    def __init__(self):
        # this does not call parent's __init__, 
        pass

Here is one example where it goes wrong:

class Parent2:
    def __init__(self):
        super().__init__()
        print('Parent2 initialized')


class Child2(Child, Parent2):
    pass

# you'd expect this to call Parent2.__init__, but it won't:
Child2()

This is because the MRO of Child2 is: Child2 -> Child -> Parent -> Parent2 -> object.

Child2.__init__ is inherited from Child and that one does not call Parent2.__init__, because of the missing call to super().__init__.

^{Note: This post contains two different implementation techniques to allow for what you want.}

Solution Through Indirection

The easiest way around this issue is to refactor the code so that the child classes does not directly override the function used by the public interface.

Instead provide the public functionality directly in the base-class, and make children override a "worker" (implementation detail) of said function that is later called by the function invoked "from the outside".

Example Implementation

class Base (object):
    def get_message (self):
        try:
            return self.get_message_impl ()
        except Exception as detail:
            print ("error:", detail)    
        return None

    def get_message_impl (self):
        raise Exception ("Not Implemented")

class Foo (Base):
    def get_message_impl (self):
        return "Hello World";

class Bar (Base):
    def get_message_impl (self):
        raise Exception ("Bar.get_message_impl always fails!")

f = Foo ()
b = Bar ()

f_msg = f.get_message ()
b_msg = b.get_message ()

print ("f_msg:", f_msg)
print ("b_msg:", b_msg)

output

error: Bar.get_message_impl always fails!
f_msg: Hello World
b_msg: None

opt-in protection

If you would like to maintain the possibility to override the public functionality presented in the base class, while still being able to easily call a "protected" version of the functions at a later time, you could create a simply wrapper such as the below:

class Base (object):
    class Protected (object):
        def __init__ (self, target):
            self.target = target

        def get_message (self):
            try:
                return self.target.get_message ()
            except Exception as detail:
                print ("error:", detail)
            return None

    def __init__ (self):
        self.protected = self.Protected (self)

    def get_message (self):
        raise Exception ("Not Implemented")

class Foo (Base):
    def get_message (self):
        return "Hello World";

class Bar (Base):
    def get_message (self):
        raise Exception ("Bar.get_message_impl always fail!")

f = Foo ()
b = Bar ()

f_msg = f.protected.get_message () # protected from failure
b_msg = b.protected.get_message () # protected from failure

b_msg = b.get_message ()           # will raise exception

It sounds like you want a class factory:

def make_baked_type(fruit, bake):
    class baked_item(fruit, bake):
        pass
    return baked_item

ApplePie = make_baked_type(Apple, Pie)
item = ApplePie()
print(item.flavour())

# or
def make_baked_item(fruit, bake):
    return make_baked_type(fruit, bake)()

item = make_baked_item(Apple, Pie)
print(item.flavour())

Yes, in Python 3.3 SimpleNamespace was added

Unlike object, with SimpleNamespace you can add and remove attributes. If a SimpleNamespace object is initialized with keyword arguments, those are directly added to the underlying namespace.

Example:

import types

x = types.SimpleNamespace()
x.happy = True

print(x.happy) # True

del x.happy
print(x.happy) # AttributeError. object has no attribute 'happy'

Your first approach is good enough, unless you want to only use class attributes and not instance attributes
Also every class in Python inherits from object, as explained in detail here

class MyClass:
    pass

An example of such classes might be as follows

• A class to store multiple class attributes

class MyClass:

    a = 1
    b = 2

print(MyClass.a)
#1
print(MyClass.b)
#2

• A custom exception where the constructor is implicitly taken from the base class

class MyException(Exception):

    pass

raise MyException
#    raise MyException
#__main__.MyException

It seems to me your confusion stems from a misunderstanding of __init__ and your use of type. With type you can dynamically create new classes, but here you want to simply use previously defined classes. Whenever you indeed initialize such a class, your provided arguments are passed to the __init__ function, where you can do whatever you want with them.

I cleaned up your code and added comments to clarify the flow of things:

# Create a blueprint for Base
class Base:
    def print_something(self):
        print('Something.')


# Create a blueprint for A
class A(Base):
    # Do some initialization whenever an instance of A is created.
    def __init__(self):
        print('Initializing A without any args')
        # Do some initialization
        self.answer = 42


# Create a blueprint for B
class B(Base):
    # An __init__ method with arguments
    def __init__(self, foo, bar):
        print(f'Initializing B with args: {foo}, {bar}')
        self.foo = foo
        self.bar = bar


# Create a blueprint for C
class C(B, Base):
    # Do some initialization whenever an instance of C is created.
    def __init__(self, x):
        # Create an instance of A and store it as an attribute of the instance
        # of C that we are initializing here.
        self.a = A()
        # Do the same for B, but provide init arguments.
        self.b = B(x[0], x[1])


def main():
    # Create an instance of C
    c = C([1, 2])

    # Print some attributes to clarify the hierarchy
    print(c.a.answer)
    print(c.b.foo)
    print(c.b.bar)


if __name__ == '__main__':
    main()