Динамическая диспетчеризация — Python: Погружаясь в классы

• Особенности полиморфизма и наследования
• Позднее связывание в сравнении с динамической диспетчеризацией
• Выводы

В курсе «Python: Полиморфизм» мы разбирали, как работает полиморфизм изнутри. Но как наследование влияет на полиморфизм, осталось не до конца раскрытым.

В этом уроке мы погрузимся в данную тему и обсудим, как наследование взаимодействует с полиморфизмом и как это влияет на структуру и функциональность кода.

Особенности полиморфизма и наследования

Для полиморфизма наследование не нужно. При этом наследование участвует в процессе выбора метода.

Посмотрим на код, который был в курсе про полиморфизм:

class Dispatcher:
    # Что происходит при вызове: obj.get_name() => call_method(obj, 'get_name')
    def call_method(self, obj, method_name, *args):  # функция-диспетчер
        # Получаем список всех методов в классе объекта
        methods = [method for method in dir(obj) if callable(getattr(obj, method))]
        if method_name in methods:
            # Берем нужный метод и вызываем его
            getattr(obj, method_name)(*args)
        elif method_name not in methods and "__call__" in methods:
            # Если метод method_name не найден, но определен метод __call__, то вызываем его
            obj.__call__(*args)
        else:
            raise Exception("No method error")

В этом коде проверка останавливается, если ничего не было найдено. Так было бы без наследования, но с ним поиск продолжается.

Сначала выбирается базовый класс для текущего, и метод ищется там. Если он не найден, то снова проверяется наличие __call__(). Затем процесс повторяется для родительского класса родителя текущего класса и далее до конца цепочки наследования.

Из этого следует интересный вывод. Метод __call__ — это «тяжелый» вызов. Он требует больше вычислений для поиска. И чем ближе к началу иерархии расположен __call__(), тем хуже с точки зрения производительности.

Теперь, когда мы осознали этот аспект, сравним позднее связывание и динамическую диспетчеризацию, чтобы понять их различия и влияние на код.

Позднее связывание в сравнении с динамической диспетчеризацией

Часто разработчики путают позднее связывание и динамическую диспетчеризацию. Ситуация усложняется тем, что в некоторых языках, например, в Java, на уровне документации и сообщества одно понятие заменяется другим.

Диспетчеризация — это процесс поиска и вызова необходимой функции или метода для уже известного типа данных.

Динамическая диспетчеризация же представляет собой поиск необходимой функции во время исполнения программы, в отличие от статической, где поиск совершается во время компиляции.

Связывание сообщает о том, что представляет собой идентификатор и какого он типа. Если связывание раннее, мы знаем об этом сразу. В случае позднего — только в момент выполнения кода.

Например, в Python можно определить функцию после того, как она уже была использована где-то в коде. Это также является примером позднего связывания. В случае использования self в Python мы знаем, что это экземпляр текущего класса. Но мы не знаем точно, какого именно класса до момента выполнения этого кода.

Выводы

Различие между поздним связыванием и динамической диспетчеризацией является ключевым для понимания работы полиморфизма и наследования в Python. С пониманием этих концепций можно более эффективно использовать эти принципы в своем коде. Это приведет к созданию более мощных и гибких программ.

Дополнительные материалы

1. What is early and late binding?