Design pattern for creating similar but different classes

Presuming that you are using Python 3.6 ore newer, I would use abstract base classes and use the __init_subclass__() method to automatically register new subclasses and the sources they handle. A classmethod on the baseclass can then look up the appropriate subclass based on the source.

If the decision on which subclass to use is more complicated, each subclass can have a can_you_handle(self, source) method that returns True if is can handle the source. The base class from_source() method calls can_you_handle() on each subclass until it finds one that can handle the source.

Here's a base class:

class Data:
    registry = {}
    
    def __init__(self, source):
        self.source = source

    
    def __init_subclass__(cls, **kwargs):
        for source in cls.sources:
            if source not in Data.registry:
                Data.registry[source] = cls
                
            else:
                other_cls = Data.registry[source].__name__
                message = f"class '{other_cls}' already registered for source '{source}'."
                raise ValueError(message)

        super().__init_subclass__(**kwargs)
            
        
    @classmethod
    def from_source(self, source):
        try:
            cls = Data.registry[source]
            return cls(source)
        
        except KeyError:
            raise ValueError(f"Unkown source: {source}") from None
    
    def __str__(self):
        return f"{type(self).__name__}('{self.source}')"

Some subclasses:

class Data_A(Data):
    sources = 'a','b'
    
    def method_for_source_A(self):
        print('doing something with Data_A')
    
class Data_C(Data):
    sources = 'c','d','e'

    def method_for_source_C(self):
        print('doing something with Data_C')

Check the registry was populated:

print(Data.registry)

prints:

{'a': __main__.Data_A, 'b': __main__.Data_A, 'c': __main__.Data_C,
 'd': __main__.Data_C, 'e': __main__.Data_C}

Try it out:

data = Data.from_source('b')
print(f"{str(data)} using {data.source}")

data = Data.from_source('e')
print(f"{str(data)} using {data.source}")

data = Data.from_source('q')
print(f"{str(data)} using {data.source}")

prints:

Data_A('b') using b
Data_C('e') using e
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-82-072d12d66274> in <module>
      5 print(f"{str(data)} using {data.source}")
      6 
----> 7 data = Data.from_source('q')
      8 print(f"{str(data)} using {data.source}")

<ipython-input-70-bd84ab43455a> in from_source(self, source)
     20 
     21         except KeyError:
---> 22             raise ValueError(f"Unkown source: {source}") from None
     23 
     24     def __str__(self):

ValueError: Unkown source: q

Try defining a subclass with a duplicated source:

class Data_F(Data):
    sources = 'f','e'

    def method_for_source_F(self):
        print('doing something with Data_F')

result:

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-124-39d1c8d7edf7> in <module>
----> 1 class Data_F(Data):
      2     sources = 'f','e'
      3 
      4     def method_for_source_F(self):
      5         print('doing something with Data_F')

<ipython-input-120-08031ccf6700> in __init_subclass__(cls, **kwargs)
     14                 other_cls = Data.registry[source].__name__
     15                 message = f"class '{other_cls}' already registered for source '{source}'."
---> 16                 raise ValueError(message) from None
     17 
     18         super().__init_subclass__(**kwargs)

ValueError: class 'Data_C' already registered for source 'e'.

class Analytics would be handled in an analogous manner.

Your main class would then look like this:

class Main_class():
    def __init__(self, sources = ['a','b','c']):
        self.data_sources = {}
        self.analytics = {}

        for s in sources:
            data = Data.from_source(s)
            self.data_sources[s] = data

            analytic = Analytics.from_source(s)
            self.analytics[s] = analytic(data)

One more thing, __init_subclass__() takes keyword arguments. So you could write the code above like this (I just prefer using class variables as shown above):

    def __init_subclass__(cls, sources, **kwargs):   # changed this line
        for source in sources:                       # and this one
            if source not in Data.registry:
                Data.registry[source] = cls
                
            else:
                other_cls = Data.registry[source].__name__
                message = f"class '{other_cls}' already registered for source '{source}'."
                raise ValueError(message)

        super().__init_subclass__(**kwargs)

And then the subclasses would look like this:

class Data_A(Data, sources=('a','b')):   # source in now a keyword argument
    
    def method_for_source_A(self):
        print('doing something with Data_A')