Что такое абстрактная модель?

Абстрактная модель

Абстрактная модель — это представление объекта, системы или процесса, которое отражает только существенные характеристики и скрывает детали реализации. Это мощный инструмент в объектно-ориентированном программировании для создания неизменяемых интерфейсов и повышения переиспользуемости кода.

Основная идея

Абстракция позволяет:

• Скрывать сложность — пользователь видит только необходимые свойства
• Определять контракты — классы договариваются об интерфейсе
• Облегчать расширение — новые реализации соответствуют контракту
• Повышать переиспользуемость — общий интерфейс для разных реализаций

Абстрактные базовые классы (ABC)

В Python используется модуль abc (Abstract Base Class):

from abc import ABC, abstractmethod

class Animal(ABC):
    """Абстрактный класс для всех животных"""
    
    @abstractmethod
    def make_sound(self):
        """Издать звук"""
        pass
    
    @abstractmethod
    def move(self):
        """Передвигаться"""
        pass
    
    def describe(self):
        """Обычный метод"""
        return f"This is a {self.__class__.__name__}"

# Нельзя создать экземпляр абстрактного класса
# animal = Animal()  # TypeError: Can't instantiate abstract class

class Dog(Animal):
    """Конкретная реализация для собак"""
    
    def make_sound(self):
        return "Woof!"
    
    def move(self):
        return "Running on four legs"

class Bird(Animal):
    """Конкретная реализация для птиц"""
    
    def make_sound(self):
        return "Tweet tweet!"
    
    def move(self):
        return "Flying"

# Использование
dog = Dog()
print(dog.make_sound())  # Woof!
print(dog.describe())    # This is a Dog

bird = Bird()
print(bird.move())  # Flying

Абстрактные свойства

from abc import ABC, abstractmethod

class Shape(ABC):
    """Абстрактный класс для геометрических фигур"""
    
    @property
    @abstractmethod
    def area(self):
        """Площадь фигуры"""
        pass
    
    @property
    @abstractmethod
    def perimeter(self):
        """Периметр фигуры"""
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    @property
    def area(self):
        return self.width * self.height
    
    @property
    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    @property
    def area(self):
        return 3.14159 * self.radius ** 2
    
    @property
    def perimeter(self):
        return 2 * 3.14159 * self.radius

# Использование
rect = Rectangle(5, 10)
print(f"Rectangle area: {rect.area}")  # 50
print(f"Rectangle perimeter: {rect.perimeter}")  # 30

circle = Circle(5)
print(f"Circle area: {circle.area}")  # 78.54975

Абстрактные методы класса и статические методы

from abc import ABC, abstractmethod

class DataProcessor(ABC):
    """Абстрактный обработчик данных"""
    
    @classmethod
    @abstractmethod
    def from_file(cls, filename):
        """Загрузить данные из файла"""
        pass
    
    @staticmethod
    @abstractmethod
    def validate_data(data):
        """Проверить данные"""
        pass
    
    @abstractmethod
    def process(self):
        """Обработать данные"""
        pass

class CSVProcessor(DataProcessor):
    def __init__(self, data):
        self.data = data
    
    @classmethod
    def from_file(cls, filename):
        # Имитация загрузки CSV
        return cls(["row1", "row2", "row3"])
    
    @staticmethod
    def validate_data(data):
        return isinstance(data, list) and len(data) > 0
    
    def process(self):
        return [row.upper() for row in self.data]

processor = CSVProcessor.from_file("data.csv")
print(processor.process())  # ['ROW1', 'ROW2', 'ROW3']

Практический пример: система платежей

from abc import ABC, abstractmethod
from typing import Optional
from datetime import datetime

class PaymentMethod(ABC):
    """Абстрактный метод платежа"""
    
    @abstractmethod
    def validate(self) -> bool:
        """Проверить валидность платёжных данных"""
        pass
    
    @abstractmethod
    def charge(self, amount: float) -> bool:
        """Снять деньги"""
        pass
    
    @abstractmethod
    def refund(self, transaction_id: str) -> bool:
        """Вернуть деньги"""
        pass

class CreditCard(PaymentMethod):
    def __init__(self, card_number, cvv, expiry):
        self.card_number = card_number
        self.cvv = cvv
        self.expiry = expiry
        self.balance = 10000
    
    def validate(self) -> bool:
        return (
            len(self.card_number) == 16 and
            len(self.cvv) == 3 and
            datetime.strptime(self.expiry, '%m/%y') > datetime.now()
        )
    
    def charge(self, amount: float) -> bool:
        if self.validate() and self.balance >= amount:
            self.balance -= amount
            return True
        return False
    
    def refund(self, transaction_id: str) -> bool:
        self.balance += 100  # Имитация возврата
        return True

class PayPal(PaymentMethod):
    def __init__(self, email, password):
        self.email = email
        self.password = password
        self.is_authenticated = False
        self.balance = 5000
    
    def validate(self) -> bool:
        return '@' in self.email and len(self.password) >= 8
    
    def charge(self, amount: float) -> bool:
        if self.validate() and self.balance >= amount:
            self.balance -= amount
            return True
        return False
    
    def refund(self, transaction_id: str) -> bool:
        self.balance += 100
        return True

class Cryptocurrency(PaymentMethod):
    def __init__(self, wallet_address, network='bitcoin'):
        self.wallet_address = wallet_address
        self.network = network
        self.balance = 0.5
    
    def validate(self) -> bool:
        return len(self.wallet_address) >= 26
    
    def charge(self, amount: float) -> bool:
        if self.validate() and self.balance >= amount:
            self.balance -= amount
            return True
        return False
    
    def refund(self, transaction_id: str) -> bool:
        self.balance += 0.001
        return True

# Использование с полиморфизмом
def process_payment(payment_method: PaymentMethod, amount: float) -> bool:
    """Обработать платёж любым методом"""
    if not payment_method.validate():
        print(f"Invalid payment method: {type(payment_method).__name__}")
        return False
    
    if payment_method.charge(amount):
        print(f"Successfully charged {amount} via {type(payment_method).__name__}")
        return True
    else:
        print(f"Failed to charge {amount} via {type(payment_method).__name__}")
        return False

# Примеры
card = CreditCard("1234567890123456", "123", "12/25")
process_payment(card, 100)  # Successfully charged 100 via CreditCard

paypal = PayPal("user@example.com", "password123")
process_payment(paypal, 50)  # Successfully charged 50 via PayPal

crypto = Cryptocurrency("bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkyjh5cvrw")
process_payment(crypto, 0.1)  # Successfully charged 0.1 via Cryptocurrency

Абстрактные классы vs Интерфейсы

from abc import ABC, abstractmethod
from typing import Protocol

# Подход 1: Абстрактный класс (ABC)
class Logger(ABC):
    @abstractmethod
    def log(self, message: str):
        pass

# Подход 2: Protocol (более гибкий)
class Loggable(Protocol):
    def log(self, message: str) -> None:
        ...

# Любой класс с методом log работает с Protocol
class ConsoleLogger:
    def log(self, message: str):
        print(message)

class FileLogger:
    def log(self, message: str):
        with open('log.txt', 'a') as f:
            f.write(message + '\n')

def setup_logging(logger: Loggable):
    logger.log("Application started")

setup_logging(ConsoleLogger())  # Работает
setup_logging(FileLogger())  # Работает

Обязательные методы и аргументы

from abc import ABC, abstractmethod
from typing import Any

class Repository(ABC):
    """Абстрактный репозиторий для работы с БД"""
    
    @abstractmethod
    def find_by_id(self, id: int) -> Any:
        """Найти по ID"""
        pass
    
    @abstractmethod
    def find_all(self) -> list:
        """Получить все записи"""
        pass
    
    @abstractmethod
    def save(self, entity: Any) -> int:
        """Сохранить запись"""
        pass
    
    @abstractmethod
    def delete(self, id: int) -> bool:
        """Удалить запись"""
        pass

class UserRepository(Repository):
    def __init__(self):
        self.users = {}
        self.next_id = 1
    
    def find_by_id(self, id: int):
        return self.users.get(id)
    
    def find_all(self):
        return list(self.users.values())
    
    def save(self, entity):
        user_id = self.next_id
        self.users[user_id] = entity
        self.next_id += 1
        return user_id
    
    def delete(self, id: int):
        if id in self.users:
            del self.users[id]
            return True
        return False

repo = UserRepository()
user_id = repo.save({'name': 'John', 'email': 'john@example.com'})
print(repo.find_by_id(user_id))  # {'name': 'John', 'email': 'john@example.com'}

Ключевые моменты

• Абстрактный класс нельзя инстанцировать — только наследовать
• Все абстрактные методы должны быть реализованы — иначе класс остаётся абстрактным
• Может содержать реализованные методы — для общей логики
• Используется для определения контрактов — что должны делать подклассы
• Обеспечивает полиморфизм — разные реализации одного интерфейса

Итоги

Абстрактная модель — фундаментальный концепт ООП, позволяющий определить контракты и создать гибкие, расширяемые системы. Правильное использование абстрактных классов делает код более модульным, тестируемым и переиспользуемым.