Jak zainicjować klasę podstawową (super)?

W Pythonie weźmy pod uwagę następujący kod:

>>> 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?

Jak zainicjować SuperClass __init__w podklasie? Postępuję zgodnie z samouczkiem Pythona i nie obejmuje tego. Kiedy szukałem w Google, znalazłem więcej niż jeden sposób. Jaki jest standardowy sposób radzenia sobie z tym?

Python (do wersji 3) obsługuje klasy „w starym” i nowym stylu. Klasy w nowym stylu pochodzą od objecti są tym, czego używasz, i wywołują ich klasę bazową za pośrednictwem super(), np

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)

Ponieważ Python wie o klasach w starym i nowym stylu, istnieją różne sposoby wywoływania metody bazowej, dlatego znalazłeś wiele sposobów, aby to zrobić.

Ze względu na kompletność klasy w starym stylu wywołują metody bazowe jawnie przy użyciu klasy bazowej, tj

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

Ale ponieważ nie powinieneś już używać starego stylu, nie przejmowałbym się tym zbytnio.

Python 3 wie tylko o klasach w nowym stylu (bez względu na to, czy pochodzisz, objectczy nie).

Obie

SuperClass.__init__(self, x)

lub

super(SubClass,self).__init__( x )

zadziała (wolę ten drugi, ponieważ bardziej odpowiada zasadzie DRY).

Zobacz tutaj: http://docs.python.org/reference/datamodel.html#basic-customization

Począwszy od Pythona 3.5.2, możesz użyć:

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

Jak zainicjować klasę podstawową (super)?

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

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

Użyj superobiektu, aby upewnić się, że otrzymasz następną metodę (jako metodę powiązaną) w kolejności rozwiązywania metod. W Pythonie 2 musisz przekazać nazwę klasy i selfsuper, aby wyszukać powiązaną __init__metodę:

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

W Pythonie 3 jest trochę magii, która sprawia, że ​​argumenty są superniepotrzebne - i jako korzyść uboczna działa trochę szybciej:

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

Zakodowanie rodzica w następujący sposób zapobiega korzystaniu z wielokrotnego dziedziczenia w trybie współpracy:

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

Zauważ, że __init__może tylko powrócićNone - ma na celu modyfikację obiektu w miejscu.

Coś __new__

Istnieje inny sposób inicjowania instancji - i jest to jedyny sposób na podklasy niezmiennych typów w Pythonie. Więc nie jest to wymagane, jeśli chcesz podklasy strlub tuplelub innego niezmiennego obiektu.

Możesz pomyśleć, że jest to metoda klasowa, ponieważ pobiera niejawny argument klasy. Ale w rzeczywistości jest to metoda statyczna . Więc musisz jawnie zadzwonić __new__z cls.

Zwykle zwracamy instancję z __new__, więc jeśli to zrobisz, musisz również zadzwonić do swojej bazy przez __new__via superw swojej klasie bazowej. Więc jeśli używasz obu metod:

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 omija trochę dziwaczności super wywołań spowodowanych tym, __new__że jest metodą statyczną, ale nadal musisz przejść clsdo metody niezwiązanej __new__:

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')