Что такое нестрогая типизация?

Нестрогая типизация (Dynamic Typing)

Нестрогая типизация — это система, где тип переменной определяется во время выполнения программы, а не при компиляции. Python использует именно эту систему типов.

Основной принцип

# В нестрогой типизации переменная может содержать любой тип
x = 5           # x имеет тип int
print(type(x))  # <class 'int'>

x = "hello"     # x переопределяется на строку
print(type(x))  # <class 'str'>

x = [1, 2, 3]   # x переопределяется на список
print(type(x))  # <class 'list'>

# Тип меняется в runtime, язык не жалуется

В строгой типизации (Java, TypeScript, C++) это вызовет ошибку компиляции:

// Java — строгая типизация
int x = 5;          // OK
String x = "hello"; // ОШИБКА: Cannot assign String to int

Характеристики нестрогой типизации

1. Автоматическое преобразование типов (Type Coercion)

# Python пытается преобразовать типы автоматически
result = "5" + 3  # TypeError! Но в других языках может работать

# Нужно явно преобразовать
result = "5" + str(3)  # "53"
result = int("5") + 3  # 8

# Но некоторые преобразования работают автоматически
result = 5 + 3.5    # 8.5 (int автоматически преобразуется в float)
result = True + 5   # 6 (bool преобразуется в int: True == 1)

2. Утиная типизация (Duck Typing)

# "Если ходит как утка и крякает как утка — это утка"
# Тип не важен, важны методы

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

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

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

# Функция работает с ЛЮБЫМ объектом, у которого есть метод speak()
def make_sound(animal):
    print(animal.speak())  # Не проверяем тип!

make_sound(Dog())     # "Woof!"
make_sound(Cat())     # "Meow!"
make_sound(Robot())   # "Beep boop!"

# Это работает без наследования от общего класса!
# Важна только наличие метода speak()

3. Отсутствие проверки типов на этапе разработки

# ❌ Ошибка обнаружится только при выполнении
def process_data(data):
    return data.upper()  # Предполагаем строку

process_data("hello")  # OK: "HELLO"
process_data(123)      # ОШИБКА: AttributeError: 'int' object has no attribute 'upper'

В строгой типизации ошибка была бы найдена до запуска:

// TypeScript — строгая типизация
function processData(data: string): string {
    return data.toUpperCase();
}

processData("hello");  // OK
processData(123);      // ОШИБКА при компиляции!

Плюсы нестрогой типизации

1. Гибкость и быстрое прототипирование

# Можно быстро писать без обдумывания типов
def calculate(values):
    return sum(values) / len(values)

calculate([1, 2, 3])          # Работает
calculate([1.5, 2.5, 3.5])    # Работает
calculate(range(10))          # Работает
calculate("12345")            # Хм, даже это работает!

2. Меньше кода (нет типов везде)

# Python
def add(a, b):
    return a + b  # Просто и понятно

add(5, 3)        # 8
add("hello", " world")  # "hello world"

# То же самое на Java
public static Object add(Object a, Object b) {
    if (a instanceof Integer && b instanceof Integer) {
        return (Integer) a + (Integer) b;
    } else if (a instanceof String && b instanceof String) {
        return (String) a + (String) b;  // Конкатенация
    }
    // ...
}

3. Утиная типизация улучшает переиспользование кода

# Работает с любым "похожим" объектом
class Logger:
    def write(self, message):
        print(f"LOG: {message}")

class FileWriter:
    def write(self, message):
        with open("file.txt", "a") as f:
            f.write(message + "\n")

def save_message(writer, message):
    """Работает с Logger И FileWriter!"""
    writer.write(message)

save_message(Logger(), "Hello")
save_message(FileWriter(), "Hello")

Минусы нестрогой типизации

1. Ошибки обнаруживаются поздно (в runtime)

# ❌ Проблема обнаружится при выполнении
def process_user(user):
    return user.email.upper()  # Предполагаем dict с 'email'

users = [{"name": "John"}, {"email": "jane@example.com"}]
for user in users:
    process_user(user)  # KeyError на первом пользователе!

Строгая типизация поймёт это раньше:

// TypeScript выдаст ошибку до запуска
interface User {
    email: string;  // ОБЯЗАТЕЛЬНОЕ поле
}

const users: User[] = [{name: "John"}];  // ОШИБКА при компиляции!

2. Сложнее отладить код

def multiply_by_two(x):
    return x * 2

multiply_by_two(5)        # OK: 10
multiply_by_two("a")      # OK: "aa" (строка повторяется!)
multiply_by_two([1, 2])   # OK: [1, 2, 1, 2] (список повторяется!)
multiply_by_two(None)     # TypeError: unsupported operand type(s)

# Поведение непредсказуемо!
# Нужны тесты для каждого типа

3. Нельзя полагаться на IDE для автодополнения

# IDE не знает, какой тип вернёт функция
def get_data():
    if some_condition:
        return {"name": "John"}  # dict
    else:
        return "error"  # string

result = get_data()
result.  # IDE не знает, какие методы доступны!
# Может быть .keys() (если dict) или .upper() (если string)

4. Производительность ниже

# Python должна проверять типы во время выполнения
def add(a, b):
    return a + b  # Python проверит: оба ли числа? или строки?

# С типами компилятор может оптимизировать
# int add(int a, int b) { return a + b; }  // Компилятор знает это точно

5. Больше ошибок в production

# Это пройдёт без ошибок
def process_payment(amount):
    charge = amount * 0.1  # Предполагаем число
    return charge

process_payment("1000")  # TypeError: can't multiply sequence by non-int
# Ошибка обнаружится только когда пользователь её вызовет!

Типизация в Python: лучшее из обоих миров

Пython поддерживает Type Hints (аннотации типов) — это совет, а не требование:

# Функция БЕЗ типов (нестрогая, классическая Python)
def add(a, b):
    return a + b

# С TYPE HINTS (помощь IDE и статическому анализу)
def add_strict(a: int, b: int) -> int:
    return a + b

# Type hints НЕ принудительны
add_strict("5", 3)  # Работает! Python их ИГНОРИРУЕТ

# Но статический анализатор (mypy) выдаст ошибку
# mypy add.py → error: Argument 1 to "add_strict" has incompatible type "str"; expected "int"

Сравнение подходов

# 1. Нестрогая типизация (классический Python)
def divide(a, b):
    return a / b

divide(10, 2)      # OK: 5.0
divide(10, "2")    # TypeError при выполнении

# 2. С Type Hints (современный Python)
from typing import Union

def divide_typed(a: Union[int, float], b: Union[int, float]) -> float:
    return a / b

divide_typed(10, 2)      # OK
divide_typed(10, "2")    # IDE предупредит, но выполнится

# 3. Строгая типизация (Java, TypeScript)
public static double divide(double a, double b) {
    return a / b;  // Компилятор не позволит другие типы
}

Когда нестрогая типизация проблема

# ❌ Без типов легко допустить ошибку в большом проекте
class Database:
    def execute(self, query):
        # query может быть string? list? dict?
        # Никто не знает!
        return query.upper()  # А если это список?

# ✅ С типами ясно
from typing import Union

class Database:
    def execute(self, query: str) -> str:
        return query.upper()

    def execute_batch(self, queries: List[str]) -> List[str]:
        return [q.upper() for q in queries]

Резюме

Нестрогая типизация в Python:

• Переменные могут содержать любой тип
• Тип проверяется только при выполнении
• Гибко, но требует хороших тестов
• Современный Python поддерживает Type Hints для добавления безопасности

Правило:

• Для скриптов и прототипов — нестрогая типизация OK
• Для production кода — добавляй Type Hints!

# Хорошая практика для production
from typing import List, Optional, Dict

def process_users(users: List[Dict[str, str]]) -> Optional[List[str]]:
    """Process users and return their emails"""
    try:
        return [user['email'] for user in users]
    except KeyError:
        return None