it-swarm.com.ru

Понимание Python super () с помощью методов __init __ ()

Я пытаюсь понять использование super(). Судя по всему, оба дочерних класса могут быть созданы, просто отлично.

Мне любопытно узнать о фактической разнице между следующими 2 дочерними классами.

class Base(object):
    def __init__(self):
        print "Base created"

class ChildA(Base):
    def __init__(self):
        Base.__init__(self)

class ChildB(Base):
    def __init__(self):
        super(ChildB, self).__init__()

ChildA() 
ChildB()
2265
Mizipzor

super() позволяет избежать явного обращения к базовому классу, который может быть Nice. Но главное преимущество заключается в множественном наследовании, где могут произойти все виды забавные вещи . Смотрите стандартные документы по super , если вы еще этого не сделали.

Обратите внимание, что синтаксис изменен в Python 3. : вы можете просто сказать super().__init__() вместо super(ChildB, self).__init__(), что IMO немного лучше. Стандартные документы также ссылаются на руководство по использованию super () , что довольно объяснительно.

1630
Kiv

Я пытаюсь понять super()

Причина, по которой мы используем super, заключается в том, что дочерние классы, которые могут использовать кооперативное множественное наследование, будут вызывать правильную функцию следующего родительского класса в Порядке разрешения методов (MRO).

В Python 3 мы можем назвать это так:

class ChildB(Base):
    def __init__(self):
        super().__init__() 

В Python 2 мы должны использовать его следующим образом:

        super(ChildB, self).__init__()

Без супер вы ограничены в возможности использовать множественное наследование:

        Base.__init__(self) # Avoid this.

Я объясню ниже.

"Какая разница на самом деле в этом коде ?:"

class ChildA(Base):
    def __init__(self):
        Base.__init__(self)

class ChildB(Base):
    def __init__(self):
        super(ChildB, self).__init__()
        # super().__init__() # you can call super like this in Python 3!

Основное различие в этом коде состоит в том, что вы получаете слой косвенности в __init__ с super, который использует текущий класс для определения __init__ следующего класса для поиска в MRO.

Я иллюстрирую это различие в ответе на канонический вопрос, Как использовать 'super' в Python? , который демонстрирует внедрение зависимости и кооперативное множественное наследование .

Если Python не было super

Вот код, который на самом деле близко эквивалентен super (как он реализован в C, за исключением некоторой проверки и аварийного поведения и переведен на Python):

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()             # Get the Method Resolution Order.
        check_next = mro.index(ChildB) + 1 # Start looking after *this* class.
        while check_next < len(mro):
            next_class = mro[check_next]
            if '__init__' in next_class.__dict__:
                next_class.__init__(self)
                break
            check_next += 1

Написано немного больше как родной Python:

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()
        for next_class in mro[mro.index(ChildB) + 1:]: # slice to end
            if hasattr(next_class, '__init__'):
                next_class.__init__(self)
                break

Если бы у нас не было объекта super, нам пришлось бы везде писать этот ручной код (или пересоздавать его!), Чтобы убедиться, что мы вызываем правильный следующий метод в Порядке разрешения методов!

Как super делает это в Python 3, не сообщая явно, из какого класса и экземпляра метода, из которого он был вызван?

Он получает фрейм вызывающего стека и находит класс (неявно хранящийся как локальная свободная переменная __class__, делающий вызывающую функцию закрытием над классом) и первый аргумент этой функции, который должен быть экземпляром или классом, информирующим ее какой порядок разрешения методов (MRO) использовать.

Поскольку для этого требуется первый аргумент для MRO, использование super со статическими методами невозможно .

Критика других ответов:

super () позволяет избежать явного обращения к базовому классу, который может быть Nice. , Но главное преимущество заключается в множественном наследовании, где могут происходить разные забавные вещи. Смотрите стандартные документы по супер, если вы еще этого не сделали.

Это довольно запутанно и мало что нам говорит, но смысл super не в том, чтобы не писать родительский класс. Смысл в том, чтобы следующий метод в очереди в порядке разрешения методов (MRO) вызывался. Это становится важным при множественном наследовании.

Я объясню здесь.

class Base(object):
    def __init__(self):
        print("Base init'ed")

class ChildA(Base):
    def __init__(self):
        print("ChildA init'ed")
        Base.__init__(self)

class ChildB(Base):
    def __init__(self):
        print("ChildB init'ed")
        super(ChildB, self).__init__()

И давайте создадим зависимость, которую мы хотим вызывать после Child:

class UserDependency(Base):
    def __init__(self):
        print("UserDependency init'ed")
        super(UserDependency, self).__init__()

Теперь запомните, ChildB использует super, ChildA не делает:

class UserA(ChildA, UserDependency):
    def __init__(self):
        print("UserA init'ed")
        super(UserA, self).__init__()

class UserB(ChildB, UserDependency):
    def __init__(self):
        print("UserB init'ed")
        super(UserB, self).__init__()

И UserA не вызывает метод UserDependency:

>>> UserA()
UserA init'ed
ChildA init'ed
Base init'ed
<__main__.UserA object at 0x0000000003403BA8>

Но UserB, потому что ChildB использует super, делает !:

>>> UserB()
UserB init'ed
ChildB init'ed
UserDependency init'ed
Base init'ed
<__main__.UserB object at 0x0000000003403438>

Критика для другого ответа

Ни при каких обстоятельствах вы не должны делать следующее, что предлагает другой ответ, поскольку вы определенно получите ошибки, когда будете использовать подкласс ChildB:

        super(self.__class__, self).__init__() # Don't do this. Ever.

(Этот ответ не является умным или особенно интересным, но, несмотря на прямую критику в комментариях и более 17 отрицательных ответов, ответчик настойчиво предлагал его, пока добрый редактор не исправил свою проблему.)

Пояснение: Этот ответ предложил назвать супер так:

super(self.__class__, self).__init__()

Это совершенно неправильно. super позволяет нам искать следующего родителя в MRO (см. первый раздел этого ответа) для дочерних классов. Если вы скажете super, что мы в методе дочернего экземпляра, он будет искать следующий метод в строке (вероятно, этот), что приведет к рекурсии, вероятно, вызовет логический сбой (в примере с ответчиком, это так) или RuntimeError, когда глубина рекурсии превышена.

>>> class Polygon(object):
...     def __init__(self, id):
...         self.id = id
...
>>> class Rectangle(Polygon):
...     def __init__(self, id, width, height):
...         super(self.__class__, self).__init__(id)
...         self.shape = (width, height)
...
>>> class Square(Rectangle):
...     pass
...
>>> Square('a', 10, 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
TypeError: __init__() missing 2 required positional arguments: 'width' and 'height'
579
Aaron Hall

Было отмечено, что в Python 3.0+ вы можете использовать

super().__init__()

сделать ваш вызов, который является кратким и не требует явной ссылки на имена родительских OR классов, что может быть удобно. Я просто хочу добавить, что для Python 2.7 или ниже, возможно получить это нечувствительное к имени поведение, написав self.__class__ вместо имени класса, т.е.

super(self.__class__, self).__init__()

ОДНАКО, это прерывает вызовы super для любых классов, которые наследуются от вашего класса, где self.__class__ может возвращать дочерний класс. Например:

class Polygon(object):
    def __init__(self, id):
        self.id = id

class Rectangle(Polygon):
    def __init__(self, id, width, height):
        super(self.__class__, self).__init__(id)
        self.shape = (width, height)

class Square(Rectangle):
    pass

Здесь у меня есть класс Square, который является подклассом Rectangle. Скажем, я не хочу писать отдельный конструктор для Square, потому что конструктор для Rectangle достаточно хорош, но по какой-то причине я хочу реализовать Square, чтобы я мог переопределить какой-то другой метод.

Когда я создаю Square, используя mSquare = Square('a', 10,10), Python вызывает конструктор для Rectangle, потому что я не дал Square свой собственный конструктор. Однако в конструкторе для Rectangle вызов super(self.__class__,self) будет возвращать суперкласс mSquare, поэтому он снова вызывает конструктор для Rectangle. Вот как происходит бесконечный цикл, как было упомянуто @S_C. В этом случае, когда я запускаю super(...).__init__(), я вызываю конструктор для Rectangle, но так как я не даю ему аргументов, я получу ошибку.

242
AnjoMan

Супер не имеет побочных эффектов

Base = ChildB

Base()

работает как положено

Base = ChildA

Base()

попадает в бесконечную рекурсию.

80
S C

Просто наполовину ... с Python 2.7, и я верю, что с тех пор, как super() была представлена ​​в версии 2.2, вы можете вызывать super() только если один из родителей наследует от класса который в конечном итоге наследует object ( классы нового стиля ).

Что касается кода python 2.7, я буду продолжать использовать BaseClassName.__init__(self, args), пока не получу преимущество от использования super().

71
rgenito

Нет, правда. super() просматривает следующий класс в MRO (порядок разрешения методов, доступ к которому осуществляется с помощью cls.__mro__) для вызова методов. Простой вызов базы __init__ вызывает базу __init__. Так случилось, что у MRO ровно один предмет - база. Таким образом, вы действительно делаете то же самое, но более приятным способом с super() (особенно, если позже вы получите множественное наследование).

50
Devin Jeanpierre

Основное отличие состоит в том, что ChildA.__init__ безусловно вызовет Base.__init__, тогда как ChildB.__init__ будет вызывать __init__ в независимо от того, какой класс является предком ChildB в строке self_ предков (которые могут отличаться) из того, что вы ожидаете).

Если вы добавите ClassC, который использует множественное наследование:

class Mixin(Base):
  def __init__(self):
    print "Mixin stuff"
    super(Mixin, self).__init__()

class ChildC(ChildB, Mixin):  # Mixin is now between ChildB and Base
  pass

ChildC()
help(ChildC) # shows that the the Method Resolution Order is ChildC->ChildB->Mixin->Base

затем Base БОЛЬШЕ НЕ ЯВЛЯЕТСЯ РОДИТЕЛЕМ ChildB для экземпляров ChildC. Теперь super(ChildB, self) будет указывать на Mixin, если self является экземпляром ChildC.

Вы вставили Mixin между ChildB и Base. И вы можете воспользоваться этим с super()

Поэтому, если вы спроектировали свои классы так, чтобы они могли использоваться в сценарии кооперативного множественного наследования, вы используете super, потому что вы действительно не знаете, кто будет предком во время выполнения.

супер рассмотренный супер пост и pycon 2015, сопровождающий видео объясняют это довольно хорошо.

28
ecerulm