Question

I wrote the following code trying to figure out how to instantiate the subclasses within the main class.. I came up with something that doesn’t feel right.. at least for me.

Is there something wrong with this type of instancing? Is there a better way to call subclasses?

class Family():
  def __init__(self):
    self.Father = self.Father(self)
    self.Mother = self.Mother(self)

  class Father():
    def __init__(self, instance = ''):
      self = instance if instance != '' else self
      print self

    def method(self):
      print "Father Method"

    def fatherMethod(self):
      print "Father Method"


  class Mother():
    def __init__(self, instance = ''):
      self = instance if instance != '' else self
      print self

    def method(self):
      print "Mother Method"

    def motherMethod(self):
      print "Mother Method"



if __name__ == "__main__":
  Family = Family()
  Family.Father.method()
  Family.Mother.method()

Answer 1

What you’ve defined there are not (in Python terminology at least) subclasses – they’re inner classes, or nested classes. I’m guessing that this isn’t actually what you were trying to achieve, but I’m not sure what you did actually want – but here are my four best guesses:

1. A subclass is where the class inheriting from another class is called a subclass. To make father a subclass of family, use the syntax class Father(Family):. What you’ve created here is actually called an Inner Class, not a subclass.

2. When you see something like Family.Father.method(), it often means Family is a module and Father is a class in that module. In Python, module basically means .py file. A module doesn’t have an __init__ method, but all code at the top level of the module (such as the if __name__ ... line) gets executed when a module is imported.

3. Similarly, you could make Family a package – which in Python basically means a directory on the filesystem containing an __init__.py file. Father and Mother would then be modules or classes within the package

4. Possibly what you’re trying to achieve is declare that an object of type Family always has a Father object and a Mother object. This doesn’t require nested classes (in fact, nested classes are a completely bizarre way to do this). Just use:

>>> class Mother():
...   def whoami(self):
...     print "I'm a mother"
... 
>>> class Father():
...   def whoami(self):
...     print "I'm a father"
...
>>> class Family():
...   def __init__(self):
...     self.mother = Mother()
...     self.father = Father()
...  
>>> f = Family()
>>> f.father.whoami()
I'm a father
>>> f.mother.whoami()
I'm a mother
>>>