Initialize subclass within class in python

Question

I am initializing a class along with two subclasses in Python using a dictionary. Would it be possible to check a key in the dictionary within the init and depending the result initialize either one of the two subclasses? For instance:

Class Pet():
    def __init__(self,dic):
       self.name=dic['name']
       self.age=dic['age']
       if dic['type']=='dog':
          #Initialize a dog which inherits all pet methods with name and age passed onto it 
       elif dic['type']=='cat':
          #Initialize a dog which inherits all pet methods with name and age passed onto it 


    def pet_methods():      
        # a bunch of pet methods that I would like to be inherited


    Class Dog():
       def __init__(self):
          self.dog_attributes=dic['dog_attributes']
    Class Cat():
       def __init__(self):
          self.cat_attributes=dic['cat_attributes']

What code can be used in the if/else statement? Or is there a better way to organize the code? I am confused as it seems like I want to call a init within another init.

score 3 · Accepted Answer · edited Apr 12 '17 at 07:31

While this may be possible by the semantics of python's classes, I would argue that this is a poor design pattern and should be avoided.

In Object Oriented programming, your classes should represent divisions between portions of your data and logic. What you're doing right now is coupling the logic/data of the Pet superclass and its subclasses. Instead, what you should strive for is to decouple your objects as much as possible. This simplifies the interface between classes and helps you to write classes that are as generic as possible and use subclasses to implement specific behavior.

In your case, you should do the initialization of different pet types within the __init__ methods of the specific pets. If you write your code this way, it is conceptually much easier to add new Pet subclasses - all you need to do is inherit from Pet and initialize the subclass as it should be.

The method that you're attempting to implement right now makes it much harder to implement subclasses. An implementer would need to understand what variables to set in the subclass to hook into the Pet classes initialization scheme, and then it would need to go into the Pet source and implement new functionality for initializing the new Pet subclass type. This is much harder to do and requires editing multiple classes just to implement a new subclass.

This question also talks about the problems of what you're trying to implement.

Yes, I was worried that my organization was not in the right dirction. Thanks for the input — user3776598, Jul 13 '15 at 16:16
Hi @user3776598 if this or any answer has solved your question please consider [accepting it](http://meta.stackexchange.com/q/5234/179419) by clicking the check-mark. This indicates to the wider community that you've found a solution and gives some reputation to both the answerer and yourself. There is no obligation to do this. — Matt Habel, Jul 13 '15 at 16:29
If I wanted to keep my current organization, what would the code be in my if/else statement in order to initialize a dog/cat while keeping the name and age? — user3776598, Jul 13 '15 at 17:16

score 2 · Answer 2 · answered Jul 13 '15 at 15:44

What you've posted isn't what you think. In your example, "Dog" and "Cat" aren't subclasses of "Pet", they're inner classes. I've posted some code below demonstrating how you should write the sub classes. For instantiation of different subclasses in your situation, it's best to use the Factory Pattern which you can Google up and I've included as an example below. I've also set the factory to be able to return the correct subtype by String, but this is an ugly way of doing things so I'd suggest you not use the example.

class Pet:
    def __init__(self):
        pass

    def method1(self):
        print "Method 1 has been called."

    def method2(self):
        print "Method 2 has been called."

    def yelp(self):
        print "I am yelping"


class Dog(Pet):
    def __init__(self):
        Pet.__init__(self)

    def yelp(self):
        print "I am barking"


class Cat(Pet):
    def __init__(self):
        Pet.__init__(self)

    def yelp(self):
        print "I am meowing"


class PetFactory:
    def __init__(self):
        pass

    def acquire_dog(self):
        return Dog()

    def acquire_cat(self):
        return Cat()

    def acquire_pet_by_name(self, pet_type):
        if pet_type == "dog":
            return Dog()
        elif pet_type == "cat":
            return Cat()

This will yield:

>>> pet = Pet()
>>> dog = Dog()
>>> cat = Cat()
>>> dog.yelp()
I am barking
>>> cat.yelp()
I am meowing
>>> pet.yelp()
I am yelping
>>> pet_factory = PetFactory()
>>> pet_factory.acquire_cat().yelp()
I am meowing
>>> pet_factory.acquire_pet_by_name("cat").yelp()
I am meowing
>>> cat.method1()
Method 1 has been called.
>>> dog.method2()
Method 2 has been called.

How are the classes in your answer inner classes and not subclasses? They inherit from `Pet` and use dynamic dispatch (a core idea of OOP) in their implementation. An inner class would be a class that is defined within another one. — Matt Habel, Jul 13 '15 at 15:47
I think you're misunderstanding me. None of the classes in mine are inner classes, they are just sub classes. In the OP's code extract, they are all inner classes but not sub classes. — zamhassam, Jul 13 '15 at 15:53
Hi, Thank you for the catch. I indeed was using inner classes when I was not meaning to do so. — user3776598, Jul 13 '15 at 16:14

score 1 · Answer 3 · answered Jul 13 '15 at 15:28

In subclasses, your init method is overriding the init method of the original superclass. This will work fine and is an import concept of OObject Oriented Programming. If you want to call an init method from the superclass, do super(self). If you want to call any other method, do super.method() and include any extra arguments.

Initialize subclass within class in python

3 Answers3

Linked