В чем разница между статической и динамической типизацией?

Разница между статической и динамической типизацией

Основное определение

Статическая типизация — тип переменной определяется на этапе компиляции (до запуска программы). Переменная может хранить только объекты объявленного типа.

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

Статическая типизация

Примеры языков: Java, C++, TypeScript, Go

// Java — статическая типизация
public class Example {
    public static void main(String[] args) {
        int number = 42;        // тип int
        String text = "hello";  // тип String
        
        // Ошибка компиляции! Нельзя присвоить строку целому числу
        // number = "this is wrong";  // ❌ Compilation error
        
        // Правильно
        number = 100;  // ✅ int может быть присвоен int
    }
}

Характеристики:

• Тип проверяется ДО запуска программы
• Ошибки типов выявляются на этапе компиляции
• Необходимо явное объявление типов
• Быстрее (оптимизация)
• Более безопасно
• Требует больше кода (явное указание типов)

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

Примеры языков: Python, JavaScript, Ruby, PHP

# Python — динамическая типизация
number = 42        # тип int
text = "hello"     # тип string

# ✅ Можно переприсвоить переменную другим типом
number = "this is string"  # Теперь это string
number = 3.14              # Теперь это float
number = [1, 2, 3]         # Теперь это список

print(f"Type: {type(number)}")  # <class 'list'>

Характеристики:

• Тип проверяется ВО ВРЕМЯ выполнения программы
• Ошибки типов выявляются только при запуске
• Типы присваиваются автоматически (type inference)
• Медленнее (нужно проверять типы во время выполнения)
• Менее безопасно (ошибки могут скрываться)
• Меньше кода, более гибко

Практические примеры

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

def add(a, b):
    return a + b

# ✅ Работает с числами
print(add(5, 3))           # 8

# ✅ Работает со строками
print(add("hello", "world"))  # "helloworld"

# ✅ Работает со списками
print(add([1, 2], [3, 4]))    # [1, 2, 3, 4]

# ❌ Ошибка только при запуске!
# print(add(5, "string"))  # TypeError: unsupported operand type

Java (статическая типизация):

// ❌ Нужно определить тип параметров
public static int add(int a, int b) {
    return a + b;
}

// Работает только с int
System.out.println(add(5, 3));  // ✅ 8

// ❌ Ошибка компиляции!
// System.out.println(add("hello", "world"));

// Для строк нужен отдельный метод
public static String add(String a, String b) {
    return a + b;
}

System.out.println(add("hello", "world"));  // ✅ "helloworld"

Сравнительная таблица

Гибридный подход: Type Hints в Python

Python поддерживает типовые подсказки (type hints), которые дают некоторые преимущества статической типизации:

# Python с type hints (PEP 484)
from typing import List, Union

def add(a: int, b: int) -> int:
    """Суммирует два числа."""
    return a + b

def process_data(data: List[int]) -> Union[int, float]:
    """Обрабатывает список чисел."""
    return sum(data) / len(data)

# ✅ Правильно (IDE подскажет типы)
add(5, 3)  # ✅

# ⚠️ IDE предупредит о неправильном типе
add("hello", "world")  # ⚠️ Type checker даст warning

Инструменты для проверки типов в Python:

• mypy — статический анализатор типов
• Pylance — расширение VS Code
• pyright — Microsoft язык сервер

# Проверить типы перед запуском
mypy script.py

TypeScript: Java-подобная типизация в JavaScript

TypeScript добавляет статическую типизацию к JavaScript:

// TypeScript — статическая типизация
function add(a: number, b: number): number {
    return a + b;
}

add(5, 3);              // ✅ OK
add("hello", "world");  // ❌ Compilation error

interface User {
    name: string;
    age: number;
}

const user: User = {
    name: "John",
    age: 30
};

// ❌ Ошибка компиляции
// const user2: User = { name: "Jane", age: "30" };

Плюсы и минусы

Статическая типизация:

Плюсы:

• Ошибки выявляются ДО запуска
• Лучшая оптимизация
• IDE может помочь лучше
• Меньше runtime ошибок
• Проще рефакторить большой код

Минусы:

• Больше кода
• Медленнее писать
• Менее гибко
• Сложнее для прототипирования

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

Плюсы:

• Быстро писать код
• Гибче
• Меньше кода
• Лучше для прототипирования
• Проще начать (меньше правил)

Минусы:

• Ошибки только при запуске
• Медленнее выполняется
• Трудно найти ошибки в большом коде
• IDE не может помочь так хорошо
• Сложнее рефакторить

Практический пример для Data Science

# Python с type hints для ML проекта
from typing import List, Tuple
import numpy as np
from sklearn.model_selection import train_test_split

def preprocess_data(
    data: np.ndarray,
    test_size: float = 0.3
) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
    """Разделяет данные на тренировочный и тестовый наборы."""
    X = data[:, :-1]
    y = data[:, -1]
    return train_test_split(X, y, test_size=test_size)

def calculate_metrics(
    y_true: List[int],
    y_pred: List[int]
) -> dict:
    """Вычисляет метрики классификации."""
    from sklearn.metrics import accuracy_score, f1_score
    return {
        "accuracy": accuracy_score(y_true, y_pred),
        "f1": f1_score(y_true, y_pred, average="weighted")
    }

Выводы

• Статическая типизация лучше для больших projects, where reliability matters (production)
• Динамическая типизация лучше для быстрого прототипирования и research
• Modern подход: использовать type hints в динамических языках
• Для Data Science обычно Python (динамический) + type hints
• TypeScript набирает популярность для бэкенда благодаря типизации