что такое super в python
Что делает «супер» в Python?
в чем разница между:
Я видел super используется довольно много в классах только с одним наследованием. Я понимаю, почему вы используете его в множественном наследовании, но неясно, каковы преимущества его использования в такой ситуации.
6 ответов
какая разница?
означает вызвать bound __init__ из родительского класса, который следует за Child в порядке разрешения метода экземпляра (MRO).
если экземпляр является подклассом дочернего, может быть другой родитель, который следующий в MRO.
объясняется просто
когда вы пишете класс, вы хотите, чтобы другие классы могли использовать он. super() облегчает другим классам использование класса, который вы пишете.
как говорит Боб Мартин, хорошая архитектура позволяет откладывать принятие решений как можно дольше.
super() может включить такую архитектуру.
когда другой класс подклассов класса, который вы написали, он также может наследовать от других классов. И у этих классов может быть __init__ это происходит после этого __init__ на основе порядка классов для метод разрешения.
без super вы, скорее всего, жестко закодируете родителя класса, который вы пишете (как в Примере). Это будет означать, что вы не будете называть следующий __init__ в MRO, и вы, таким образом, не сможете повторно использовать код в нем.
если вы пишете свой собственный код для личного использования, вы можете не заботиться об этом различии. Но если вы хотите, чтобы другие использовали ваш код, используя super одна вещь которая позволяет большей гибкости для потребителей код.
Python 2 Против 3
это работает в Python 2 и 3:
это работает только в Python 3:
он работает без аргументов, перемещаясь в кадре стека и получая первый аргумент метода (обычно self для метода экземпляра или cls для метода класса, но могут быть и другие имена) и нахождение класса (например, Child ) в свободных переменных (он просматривается с именем __class__ бесплатно переменная замыкания в методе).
косвенность с прямой совместимостью
что это дает тебе? Для единичного наследования примеры из вопроса практически идентичны с точки зрения статического анализа. Однако, используя super дает слой с вперед совместимость.
Forward совместимость очень важна для опытных разработчиков. Вы хотите, чтобы ваш код продолжал работать с минимальными изменениями по мере его изменения. Когда вы смотрите на свою историю изменений, вы хотите точно увидеть, что изменилось, когда.
Инъекции Зависимостей
другие люди могут использовать ваш код и ввести родителей в разрешение метода:
скажем, вы добавляете другой класс к своему объекту и хотите ввести класс между Foo и Bar (для тестирования или по какой-либо другой причине):
использование un-super child не удается ввести зависимость, потому что ребенок, который вы используете, жестко закодировал метод, который будет вызываться после его собственного:
класс с ребенком, который использует super может правильно ввести зависимость:
устранение комментарий
почему в мире это было бы полезно?
Python линеаризирует сложное дерево наследования через алгоритм линеаризации C3 для создания порядка разрешения метода (MRO).
мы хотим методов посмотрела в таком порядке.
оба дочерних класса намерены вызвать метод с тем же именем, что и следующий в MRO, который может быть другое класс он не знал, когда он был создан.
без super hard-codes его родительский метод-таким образом, это ограничило поведение его метода, и подклассы не могут вводить функциональность в цепочку вызовов.
один с super имеет большую гибкость. Цепочка вызовов для методов может быть перехвачена и введена функциональность.
вам может не понадобиться эта функциональность, но подклассы вашего кода могут.
вывод
всегда использовать super для ссылки на родительский класс, а не жесткого кодирования его.
вы собираетесь ссылаться на родительский класс, который является следующим в строке, а не конкретно на тот, который вы видите, наследует ребенок от.
не используя super может накладывать ненужные ограничения на пользователей вашего кода.
разве все это не предполагает, что базовый класс является классом нового стиля?
не будет работать в Python 2. class A должен быть новый стиль, i.e: class A(object)
например, у нас есть следующая иерархическая структура:
в этом случае MRO D будет (только для Python 3):
давайте создадим класс, в котором super() вызовы после выполнения метода.
таким образом, мы можем видеть, что порядок разрешения такой же, как в MRO. Но когда мы зовем super() в начало метод:
у нас есть другой порядок, он отменен порядком кортежа MRO.
для дополнительного чтения я бы рекомендовал следующие ответы:
при вызове super() чтобы разрешить родительскую версию classmethod, метода экземпляра или staticmethod, мы хотим передать текущий класс, область которого мы находимся в качестве первого аргумента, чтобы указать, к какой области родителя мы пытаемся разрешить, и в качестве второго аргумента объект интереса, чтобы указать, к какому объекту мы пытаемся применить эту область.
используя super С staticmethod
например, super() внутри __new__() метод
1-хотя это обычно для __new__() взять в качестве первого параметра ссылку на класс, называя это не реализовано в Python как classmethod, но скорее staticmethod. То есть ссылка на класс должна быть передана явно в качестве первого аргумента при вызове __new__() напрямую:
используя super С методом экземпляра
например, super() изнутри __init__()
используя super С classmethod
выше не будет работать, потому что A.alternate_constructor() метод принимает неявную ссылку на A в качестве первого аргумента. The cls передается здесь будет второй аргумент.
class Child(SomeBaseClass): def __init__(self): SomeBaseClass.__init__(self) Это довольно легко понять.
class Child(SomeBaseClass): def __init__(self): super(Child, self).__init__()
при создании дочернего экземпляра его MRO(порядок разрешения метода) находится в порядке (Дочерний, SomeBaseClass, object) на основе наследования. (предположим, что SomeBaseClass не имеет других родителей, кроме объекта по умолчанию)
для multi наследования MRO может содержать много классов, поэтому в основном super позволяет вам решить, где вы хотите начать поиск в MRO.
Множественное наследование, функция super
Продолжаем тему наследования классов в Python и поговорим о механизме множественного наследования.
Множественное наследование – это возможность построения дочернего класса на основе нескольких базовых.
Вот хорошая иллюстрация этого принципа: скрещивая лошадь с ослом, получаем мула.
В качестве примера множественного наследования построим класс графического примитива Line на основе двух классов: Styles и Pos. Если мы все запишем вот так:
То при запуске программы увидим ошибку, т.к. первый вызываемый инициализатор класса Pos принимает всего два аргумента, а мы передаем четыре. Давайте поправим этот момент и запишем его в таком виде:
Мы здесь добавили остаточные аргументы *args и далее, вызвали инициализатор второго базового класса Styles из класса Pos с этими остаточными аргументами. В результате у нас получилась полная инициализация данных как мы этого и хотели. Теперь, при вызове метода:
мы видим отображение всех указанных локальных свойств. И иерархия наших классов стала следующей:
Но при таком построении программы есть один большой недостаток. Если, например, мы в классе Line поменяем порядок наследования базовых классов:
то при выполнении у нас возникнет ошибка, т.к. сначала будет вызван инициализатор класса Styles, а в нем по прежнему всего два параметра. Ну, хорошо, давайте добавим и ему остаточные аргументы:
И, далее, мы должны, получается, еще вызвать инициализатор класса Pos. Но, тогда у нас получится рекурсия: из Styles вызываем Pos, а из Pos – Styles! И такая путаница возникла всего из двух базовых классов! А представьте, если их будет десяток? Для выхода из такой ситуации как раз и была предложена функция super(). Она позволяет обойти всех предков в определенном порядке и только один раз. Давайте поставим вызов этой функции вместо конкретных классов:
И, теперь, при запуске у нас нет никаких ошибок, кроме изменения порядка записи значений в атрибуты. Но, это логично, т.к. мы сначала вызвали Styles и записали координаты, а затем, Pos и записали через него свойства. Если поменять порядок наследования:
то все будет в правильном порядке.
Но такой вариант множественного наследования тоже не очень хорош. Вызывать инициализаторы с аргументами в этом случае порочная практика, т.к. даже незначительное изменение иерархии классов может привести к серьезным ошибкам. Поэтому, чаще всего, инициализаторы при множественном наследовании записывают без аргументов. В нашем случае программу можно очень легко изменить, записав ее так. В класс Line добавим инициализатор с аргументами:
И, далее, просто вызываем super() и указываем инициализаторы вышестоящих классов без аргументов:
Запускаем программу, и видим, что все работает абсолютно также. Но, зато теперь, мы можем наследовать классы в любом порядке:
И это не приведет к какой-либо ошибке. Кстати, в действительности, на вершине иерархии наших классов стоит класс object, который наследуется по умолчанию любым классом в Python:
Так вот, функция super() перебирает предков в соответствии с алгоритмом поиска C3:
C3 – поиск в дереве наследования классов Python 3 (MRO)
Более подробно об этом алгоритме можно почитать здесь:
В соответствии с алгоритмом MRO обход нашего дерева наследования будет происходить так:
Line → Pos → Styles → object
Кстати, для любого класса мы можем посмотреть этот список:
И получаем последовательность в соответствии с описанным алгоритмом.
Задание для самоподготовки
Создайте дочерний класс Motherboard (материнская плата), которая наследуется от классов: CPU (процессор), GPU (графич. сопроцессор), Memory (память). В свою очередь CPU наследуется от классов: AMD и Intell, GPU от классов NVidia, GeForce.
Создайте экземпляр класса Motherboard и наполните ее конкретным содержимым (локальным свойствам этого объекта присвойте определенные значения). Определите вспомогательные методы в базовых классах и выведите итоговую информацию в консоль с помощью метода showInfo() класса Motherboard.
Видео по теме
#1: парадигма ООП, классы, экземпляры классов, атрибуты
#2: методы класса, параметр self, конструктор и деструктор
#4: объекты свойства (property) и дескрипторы классов
#5: статические свойства и методы классов, декоратор @staticmethod, создание синглетона
#6: простое наследование классов, режим доступа protected
#7: переопределение и перегрузка методов, абстрактные методы
#8: множественное наследование, функция super
#9: перегрузка операторов
#10: собственные исключения и итерабельные объекты
#11: функторы и менеджеры контекста
#12: нейронная сеть (пример реализации)
#14: полиморфизм в ООП на Python
#15: Моносостояние экземпляров класса
#16: Магические методы __str__, __repr__, __len__, __abs__
#17: Коллекция __slots__ для классов
#18: Как работает __slots__ с property и при наследовании классов
#19. Введение в обработку исключений
#20. Распространение исключений (propagation exceptions)
#21. Инструкция raise и пользовательские исключения
© 2021 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Python Super () – простое иллюстрированное руководство
Встроенный метод Super () Python возвращает временный объект суперкласса, чтобы помочь вам получить доступ к своим методам. Его цель состоит в том, чтобы избежать использования имени базового класса. Это также позволяет вашему классу наследовать из нескольких базовых классов. Визуальная идея Super () Идея проста: используйте Super (), чтобы вызвать методы, определенные в … Python Super () – простая иллюстрированная руководство Подробнее »
Встроенный Python Super () Метод возвращает временный объект суперкласса, чтобы помочь вам получить доступ к своим методам. Его цель состоит в том, чтобы избежать использования имени базового класса. Это также позволяет вашему классу наследовать из нескольких базовых классов.
Визуальная идея супер ()
Идея просто: использовать Super () Чтобы вызвать методы, определенные в родительских классах – будь то ваш ребенок класс наследует от одного или нескольких базовых классов. Смотрите графику:
Нужно мне вести вас через этот пример? Посмотрите видео объяснения следующим!
Видео супер () на примере
Далее вы узнаете обоих случаях по примеру!
Простой пример 1: Super () с одним наследством
Наследование В объектно-ориентированном программировании позволяет создавать классовую иерархию, где один класс ребенка наследует все методы от другого родительского класса. Это упрощает разработку крупных программных проектов и позволяет избежать избыточного кода. Вы можете узнать больше о концепции наследства в наших Руководство по разговору здесь Отказ
Например, следующий код определяет родительский класс Организм и детский класс Человек Отказ Детский класс использует Super () Чтобы запустить конструктор метода родительского класса.
Здесь вы называете базовый класс организм, используя следующий код:
Семантически эквивалентный звонок кода будет:
Вы называете __init __ () Метод на базовом классе Организм и передайте ссылку на экземпляр вызова в качестве аргумента. Таким образом, вы также можете изменить внутренние атрибуты Я экземпляр в конструкторе базового класса.
Пример 2: Супер () с несколькими наследованием
Один из уникальных функций Python по сравнению с другими языками программирования состоит в том, что это позволяет Многократное наследование Отказ
Многократное наследование означает, что класс может наследовать от нескольких родителей. Например, класс Человек Может наследовать от двух родительских классов: Организм и Мыслитель Отказ Скажем, вы определяете метод Live () в организме и думаю () в мыслителе. Если человеческий объект наследует от обоих классов, он может позвонить Live () и думаю () в то же время! Вы используете Super () Способ для вызова этих функций:
Я должен упомянуть, что в этом примере вы также могли бы назвать Self.Live () и self.Том () В классе Человек вместо Super (). Живи () и Super (). думаю () Отказ Выходность будет одинаковым в обоих случаях. На практике вы бы использовали бывшие для Методы экземпляра и последний за Методы класса Отказ Разница между оба объясняется в нашем руководстве в блоге здесь.
Резюме
Встроенный Python Super () Метод возвращает временный объект суперкласса, чтобы помочь вам получить доступ к своим методам. Его цель состоит в том, чтобы избежать использования имени базового класса. Это также позволяет вашему классу наследовать из нескольких базовых классов.
Вы можете погрузиться глубже в некоторые из пособий Super () Метод здесь:
Если вы потратили час, изучающие все три ресурса, вы стали Super () Суперзвезда – и это поможет вам по всей вашей программированной карьере. Хорошая прибыль в инвестированное время!
Куда пойти отсюда?
Достаточно теории, давайте познакомимся!
Чтобы стать успешным в кодировке, вам нужно выйти туда и решать реальные проблемы для реальных людей. Вот как вы можете легко стать шестифункциональным тренером. И вот как вы польские навыки, которые вам действительно нужны на практике. В конце концов, что такое использование теории обучения, что никто никогда не нуждается?
Практические проекты – это то, как вы обостряете вашу пилу в кодировке!
Вы хотите стать мастером кода, сосредоточившись на практических кодовых проектах, которые фактически зарабатывают вам деньги и решают проблемы для людей?
Затем станьте питоном независимым разработчиком! Это лучший способ приближения к задаче улучшения ваших навыков Python – даже если вы являетесь полным новичком.
Присоединяйтесь к моему бесплатным вебинаре «Как создать свой навык высокого дохода Python» и посмотреть, как я вырос на моем кодированном бизнесе в Интернете и как вы можете, слишком от комфорта вашего собственного дома.
Присоединяйтесь к свободному вебинару сейчас!
Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.
Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.
Его страсти пишут, чтение и кодирование. Но его величайшая страсть состоит в том, чтобы служить стремлению кодер через Finxter и помогать им повысить свои навыки. Вы можете присоединиться к его бесплатной академии электронной почты здесь.
Supercharge Your Classes With Python super()
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Supercharge Your Classes With Python super()
In this tutorial, you’ll learn about the following:
Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you’ll need to take your Python skills to the next level.
An Overview of Python’s super() Function
If not, don’t fear! While the official documentation is fairly technical, at a high level super() gives you access to methods in a superclass from the subclass that inherits from it.
super() alone returns a temporary object of the superclass that then allows you to call that superclass’s methods.
Why would you want to do any of this? While the possibilities are limited by your imagination, a common use case is building classes that extend the functionality of previously built classes.
Calling the previously built methods with super() saves you from needing to rewrite those methods in your subclass, and allows you to swap out superclasses with minimal code changes.
super() in Single Inheritance
If you’re unfamiliar with object-oriented programming concepts, inheritance might be an unfamiliar term. Inheritance is a concept in object-oriented programming in which a class derives (or inherits) attributes and behaviors from another class without needing to implement them again.
For me at least, it’s easier to understand these concepts when looking at code, so let’s write classes describing some shapes:
You can use them as below:
In this example, you have two shapes that are related to each other: a square is a special kind of rectangle. The code, however, doesn’t reflect that relationship and thus has code that is essentially repeated.
By using inheritance, you can reduce the amount of code you write while simultaneously reflecting the real-world relationship between rectangles and squares:
Here, you’ve used super() to call the __init__() of the Rectangle class, allowing you to use it in the Square class without repeating code. Below, the core functionality remains after making changes:
In this example, Rectangle is the superclass, and Square is the subclass.
Note: To learn more about inheritance and object-oriented concepts in Python, be sure to check out Inheritance and Composition: A Python OOP Guide and Object-Oriented Programming (OOP) in Python 3.
What Can super() Do for You?
So what can super() do for you in single inheritance?
Like in other object-oriented languages, it allows you to call methods of the superclass in your subclass. The primary use case of this is to extend the functionality of the inherited method.
Now that you’ve built the classes, let’s look at the surface area and volume of a cube with a side length of 3 :
Caution: Note that in our example above, super() alone won’t make the method calls for you: you have to call the method on the proxy object itself.
A super() Deep Dive
While the examples above (and below) call super() without any parameters, super() can also take two parameters: the first is the subclass, and the second parameter is an object that is an instance of that subclass.
First, let’s see two examples showing what manipulating the first variable can do, using the classes already shown:
Caution: While we are doing a lot of fiddling with the parameters to super() in order to explore how it works under the hood, I’d caution against doing this regularly.
The parameterless call to super() is recommended and sufficient for most use cases, and needing to change the search hierarchy regularly could be indicative of a larger design issue.
By including an instantiated object, super() returns a bound method: a method that is bound to the object, which gives the method the object’s context such as any instance attributes. If this parameter is not included, the method returned is just a function, unassociated with an object’s context.
For more information about bound methods, unbound methods, and functions, read the Python documentation on its descriptor system.
Note: Technically, super() doesn’t return a method. It returns a proxy object. This is an object that delegates calls to the correct class methods without making an additional object in order to do so.
super() in Multiple Inheritance
Now that you’ve worked through an overview and some examples of super() and single inheritance, you will be introduced to an overview and some examples that will demonstrate how multiple inheritance works and how super() enables that functionality.
Multiple Inheritance Overview
There is another use case in which super() really shines, and this one isn’t as common as the single inheritance scenario. In addition to single inheritance, Python supports multiple inheritance, in which a subclass can inherit from multiple superclasses that don’t necessarily inherit from each other (also known as sibling classes).
I’m a very visual person, and I find diagrams are incredibly helpful to understand concepts like this. The image below shows a very simple multiple inheritance scenario, where one class inherits from two unrelated (sibling) superclasses:
A diagrammed example of multiple inheritance (Image: Kyle Stratis)
To better illustrate multiple inheritance in action, here is some code for you to try out, showing how you can build a right pyramid (a pyramid with a square base) out of a Triangle and a Square :
Note: The term slant height may be unfamiliar, especially if it’s been a while since you’ve taken a geometry class or worked on any pyramids.
The slant height is the height from the center of the base of an object (like a pyramid) up its face to the peak of that object. You can read more about slant heights at WolframMathWorld.
Method Resolution Order
The method resolution order (or MRO) tells Python how to search for inherited methods. This comes in handy when you’re using super() because the MRO tells you exactly where Python will look for a method you’re calling with super() and in what order.
Luckily, you have some control over how the MRO is constructed. Just by changing the signature of the RightPyramid class, you can search in the order you want, and the methods will resolve correctly:
Now, you can build a pyramid, inspect the MRO, and calculate the surface area:
There’s still a problem here, though. For the sake of simplicity, I did a few things wrong in this example: the first, and arguably most importantly, was that I had two separate classes with the same method name and signature.
When you’re using super() with multiple inheritance, it’s imperative to design your classes to cooperate. Part of this is ensuring that your methods are unique so that they get resolved in the MRO, by making sure method signatures are unique—whether by using method names or method parameters.
Let’s also go ahead and use this in the RightPyramid class:
You need to do two things to fix this:
Complete Code Example Show/Hide
There are a number of important differences in this code:
** kwargs is modified in some places (such as RightPyramid.__init__() ):** This will allow users of these objects to instantiate them only with the arguments that make sense for that particular object.
Now, when you use these updated classes, you have this:
It works! You’ve used super() to successfully navigate a complicated class hierarchy while using both inheritance and composition to create new classes with minimal reimplementation.
Multiple Inheritance Alternatives
As you can see, multiple inheritance can be useful but also lead to very complicated situations and code that is hard to read. It’s also rare to have objects that neatly inherit everything from more than multiple other objects.
If you see yourself beginning to use multiple inheritance and a complicated class hierarchy, it’s worth asking yourself if you can achieve code that is cleaner and easier to understand by using composition instead of inheritance. Since this article is focused on inheritance, I won’t go into too much detail on composition and how to wield it in Python. Luckily, Real Python has published a deep-dive guide to both inheritance and composition in Python that will make you an OOP pro in no time.
There’s another technique that can help you get around the complexity of multiple inheritance while still providing many of the benefits. This technique is in the form of a specialized, simple class called a mixin.
A mixin works as a kind of inheritance, but instead of defining an “is-a” relationship it may be more accurate to say that it defines an “includes-a” relationship. With a mix-in you can write a behavior that can be directly included in any number of other classes.
Below, you will see a short example using VolumeMixin to give specific functionality to our 3D objects—in this case, a volume calculation:
This mixin can be used the same way in any other class that has an area defined for it and for which the formula area * height returns the correct volume.
A super() Recap
You then learned how multiple inheritance works in Python, and techniques to combine super() with multiple inheritance. You also learned about how Python resolves method calls using the method resolution order (MRO), as well as how to inspect and modify the MRO to ensure appropriate methods are called at appropriate times.
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Supercharge Your Classes With Python super()
Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.
About Kyle Stratis
Kyle is a self-taught developer working as a senior data engineer at Vizit Labs. In the past, he has founded DanqEx (formerly Nasdanq: the original meme stock exchange) and Encryptid Gaming.
Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:
Master Real-World Python Skills With Unlimited Access to Real Python
Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas:
Master Real-World Python Skills
With Unlimited Access to Real Python
Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas:
Real Python Comment Policy: The most useful comments are those written with the goal of learning from or helping out other readers—after reading the whole article and all the earlier comments. Complaints and insults generally won’t make the cut here.
What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.