Значит ли что-то для программиста изменяемость / неизменямость типа данных

Mutability (изменяемость) — фундаментальная характеристика типов

Изменяемость определяет, может ли объект изменяться после создания. Это влияет на безопасность, производительность и архитектуру кода. Это НЕ просто теория — это важная практика.

Mutable vs Immutable типы в Python

Immutable (неизменяемые):

int, float, str, tuple, bool, frozenset

x = 5
x = 10  # ← Создаётся НОВЫЙ объект
print(id(x))  # Другой ID

Mutable (изменяемые):

list, dict, set

x = [1, 2, 3]
x[0] = 999  # ← Объект изменяется на месте
print(id(x))  # Тот же ID!

Почему это важно: проблемы с изменяемостью

Проблема 1: Неожиданное изменение

def process_data(data_list):
    data_list[0] = "MODIFIED"
    return data_list

original = ["Alice", "Bob", "Charlie"]
result = process_data(original)

print(original)  # ["MODIFIED", "Bob", "Charlie"] ← Изменился!

Решение: использовать неизменяемые типы

def process_data(data_tuple):
    # Нельзя изменить в место
    # data_tuple[0] = "MODIFIED"  # TypeError
    return ("MODIFIED",) + data_tuple[1:]

original = ("Alice", "Bob", "Charlie")
result = process_data(original)
print(original)  # ("Alice", "Bob", "Charlie") ← Не изменился!

Проблема 2: Параметры по умолчанию

# ❌ Очень опасно!
def append_to_list(item, default_list=[]):
    default_list.append(item)
    return default_list

result1 = append_to_list("a")  # ["a"]
result2 = append_to_list("b")  # ["a", "b"] ← Неожиданно!
print(result1)  # ["a", "b"] ← Изменился!

Почему: пустой список создаётся один раз при определении функции, потом переиспользуется.

Решение: использовать None

# ✅ Правильно
def append_to_list(item, default_list=None):
    if default_list is None:
        default_list = []  # Новый список каждый раз
    default_list.append(item)
    return default_list

result1 = append_to_list("a")  # ["a"]
result2 = append_to_list("b")  # ["b"] ← Правильно!

Проблема 3: Словари как параметры

# ❌ Опасно
def update_config(new_config, base_config={"debug": False}):
    base_config.update(new_config)
    return base_config

config1 = update_config({"port": 8000})
config2 = update_config({"host": "0.0.0.0"})
print(config1)  # {"debug": False, "port": 8000, "host": "0.0.0.0"}
# Конфигурации смешались!

Решение: None или copy

# ✅ Правильно
def update_config(new_config, base_config=None):
    if base_config is None:
        base_config = {"debug": False}
    result = base_config.copy()  # Shallow copy верхнего уровня
    result.update(new_config)
    return result

Практическое применение: функциональное программирование

# ❌ Императивно, с изменяемостью
def calculate_total(items):
    total = 0  # Изменяемое состояние
    for item in items:
        total += item.price  # Изменяем total
    return total

# ✅ Функционально, с неизменяемостью
from functools import reduce

def calculate_total(items):
    return reduce(
        lambda acc, item: acc + item.price,
        items,
        0  # Начальное значение
    )
    # Переменная total НЕ изменяется, создаются новые значения

Потокобезопасность (Thread Safety)

Неизменяемые объекты безопасны в многопоточности:

# ❌ Опасно без синхронизации
shared_list = [1, 2, 3]  # Mutable

def thread_func():
    shared_list[0] = 999  # Race condition!

# Нужна блокировка:
import threading
lock = threading.Lock()

def thread_func():
    with lock:
        shared_list[0] = 999  # Безопасно

# ✅ Безопасно без синхронизации
shared_tuple = (1, 2, 3)  # Immutable

def thread_func():
    new_tuple = (999,) + shared_tuple[1:]  # Новый объект
    # Отправляем в очередь, но оригинал не меняется

Использование в словарях и множествах

# ✅ Правильно — ключи immutable
data = {
    "user_1": "Alice",
    (1, 2): "coordinate",  # Tuple как ключ — OK
    frozenset([1, 2]): "set_key"  # Frozenset как ключ — OK
}

# ❌ Неправильно — ключи mutable
try:
    data[[1, 2]] = "value"  # TypeError: unhashable type
except TypeError:
    pass

# Почему? Если список изменится, хеш нарушится
l = [1, 2]
l.append(3)  # Список изменился
# Теперь невозможно найти ключ в словаре

Пример: Data Classes

from dataclasses import dataclass

@dataclass(frozen=True)  # ← Immutable!
class Point:
    x: int
    y: int

p1 = Point(1, 2)
# p1.x = 5  # TypeError: cannot assign to field 'x'

# Можем использовать как ключ
locations = {p1: "starting point"}

# Но легко создать новый объект
p2 = Point(3, 4)

Правила для программиста

✅ Используй Immutable когда:

• Объект не должен меняться (константа)
• Нужно использовать как ключ словаря
• Нужна потокобезопасность
• Возвращаешь значение из функции
• Данные в кэше

✅ Используй Mutable когда:

• Нужна производительность (в цикле)
• Работаешь с большими структурами
• Нужна гибкость в изменении

Копирование при изменяемости

# Immutable — копирование автоматическое
a = "hello"
b = a.upper()  # Новый объект
print(a)  # "hello" — не изменился

# Mutable — нужно копировать вручную
a = [1, 2, 3]
b = a.copy()  # Поверхностная копия
b[0] = 999
print(a)  # [1, 2, 3] — не изменился

Итог

Изменяемость критически важна для программиста:

✅ Правильность — неизменяемость предотвращает баги
✅ Безопасность — потокобезопасность с immutable
✅ Производительность — кэширование возможно с immutable
✅ Структуры данных — ключи словарей должны быть immutable
✅ Отладка — immutable легче отлаживать

Это не просто теория — это основа надёжного кода.