Что такое строгая динамическая типизация в Python?

Строгая динамическая типизация в Python

Python имеет динамическую типизацию (типы проверяются во время выполнения), но при этом строгую (нельзя просто складывать строку с числом).

Динамическая vs Статическая типизация

Статическая типизация (Java, C++)

// Java — статическая типизация
int number = 5;
string text = "hello";
number = "world";  // ОШИБКА на этапе компиляции
// error: incompatible types: String cannot be converted to int

Динамическая типизация (Python)

# Python — динамическая типизация
number = 5
text = "hello"
number = "world"  # ОК! Переменная может менять тип
print(number)  # "world"

# Тип определяется во время выполнения
print(type(number))  # <class "str">

Это динамическая типизация — тип переменной можно менять во время выполнения.

Строгая типизация — преобразования типов

Динамическая типизация НЕ значит, что типы игнорируются. Python строг в операциях с типами.

# Правильные операции
5 + 3  # 8 (число + число)
"hello" + " world"  # "hello world" (строка + строка)
[1, 2] + [3, 4]  # [1, 2, 3, 4] (список + список)

# Неправильные операции (ОШИБКИ)
5 + "hello"  # TypeError: unsupported operand type(s) for +: int and str
"5" * 3  # "555" (ОК, строка * число = повтор)
[1, 2] + 3  # TypeError: can only concatenate list to list, not int

# Атрибуты несуществующего типа
text = "hello"
text.sqrt()  # AttributeError: str object has no attribute sqrt

number = 5
number.upper()  # AttributeError: int object has no attribute upper

Ключевые характеристики Python типизации

1. Динамическая (runtime checking)

def process_data(value):
    return value * 2  # Работает с любым типом?

print(process_data(5))      # 10
print(process_data("hi"))    # "hihi"
print(process_data([1, 2]))  # [1, 2, 1, 2]

# А теперь сломается
data = process_data(None)
# TypeError: unsupported operand type(s) for *: NoneType and int

2. Строгая (no implicit conversions)

# Python НЕ автоматически конвертирует типы
"5" + 3  # TypeError
# В Java это было бы: "5" + 3 = "53"

# Нужна явная конвертация
int("5") + 3  # 8
str(5) + "3"  # "53"

# Boolean не конвертируется в число автоматически
True + 3  # 4 (специальный случай в Python!)
False + 5  # 5

Примеры runtime type errors

# Это ошибки типа, которые выявляются только при выполнении

def divide(a, b):
    return a / b

divide(10, 2)     # 5.0
divide("10", 2)   # TypeError: unsupported operand type(s) for /: str and int

def process_list(items):
    return items[0] + items[1]  # Предполагаем числа

process_list([1, 2])           # 3
process_list(["a", "b"])       # "ab"
process_list([{}, {}])          # TypeError: unsupported operand type(s) for +: dict and dict

Как Python проверяет типы (duck typing)

Python использует принцип "duck typing" — проверяет способности объекта, не его тип.

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

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

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

def animal_sound(animal):
    # Не проверяем тип, просто вызываем метод
    return animal.make_sound()

dog = Dog()
cat = Cat()
robot = Robot()

print(animal_sound(dog))     # "Woof!"
print(animal_sound(cat))     # "Meow!"
print(animal_sound(robot))   # "Beep boop!"

class Stone:
    pass

stone = Stone()
print(animal_sound(stone))   # AttributeError: Stone object has no attribute make_sound

Type Hints

def add(a: int, b: int) -> int:
    return a + b

add(5, 3)           # 8
add("5", "3")       # "53" (работает, несмотря на подсказку)
add([1], [2])       # [1, 2] (работает!)

# Подсказки нужны для:
# 1. Документации
# 2. IDE автодополнения
# 3. Статических анализаторов (mypy)

Проверка типов в runtime

def process_number(value):
    if not isinstance(value, (int, float)):
        raise TypeError(f"Ожидается число, получено {type(value).__name__}")
    return value * 2

process_number(5)       # 10
process_number(5.5)     # 11.0
process_number("5")     # TypeError

Сравнение: строгая vs слабая типизация

# Python: СТРОГАЯ динамическая типизация
"5" + 3  # TypeError
# Нельзя складывать строку и число

# JavaScript: СЛАБАЯ динамическая типизация
"5" + 3  // "53"
// JavaScript конвертирует типы автоматически

Лучшие практики

# 1. Используй type hints
def fetch_users(ids: list[int]) -> list:
    return [db.get_user(id) for id in ids]

# 2. Проверяй типы в начале функции
def calculate(a: int, b: int) -> int:
    if not isinstance(a, int) or not isinstance(b, int):
        raise TypeError("Оба аргумента должны быть int")
    return a + b

# 3. Используй mypy для статической проверки
# $ pip install mypy
# $ mypy script.py

# 4. Тестируй разные типы
import pytest

def test_add():
    assert 2 + 3 == 5

Python имеет строгую динамическую типизацию: типы определяются в runtime, но операции с несовместимыми типами вызывают ошибки.