python - oriented - ¿Cómo inicializo la base(super) clase?

python oop exercises

Question

En Python, considere que tengo el siguiente código:

>>> class SuperClass(object):
    def __init__(self, x):
        self.x = x

>>> class SubClass(SuperClass):
    def __init__(self, y):
        self.y = y
        # how do I initialize the SuperClass __init__ here?

¿Cómo inicializo SuperClass __init__ en la subclase? Estoy siguiendo el tutorial de Python y no cubre eso. Cuando busqué en Google, encontré más de una forma de hacerlo. ¿Cuál es la forma estándar de manejar esto?

Answer 1

¿Cómo inicializo la base (super) clase?

class SuperClass(object):
    def __init__(self, x):
        self.x = x

class SubClass(SuperClass):
    def __init__(self, y):
        self.y = y

Use un super objeto para asegurarse de obtener el siguiente método (como un método vinculado) en el orden de resolución del método. En Python 2, debe pasar el nombre de la clase y self a súper para buscar el método __init__ enlazado:

 class SubClass(SuperClass):
      def __init__(self, y):
          super(SubClass, self).__init__(''x'')
          self.y = y

En Python 3, hay un poco de magia que hace que los argumentos sean super innecesarios, y como beneficio secundario funciona un poco más rápido:

 class SubClass(SuperClass):
      def __init__(self, y):
          super().__init__(''x'')
          self.y = y

La codificación del padre como esta a continuación le impide usar herencia múltiple cooperativa:

 class SubClass(SuperClass):
      def __init__(self, y):
          SuperClass.__init__(self, ''x'') # don''t do this
          self.y = y

Tenga en cuenta que __init__ solo puede devolver None - está destinado a modificar el objeto in situ.

Algo __new__

Hay otra forma de inicializar instancias, y es la única forma para subclases de tipos inmutables en Python. Por lo tanto, es necesario si desea subclasar str o tuple u otro objeto inmutable.

Puede pensar que es un método de clase porque obtiene un argumento de clase implícito. Pero en realidad es un método estático . Entonces necesitas llamar a __new__ con cls explícitamente.

Por lo general, devolvemos la instancia de __new__ , por lo que si lo hace, también debe llamar a __new__ su base __new__ través de super en su clase base. Entonces, si usas ambos métodos:

class SuperClass(object):
    def __new__(cls, x):
        return super(SuperClass, cls).__new__(cls)
    def __init__(self, x):
        self.x = x

class SubClass(object):
    def __new__(cls, y):
        return super(SubClass, cls).__new__(cls)

    def __init__(self, y):
        self.y = y
        super(SubClass, self).__init__(''x'')

Python 3 elude un poco la rareza de las super llamadas causadas por que __new__ es un método estático, pero aún necesitas pasar cls al método __new__ no enlazado:

class SuperClass(object):
    def __new__(cls, x):
        return super().__new__(cls)
    def __init__(self, x):
        self.x = x

class SubClass(object):
    def __new__(cls, y):
        return super().__new__(cls)
    def __init__(self, y):
        self.y = y
        super().__init__(''x'')

Answer 2

A partir de Python 3.5.2, puede usar:

class C(B):
def method(self, arg):
    super().method(arg)    # This does the same thing as:
                           # super(C, self).method(arg)

https://docs.python.org/3/library/functions.html#super

Answer 3

Ambos

SuperClass.__init__(self, x)

o

super(SubClass,self).__init__( x )

funcionará (prefiero el segundo, ya que se adhiere más al principio DRY).

Vea aquí: http://docs.python.org/reference/datamodel.html#basic-customization

Answer 4

Python (hasta la versión 3) admite clases de "estilo antiguo" y de estilo nuevo. Las clases de nuevo estilo se derivan de object y son lo que estás usando e invocan su clase base a través de super() , por ej.

class X(object):
  def __init__(self, x):
    pass

  def doit(self, bar):
    pass

class Y(X):
  def __init__(self):
    super(Y, self).__init__(123)

  def doit(self, foo):
    return super(Y, self).doit(foo)

Debido a que python sabe sobre clases de estilo antiguo y nuevo, existen diferentes formas de invocar un método base, razón por la cual ha encontrado varias formas de hacerlo.

Para mayor completitud, las clases antiguas llaman a los métodos base explícitamente usando la clase base, es decir,

def doit(self, foo):
  return X.doit(self, foo)

Pero como ya no deberías usar el viejo estilo, no me interesaría demasiado.

Python 3 solo conoce las clases de estilo nuevo (no importa si deriva de un object o no).