Initiate subclasses from parent class

Question

Suppose I have a list of inputs that will generate O objects, of the following form:

inps = [['A', 5], ['B', 2]]

and O has subclasses A and B. A and B each are initiated with a single integer -- 5 or 2 in the example above -- and have a method update(self, t), so I believe it makes sense to group them under an O superclass. I could complete the program with a loop:

Os = []
for inp in inps:
    if inp[0] == 'A':
        Os.append(A(inp[1]))
    elif inp[0] == 'B':
        Os.append(B(inp[1]))

and then at runtime,

for O in Os: O.update(t)

I'm wondering, however, if there is a more object oriented way to accomplish this. One way, I suppose, might be to make a fake "O constructor" outside of the O class:

def initO(inp):
    if inp[0] == 'A':
        return A(inp[1])
    elif inp[0] == 'B':
        return B(inp[1])

Os = [initO(inp) for inp in inps]

This is more elegant, in my opinion, and for all intensive purposes gives me the result I want; but it feels like a complete abuse of the class system in python. Is there a better way to do this, perhaps by initiating A and B from the O constructor?

EDIT: The ideal would be to be able to use

Os = [O(inp) for inp in inps]

while maintaining O as a superclass of A and B.

Answer 1

In case you really want to create a (direct) subclass from within a parent class you could use the special __subclasses__ method:

class O(object):
    def __init__(self, integer):
        self.value = integer

    @classmethod
    def get_subclass(cls, subclassname, value):  
        # probably not a really good name for that method - I'm out of creativity...
        subcls = next(sub for sub in cls.__subclasses__() if sub.__name__ == subclassname)
        return subcls(value)

    def __repr__(self):
        return '{self.__class__.__name__}({self.value})'.format(self=self)

class A(O):
    pass

class B(O):
    pass

This acts like a factory:

>>> O.get_subclass('A', 1)
A(1)

Or as list-comprehension:

>>> [O.get_subclass(*inp) for inp in inps]

In case you want to optimize it and you know that you won't add subclasses during the programs progress you could put the subclasses in a dictionary that maps from __name__ to the subclass:

class O(object):
    __subs = {}
    def __init__(self, integer):
        self.value = integer

    @classmethod
    def get_subclass(cls, subclassname, value):
        if not cls.__subs:
            cls.__subs = {sub.__name__: sub for sub in cls.__subclasses__()}
        return cls.__subs[subclassname](value)

You could probably also use __new__ to implement that behavior or a metaclass but I think a classmethod may be more appropriate here because it's easy to understand and allows for more flexibility.

In case you not only want direct subclasses you might want to check this recipe to find even subclasses of your subclasses (I also implemented it in a 3rd party extension package of mine: iteration_utilities.itersubclasses).

Answer 2

At the risk of drawing more negative fire... we can use metaclasses. This may or may not be suitable for your particular application. Every time you define a subclass of class O, you always have an up-to-date list (well, dict) of O's subclasses. Oh, and this is written for Python 2 (but can be ported to Python 3).

class OMetaclass(type):
    '''This metaclass adds a 'subclasses' attribute to its classes that
    maps subclass name to the class object.'''
    def __init__(cls, name, bases, dct):
        if not hasattr(cls, 'subclasses'):
            cls.subclasses = {}
        else:
            cls.subclasses[name] = cls

        super(OMetaclass, cls).__init__(name, bases, dct)

class O(object):
    __metaclass__ = OMetaclass

### Now, define the rest of your subclasses of O as usual.

class A(O):
    def __init__(self, x): pass

class B(O):
    def __init__(self, x): pass

Now, you have a dictionary, O.subclasses, that contains all the subclasses of O. You can now just do this:

Os = [O.subclasses[cls](arg) for (cls, arg) in inps]

Now, you don't have to worry about weird prefixes for your classes and you won't need to change your code if you're subclassing O already, but you've introduced magic (metaclasses) that may make your program harder to grok.

Answer 3

Without knowing more about your A and B, it's hard to say. But this looks like a classic case for a switch in a language like C. Python doesn't have a switch statement, so the use of a dict or dict-like construct is used instead.

If you're sure your inputs are clean, you can directly get your classes using the globals() function:

Os = [globals()[f](x) for (f, x) in inps]

If you want to sanitize, you can do something like this:

allowed = {'A', 'B'}
Os = [globals()[f](x) for (f, x) in inps if f in allowed]

This solution can also be changed if you prefer to have a fixed dictionary and sanitized inputs:

allowed = {'A', 'B'}
classname_to_class = {k: v for (k, v) in globals().iteritems() if k in allowed}
# Now, you can have a dict mapping class names to classes without writing 'A': A, 'B': B ...

Alternately, if you can prefix all your class definitions, you could even do something like this:

classname_to_class = {k[13:]: v for (k, v) in globals().iteritems() if k.startswith('SpecialPrefix'} # 13: is the length of 'SpecialPrefix'

This solution allows you to just name your classes with a prefix and have the dictionary automatically populate (after stripping out the special prefix if you so choose). These dictionaries are equivalent to trans and dct in the other solutions posted here, except without having to manually generate the dictionary.

Unlike the other solutions posted so far, these reduce the likelihood of a transcription error (and the amount of boilerplate code required) in cases where you have a lot more classes than A and B.

Answer 4

Although it is technically possible to perform call by name in Python, I strongly advice not to do that. The cleanest way is probably using a dictionary:

trans = { 'A' : A, 'B' : B }

def initO(inp):
    cons = trans.get(inp[0])
    if cons is not None:
        return cons(*inp[1:])

So here trans is a dictionary that maps names on classes (and thus corresponding constructors).

In the initO we perform a lookup, if the lookup succeeds, we call the constructor cons with the remaining arguments of inp.

Answer 5

You could use a dict to map the names to the actual classes:

dct = {'A': A, 'B': B}

[dct[name](argument) for name, argument in inps]

Or if you don't want the list-comprehension:

dct = {'A': A, 'B': B}
Os = []
for inp in inps:
    cls = dct[inp[0]]
    Os.append(cls(inp[1]))