title: Python interface and self instanciation
body: <p>I have a question of a more design nature regarding a simple strategy design pattern.</p>
  
  <p>Lets say I have an interface:</p>
  
  <pre><code>class RenewInterface:
      def __init__(*args, **kwargs):
          self.var1 = {}
          self.var2 = []
          if args:
              for i in args:
                  inst = i()
                  self.var1[inst.__class__.__name__] = inst
  
      @abstractmethod
      def renew(*args, **kwargs)
          Do some stuff and call renew in self.var1[inst__class__.__name__]
  
  class ChildClass(RenewInterface):
      def __init__(*args, **kwargs):
          super(ChildClass, self).__init__(*args, **kwargs)
  
      def renew(self, *args, **kwargs)
          Do more stuff
  </code></pre>
  
  <p>When I inherit from that class and if I choose to call the superclass <code>__init__</code> (the above code). If I have no args then I will only expose the <code>var1</code> and <code>var2</code> to the child class, but if I for some reason had args and I called the parent(RenewInterface) with <code>super(ChildClass, self).__init__(*args, **kwargs)</code> and the arg for some reason was the class of ChildClass, then I guess I would instantiate the ChildClass from itself? Since I don't care about the variables in the superclass is OK to:</p>
  
  <ol>
  <li>Skip calling the superclass</li>
  <li>Skip the <code>__init__</code> all together in the ChildClass?, but then it uses the RenewInterface <code>__init__</code> again for instantiation</li>
  </ol>
  
  <p>I've tried it all and it all works, but I'm not sure what the most "pythonic" way of doing it is? Or more importantly, does this vary from version 2.6, 2.7 and python>=3.3.</p>
  
  <p>I've read the docs and tried to google, but I have not found any conclusive information :(</p>
  
  <p>Regards</p>