# Базовый класс
class Животное:
    def __init__(self, имя):
        self.имя = имя
    
    def издать_звук(self):
        pass  # Абстрактный метод
    
    def описание(self):
        return f"{self.имя} - животное"

# Подклассы
class Собака(Животное):
    def издать_звук(self):
        return f"{self.имя} говорит: Гав-гав!"
    
    def описание(self):
        return f"{self.имя} - собака"

class Кошка(Животное):
    def издать_звук(self):
        return f"{self.имя} говорит: Мяу-мяу!"
    
    def описание(self):
        return f"{self.имя} - кошка"

class Птица(Животное):
    def издать_звук(self):
        return f"{self.имя} говорит: Чирик-чирик!"
    
    def описание(self):
        return f"{self.имя} - птица"

# Функция, использующая полиморфизм
def показать_животное(животное):
    print(животное.описание())
    print(животное.издать_звук())
    print()

# Использование полиморфизма
животные = [
    Собака("Бобик"),
    Кошка("Мурка"),
    Птица("Чижик")
]

for животное in животные:
    показать_животное(животное)

from abc import ABC, abstractmethod

# Абстрактный базовый класс
class Фигура(ABC):
    def __init__(self, название):
        self.название = название
    
    @abstractmethod
    def площадь(self):
        pass
    
    @abstractmethod
    def периметр(self):
        pass
    
    def описание(self):
        return f"Это {self.название}"

# Конкретные реализации
class Прямоугольник(Фигура):
    def __init__(self, ширина, высота):
        super().__init__("прямоугольник")
        self.ширина = ширина
        self.высота = высота
    
    def площадь(self):
        return self.ширина * self.высота
    
    def периметр(self):
        return 2 * (self.ширина + self.высота)

class Круг(Фигура):
    def __init__(self, радиус):
        super().__init__("круг")
        self.радиус = радиус
    
    def площадь(self):
        import math
        return math.pi * self.радиус ** 2
    
    def периметр(self):
        import math
        return 2 * math.pi * self.радиус

class Треугольник(Фигура):
    def __init__(self, сторона_a, сторона_b, сторона_c):
        super().__init__("треугольник")
        self.сторона_a = сторона_a
        self.сторона_b = сторона_b
        self.сторона_c = сторона_c
    
    def площадь(self):
        # Формула Герона
        p = self.периметр() / 2
        return (p * (p - self.сторона_a) * (p - self.сторона_b) * (p - self.сторона_c)) ** 0.5
    
    def периметр(self):
        return self.сторона_a + self.сторона_b + self.сторона_c

# Функция, работающая с любыми фигурами
def анализировать_фигуру(фигура):
    print(фигура.описание())
    print(f"Площадь: {фигура.площадь():.2f}")
    print(f"Периметр: {фигура.периметр():.2f}")
    print()

# Использование полиморфизма
фигуры = [
    Прямоугольник(5, 3),
    Круг(4),
    Треугольник(3, 4, 5)
]

for фигура in фигуры:
    анализировать_фигуру(фигура)

# Функции, демонстрирующие полиморфизм
def длина_объекта(объект):
    return len(объект)

def итерировать_объект(объект):
    результат = []
    for элемент in объект:
        результат.append(элемент)
    return результат

def строковое_представление(объект):
    return str(объект)

# Разные типы объектов
объекты = [
    "строка",
    [1, 2, 3, 4],
    {"ключ": "значение"},
    (1, 2, 3),
    {1, 2, 3}
]

for объект in объекты:
    print(f"Объект: {объект}")
    print(f"Тип: {type(объект).__name__}")
    print(f"Длина: {длина_объекта(объект)}")
    print(f"Элементы: {итерировать_объект(объект)}")
    print(f"Строковое представление: {строковое_представление(объект)}")
    print()

class Вектор:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    # Сложение векторов
    def __add__(self, другой):
        if isinstance(другой, Вектор):
            return Вектор(self.x + другой.x, self.y + другой.y)
        return NotImplemented
    
    # Умножение вектора на число
    def __mul__(self, скаляр):
        if isinstance(скаляр, (int, float)):
            return Вектор(self.x * скаляр, self.y * скаляр)
        return NotImplemented
    
    # Умножение числа на вектор
    def __rmul__(self, скаляр):
        return self.__mul__(скаляр)
    
    # Строковое представление
    def __str__(self):
        return f"Вектор({self.x}, {self.y})"
    
    # Представление для отладки
    def __repr__(self):
        return f"Вектор({self.x}, {self.y})"
    
    # Сравнение векторов
    def __eq__(self, другой):
        if isinstance(другой, Вектор):
            return self.x == другой.x and self.y == другой.y
        return False
    
    # Длина вектора
    def __abs__(self):
        import math
        return math.sqrt(self.x ** 2 + self.y ** 2)

# Использование перегруженных операторов
вектор1 = Вектор(3, 4)
вектор2 = Вектор(1, 2)

print(f"Вектор 1: {вектор1}")
print(f"Вектор 2: {вектор2}")
print(f"Сумма: {вектор1 + вектор2}")
print(f"Умножение на 3: {вектор1 * 3}")
print(f"Умножение 2 на вектор: {2 * вектор2}")
print(f"Равны ли векторы: {вектор1 == вектор2}")
print(f"Длина вектора 1: {abs(вектор1):.2f}")

# Функция, которая может вызывать разные исключения
def обработать_данные(данные):
    try:
        if isinstance(данные, str):
            if not данные:
                raise ValueError("Строка не должна быть пустой")
            return len(данные)
        elif isinstance(данные, list):
            if not данные:
                raise IndexError("Список не должен быть пустым")
            return sum(данные)
        elif isinstance(данные, dict):
            if not данные:
                raise KeyError("Словарь не должен быть пустым")
            return len(данные)
        else:
            raise TypeError(f"Неподдерживаемый тип данных: {type(данные)}")
    except (ValueError, IndexError, KeyError, TypeError) as e:
        print(f"Ошибка: {e}")
        return None

# Тестирование с разными типами данных
тестовые_данные = [
    "Привет, мир!",
    "",
    [1, 2, 3, 4, 5],
    [],
    {"ключ1": "значение1", "ключ2": "значение2"},
    {},
    42
]

for данные in тестовые_данные:
    print(f"Обработка: {данные} (тип: {type(данные).__name__})")
    результат = обработать_данные(данные)
    if результат is not None:
        print(f"Результат: {результат}")
    print()

from abc import ABC, abstractmethod

# Абстрактный базовый класс для платежных систем
class ПлатежнаяСистема(ABC):
    def __init__(self, имя):
        self.имя = имя
    
    @abstractmethod
    def обработать_платеж(self, сумма):
        pass
    
    @abstractmethod
    def получить_комиссию(self, сумма):
        pass

# Конкретные реализации
class КредитнаяКарта(ПлатежнаяСистема):
    def __init__(self, имя, номер_карты):
        super().__init__(имя)
        self.номер_карты = номер_карты
    
    def обработать_платеж(self, сумма):
        комиссия = self.получить_комиссию(сумма)
        итоговая_сумма = сумма + комиссия
        return f"Платеж {сумма} через кредитную карту обработан. Комиссия: {комиссия}. Итого: {итоговая_сумма}"
    
    def получить_комиссию(self, сумма):
        return сумма * 0.02  # 2% комиссия

class PayPal(ПлатежнаяСистема):
    def __init__(self, имя, email):
        super().__init__(имя)
        self.email = email
    
    def обработать_платеж(self, сумма):
        комиссия = self.получить_комиссию(сумма)
        итоговая_сумма = сумма + комиссия
        return f"Платеж {сумма} через PayPal обработан. Комиссия: {комиссия}. Итого: {итоговая_сумма}"
    
    def получить_комиссию(self, сумма):
        return сумма * 0.03  # 3% комиссия

class БанковскийПеревод(ПлатежнаяСистема):
    def __init__(self, имя, номер_счета):
        super().__init__(имя)
        self.номер_счета = номер_счета
    
    def обработать_платеж(self, сумма):
        комиссия = self.получить_комиссию(сумма)
        итоговая_сумма = сумма + комиссия
        return f"Платеж {сумма} банковским переводом обработан. Комиссия: {комиссия}. Итого: {итоговая_сумма}"
    
    def получить_комиссию(self, сумма):
        return max(50, сумма * 0.01)  # Минимум 50 или 1%

# Система обработки платежей
class ПлатежныйПроцессор:
    def __init__(self):
        self.платежные_системы = []
    
    def добавить_систему(self, система):
        self.платежные_системы.append(система)
    
    def обработать_платежи(self, сумма):
        print(f"Обработка платежа на сумму {сумма} через все доступные системы:")
        for система in self.платежные_системы:
            print(система.обработать_платеж(сумма))
            print()

# Использование полиморфизма в системе платежей
процессор = ПлатежныйПроцессор()
процессор.добавить_систему(КредитнаяКарта("Visa", "****1234"))
процессор.добавить_систему(PayPal("PayPal", "user@example.com"))
процессор.добавить_систему(БанковскийПеревод("SWIFT", "SWIFT123456789"))

процессор.обработать_платежи(1000)