Есть ли интерфейсы в Python?

Интерфейсы в Python

Да, интерфейсы в Python существуют, но реализованы не так явно, как в языках типа Java или C#. Python использует структурную типизацию (duck typing) вместо номинальной, что позволяет работать с интерфейсами более гибко и Pythonic.

Что такое интерфейс

Интерфейс — это контракт, который определяет, какие методы и свойства должен иметь объект, не указывая, как они реализуются. Интерфейс отвечает на вопрос: "Какие операции может выполнять этот объект?"

В Python интерфейсы реализуются несколькими способами:

1. Duck Typing (самый Pythonic)

Python опирается на принцип "Если объект ходит как утка и крякает как утка, значит это утка". Вместо явной реализации интерфейса, просто нужны правильные методы:

# Нет явного интерфейса, но есть контракт
class Dog:
    def speak(self):
        return "Woof!"

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

class Robot:
    def speak(self):
        return "Beep boop!"

def make_speak(animal):
    print(animal.speak())  # работает с любым объектом, у которого есть метод speak()

make_speak(Dog())     # работает
make_speak(Cat())     # работает
make_speak(Robot())   # работает

Здесь нет явного интерфейса, но все три класса "реализуют" одинаковый контракт.

2. Abstract Base Classes (ABC)

Этот способ ближе к традиционным интерфейсам. ABC позволяет создать абстрактный класс, который определяет, какие методы должны быть у подклассов:

from abc import ABC, abstractmethod

class Animal(ABC):  # Абстрактный класс = интерфейс
    @abstractmethod
    def speak(self):
        pass
    
    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"
    
    def move(self):
        return "Running on four legs"

class Bird(Animal):
    def speak(self):
        return "Tweet!"
    
    def move(self):
        return "Flying"

# dog = Dog()  # ✅ работает
# bird = Bird()  # ✅ работает
# animal = Animal()  # ❌ TypeError: Can't instantiate abstract class

Преимущества ABC:

• Явный контракт
• Проверка в runtime, что подкласс реализовал все методы
• Документирует, что должно быть реализовано

3. Typing Protocols (Python 3.8+, новый стандарт)

Это современный способ определить структурный тип без наследования:

from typing import Protocol

class Drawable(Protocol):  # Это интерфейс/протокол
    def draw(self) -> None:
        ...

class Circle:
    def draw(self) -> None:
        print("Drawing circle")

class Square:
    def draw(self) -> None:
        print("Drawing square")

def render(obj: Drawable) -> None:  # Принимает любой объект с методом draw()
    obj.draw()

render(Circle())   # ✅ работает
render(Square())   # ✅ работает

Вот в чем магия: Circle и Square не наследуют Drawable, но static type checker (mypy) понимает, что они его реализуют благодаря методу draw().

4. Type Hints с Generic

Для более сложных контрактов можно использовать generic типы:

from typing import TypeVar, Generic

T = TypeVar('T')

class Repository(Generic[T]):
    def get(self, id: int) -> T:
        pass
    
    def save(self, item: T) -> None:
        pass

class User:
    def __init__(self, name: str):
        self.name = name

class UserRepository(Repository[User]):
    def get(self, id: int) -> User:
        return User("John")
    
    def save(self, item: User) -> None:
        print(f"Saving {item.name}")

Сравнение способов

Практический пример: реальный сценарий

from typing import Protocol

# Определяем интерфейс
class DatabaseConnection(Protocol):
    def execute(self, query: str) -> list:
        ...
    
    def commit(self) -> None:
        ...

# Реализация 1: PostgreSQL
class PostgreSQL:
    def execute(self, query: str) -> list:
        return ["result from postgres"]
    
    def commit(self) -> None:
        print("Postgres: Committing")

# Реализация 2: MongoDB
class MongoDB:
    def execute(self, query: str) -> list:
        return ["result from mongo"]
    
    def commit(self) -> None:
        print("Mongo: Committing")

# Функция, которая работает с любой БД
def save_data(db: DatabaseConnection, query: str):
    results = db.execute(query)
    db.commit()
    return results

# Использование
pg = PostgreSQL()
mongo = MongoDB()

save_data(pg, "SELECT * FROM users")         # ✅ работает
save_data(mongo, "db.users.find({})")       # ✅ работает

Почему Python не использует явные интерфейсы

1. Динамическая типизация — типы проверяются в runtime, а не при компиляции
2. Гибкость — код может быть более общим и переиспользуемым
3. Простота — не требует сложной иерархии классов
4. Pythonic философия — "Лучше просить прощения, чем получать разрешение"

Когда использовать что

# Малые скрипты → Duck typing
def process(obj):
    obj.process()  # работает если есть метод

# Большой проект → ABC или Protocol
from abc import ABC, abstractmethod

class Service(ABC):
    @abstractmethod
    def run(self):
        pass

# Современный код → Protocol
from typing import Protocol

class Loggable(Protocol):
    def log(self, message: str) -> None:
        ...

Вывод

Пython имеет интерфейсы, но они реализованы неявно через duck typing и явно через ABC или Protocol. Это дает разработчикам гибкость выбора между простотой и структурированностью кода в зависимости от масштаба проекта.