Приведи пример полиморфизма в Python

Полиморфизм в Python

Полиморфизм — это способность объектов разных типов отвечать на одно и то же сообщение (вызов метода) по-разному. В Python это реализуется через несколько механизмов.

1. Полиморфизм методов (Duck Typing)

Наиболее идиоматичный для Python подход. Объекты разных классов реализуют один и тот же интерфейс метода.

class Dog:
    def sound(self):
        return "Woof!"

class Cat:
    def sound(self):
        return "Meow!"

class Bird:
    def sound(self):
        return "Chirp!"

def make_animal_sound(animal):
    # Не проверяем тип, просто вызываем метод
    print(animal.sound())

# Использование
dog = Dog()
cat = Cat()
bird = Bird()

make_animal_sound(dog)    # Woof!
make_animal_sound(cat)    # Meow!
make_animal_sound(bird)   # Chirp!

Это работает благодаря принципу «утиной типизации» (duck typing): если объект как утка крякает, ходит и плывёт как утка — это утка.

2. Полиморфизм через наследование

Использование общего базового класса с виртуальными методами.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass
    
    def describe(self):
        return f"This is a {self.__class__.__name__}"

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

class Snake(Animal):
    def make_sound(self):
        return "Hiss!"

def animal_sounds(animals):
    for animal in animals:
        print(f"{animal.describe()}: {animal.make_sound()}")

# Использование
animals = [Dog(), Cat(), Snake()]
animal_sounds(animals)

# Вывод:
# This is a Dog: Woof!
# This is a Cat: Meow!
# This is a Snake: Hiss!

3. Полиморфизм операторов

Пеегрузка встроенных операторов через специальные методы.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(v1 + v2)     # Vector(4, 6)
print(v1 - v2)     # Vector(-2, -2)
print(v1 * 2)      # Vector(2, 4)

4. Полиморфизм через встроенные функции

Одна и та же функция работает с разными типами.

# len() работает со строками, списками, кортежами
print(len("hello"))        # 5
print(len([1, 2, 3]))      # 3
print(len((1, 2, 3, 4)))   # 4

# Наш класс с поддержкой len()
class Playlist:
    def __init__(self, songs):
        self.songs = songs
    
    def __len__(self):
        return len(self.songs)
    
    def __getitem__(self, index):
        return self.songs[index]

playlist = Playlist(["Song1", "Song2", "Song3"])
print(len(playlist))       # 3
print(playlist[0])         # Song1

5. Полиморфизм с использованием Protocol (структурная типизация)

Новый подход в Python 3.8+ для более явного определения интерфейсов.

from typing import Protocol

class Drawable(Protocol):
    def draw(self) -> str:
        ...

class Circle:
    def draw(self):
        return "Drawing a circle"

class Square:
    def draw(self):
        return "Drawing a square"

def render(shape: Drawable):
    print(shape.draw())

render(Circle())   # Drawing a circle
render(Square())   # Drawing a square

Преимущества полиморфизма

• Гибкость кода: легко добавлять новые типы без изменения существующего кода
• Переиспользуемость: один код работает с разными типами
• Масштабируемость: просто расширяется функционал
• Слабая связанность: компоненты не зависят друг от друга

Полиморфизм — это один из столпов объектно-ориентированного программирования и важная техника для написания чистого, гибкого кода.