Чем отличается полиморфизм от перегрузки методов?

И полиморфизм, и перегрузка методов - это концепции объектно-ориентированного программирования (ООП), но они отличаются по своей сути и механизму реализации.

Полиморфизм (от греч. "многоформность") означает возможность объектов разных классов реагировать на один и тот же метод (или оператор) по-разному. Это достигается через наследование и интерфейсы. Основная идея в том, чтобы иметь возможность использовать объекты разных классов, как будто они принадлежат к одному общему типу. В Python полиморфизм достигается в основном за счет duck typing, когда важна не принадлежность к конкретному классу, а наличие нужных методов (если объект "крякает как утка", то он и есть утка).

Пример полиморфизма:

class Animal:
    def make_sound(self):
        print("Животное издает звук")

class Dog(Animal):
    def make_sound(self):
        print("Гав!")

class Cat(Animal):
    def make_sound(self):
        print("Мяу!")

def animal_sound(animal):
    animal.make_sound()

my_dog = Dog()
my_cat = Cat()

animal_sound(my_dog)  # Выведет "Гав!"
animal_sound(my_cat)  # Выведет "Мяу!"

В этом примере функция animal_sound принимает объект типа Animal (или его потомка) и вызывает метод make_sound. Разные объекты (Dog и Cat) реагируют на вызов одного и того же метода по-разному.

Перегрузка методов означает возможность определить несколько методов с одним и тем же именем в одном классе, но с разными параметрами (разное количество, типы или порядок аргументов). Цель - обеспечить более гибкий интерфейс класса, позволяя вызывать один и тот же метод с разным набором данных. В классическом понимании перегрузки, как в Java или C++, Python не поддерживает перегрузку методов *напрямую* по сигнатуре (то есть по типу и количеству аргументов).

Эмуляция перегрузки методов в Python:

class Calculator:
    def add(self, a, b=None):
        if b is None:
            print(f"С одним аргументом: {a}")
            return a
        else:
            print(f"С двумя аргументами: {a + b}")
            return a + b


calc = Calculator()
calc.add(5)        # Выведет "С одним аргументом: 5"
calc.add(5, 3)      # Выведет "С двумя аргументами: 8"

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

Ключевые различия:

• Полиморфизм: Разные классы реагируют на один и тот же метод по-разному (через наследование или интерфейсы/протоколы).
• Перегрузка методов: Один класс имеет несколько методов с одним и тем же именем, но с разными параметрами (эмулируется в Python).
• Реализация: Полиморфизм в Python основан на "duck typing". Перегрузка, в строгом смысле, отсутствует, но можно имитировать с помощью аргументов по умолчанию или *args и **kwargs.

Таким образом, полиморфизм позволяет объектам разных классов вести себя по-разному при вызове одного и того же метода, а перегрузка (эмулируемая в Python) позволяет иметь несколько методов с одним именем, но с разным набором аргументов в *одном* классе. Оба механизма служат для повышения гибкости и удобства использования кода.