> Что такое duck typing и динамическая типизация в Python (Python)

Короткий ответ

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

Подробное объяснение

В языках со статической типизацией (Java, C++) тип переменной фиксируется на этапе компиляции. В Python тип привязан к объекту, а не к имени переменной. Одна и та же переменная может сначала хранить число, потом строку, потом список - интерпретатор не будет возражать.

Duck typing - это следствие динамической типизации. Когда мы вызываем obj.method(), Python не проверяет, к какому классу принадлежит obj. Он просто пытается вызвать метод method. Если метод есть - код работает, если нет - возникает AttributeError. Это позволяет писать гибкий код, который работает с любыми объектами, поддерживающими нужный интерфейс, даже если эти объекты не связаны наследованием.

Ключевое отличие от статической типизации: в Python нет проверки типов на этапе компиляции (её просто нет - код компилируется в байткод без таких проверок). Ошибки, связанные с типами, всплывают в рантайме.

На практике

В реальной backend-разработке duck typing проявляется постоянно:

• функции принимают любой объект, у которого есть нужные методы (например, len() работает со строками, списками, словарями, множествами - всем, что реализует __len__)
• паттерн "утиная типизация" используется в стандартной библиотеке: file-like объекты, iterable, callable
• при работе с БД можно передать в функцию и список, и генератор, и кастомный итератор - главное, чтобы по ним можно было итерироваться
• для контроля типов используют typing и mypy, но это опционально и не влияет на рантайм

Важно понимать: duck typing - это не про отсутствие типов, а про то, что тип определяется поведением. Это даёт гибкость, но требует дисциплины: нужно писать понятные имена переменных, docstring'и и, при необходимости, аннотации.

Пример кода

PYTHON
class Duck:
    def quack(self):
        return "Кря!"

class Person:
    def quack(self):
        return "Имитирую утку"

def make_sound(obj):
    # duck typing: нам не важен тип, важен метод quack
    return obj.quack()

duck = Duck()
person = Person()

print(make_sound(duck))    # Кря!
print(make_sound(person))  # Имитирую утку

# динамическая типизация: переменная меняет тип
value = 42
print(type(value))  # <class 'int'>
value = "теперь строка"
print(type(value))  # <class 'str'>

Как отвечать на собеседовании

Начни с чёткого определения обоих понятий, затем покажи связь между ними. Приведи пример из практики - например, функцию, которая принимает любой итерируемый объект. Упомяни, что duck typing - это философия Python, отражённая в принципе "лучше просить прощения, чем разрешения" (EAFP). Если спросят про минусы - скажи, что ошибки типов всплывают в рантайме, а не на этапе компиляции, и что это решается аннотациями и mypy. Не углубляйся в сложные темы вроде протоколов или ABC, если не спрашивают - для junior достаточно базового понимания.

Что проверяет интервьюер

Интервьюер хочет убедиться, что ты:

• понимаешь разницу между статической и динамической типизацией
• осознаёшь, что тип в Python привязан к объекту, а не к переменной
• можешь объяснить duck typing через поведение, а не через формальные типы
• знаешь практические следствия: гибкость кода, ошибки в рантайме, роль аннотаций
• умеешь привести простой пример

Для junior достаточно уверенного объяснения базовых концепций и одного примера. Не нужно рассказывать про Protocol, typing.cast или виртуальные подклассы - это уровень middle+.

Типичные ошибки

• путать duck typing с полиморфизмом в ООП - это разные вещи, хотя и связанные
• говорить, что "Python - язык без типов" - это неверно, типы есть, просто они динамические
• утверждать, что duck typing - это то же самое, что динамическая типизация - нет, это разные концепции, хотя и взаимосвязанные
• забывать упомянуть, что ошибки типов проявляются в рантайме, а не на этапе компиляции
• пытаться привести пример с наследованием - duck typing как раз позволяет обходиться без него
• говорить, что аннотации типов влияют на выполнение - они не влияют, это только подсказки для инструментов