如何在Python中基类内创建派生类的对象？

Question

I have a code like this:

class Base:
    def __init__(self):
        pass

    def new_obj(self):
        return Base()  # ← return Derived()

class Derived(Base):
    def __init__(self):
        pass

In the line with a comment I actually want not exactly the Derived object, but any object of class that self really is.

Here is a real-life example from Mercurial .

How to do that?

Answer 1

def new_obj(self):
    return self.__class__()

Answer 2

I can't think of a really good reason to do this, but as D.Shawley pointed out:

def new_obj(self):
    return self.__class__()

will do it.

That's because when calling a method on a derived class, if it doesn't exist on that class, it will use the method resolution order to figure out which method to call on its inheritance chain. In this case, you've only got one, so it's going to call Base.new_obj and pass in the instance as the first argument (ie self).

All instances have a __class__ attribute, that refers to the class that they are an instance of. So given

 class Base:
     def new_obj(self):
          return self.__class__()

 class Derived(Base): pass

 derived = Derived()

The following lines are functionally equivalent:

 derived.new_obj()
 # or
 Base.new_obj(derived)

You may have encountered a relative of this if you've either forgotten to add the self parameter to your function declaration, or not provided enough arguments to a function and seen a stack trace that looks like this:

>>> f.bar()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bar() takes exactly 2 arguments (1 given)

Answer 3

You can use a classmethod:

class Base:
    def __init__(self):
        pass

    @classmethod
    def new_obj(cls):
        return cls()

class Derived(Base):
    def __init__(self):
        pass

>>> b = Base()
>>> b.new_obj()
<__main__.Base at 0x10fc12208>
>>> d = Derived()
>>> d.new_obj()
<__main__.Derived at 0x10fdfce80>

Answer 4

You can also do this with a class method, which you create with a decorator.

In [1]: class Base:
   ...:     @classmethod
   ...:     def new_obj(cls):
   ...:         return cls()
   ...:

In [2]: class Derived(Base): pass

In [3]: print type(Base.new_obj())
<type 'instance'>

In [4]: print Base.new_obj().__class__
__main__.Base

In [5]: print Derived.new_obj().__class__
__main__.Derived

Incidentally (you may know this), you don't have to create __init__ methods if you don't do anything with them.