Какие плюсы и минусы неизменяемых типов данных?

Плюсы и минусы неизменяемых типов данных

Неизменяемость (immutability) — один из столпов функционального программирования и важный концепт в Python. Рассмотрю все стороны медали.

1. Что такое неизменяемость?

Объект является неизменяемым, если его содержимое не может быть изменено после создания.

# Неизменяемые типы в Python
immutable_int = 42  # int
immutable_str = "hello"  # str
immutable_tuple = (1, 2, 3)  # tuple
immutable_frozen = frozenset([1, 2, 3])  # frozenset
immutable_bytes = b"data"  # bytes

# Попытка изменить
immutable_str = immutable_str.upper()  # Это НОВАЯ строка, не изменение
print(immutable_str)  # "HELLO"

# Нельзя изменить элемент
# immutable_str[0] = 'x'  # TypeError: 'str' object does not support item assignment

# Изменяемые типы
mutable_list = [1, 2, 3]  # list
mutable_dict = {'a': 1}  # dict
mutable_set = {1, 2, 3}  # set

# Можно изменять
mutable_list[0] = 999
mutable_dict['a'] = 2
mutable_set.add(4)
print(mutable_list, mutable_dict, mutable_set)

2. Плюсы неизменяемых типов

Плюс 1: Потокобезопасность

Неизменяемые объекты безопасны для использования в многопоточной среде без блокировок.

import threading
import time

# ✅ Безопасно: неизменяемая строка
shared_string = "Hello World"

def read_string():
    for _ in range(1000000):
        _ = shared_string.upper()  # Безопасно!

threads = [threading.Thread(target=read_string) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print("String is still:", shared_string)  # Не изменилась

# ❌ Опасно: изменяемый список
shared_list = [1, 2, 3]
lock = threading.Lock()  # Нужна блокировка!

def modify_list():
    for _ in range(100):
        with lock:
            shared_list.append(0)

threads = [threading.Thread(target=modify_list) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print("List length:", len(shared_list))  # Может быть неправильным без lock

Плюс 2: Можно использовать как ключи словаря

# ✅ Правильно: неизменяемые типы
user_cache = {}

key1 = ("alice", 30)  # tuple — неизменяемый
user_cache[key1] = "Admin"

key2 = "user:123"  # str — неизменяемый
user_cache[key2] = "User"

print(user_cache)
# {('alice', 30): 'Admin', 'user:123': 'User'}

# ❌ Неправильно: изменяемые типы
# user_cache[[1, 2, 3]] = "data"  # TypeError: unhashable type: 'list'
# user_cache[{"a": 1}] = "data"  # TypeError: unhashable type: 'dict'

# Использование в наборах
user_ids = {"alice", "bob", "charlie"}
print("alice" in user_ids)  # O(1) — быстро

# ❌ Нельзя так:
# user_ids = {[1, 2], [3, 4]}  # TypeError: unhashable type: 'list'

Плюс 3: Оптимизация памяти и производительность

# Интернирование строк
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True — один объект в памяти!
print(id(s1), id(s2))  # Одинаковые ID

# Небольшие целые числа также интернируются
a = 256
b = 256
print(a is b)  # True — интернировано

c = 257
d = 257
print(c is d)  # False — разные объекты (за пределами диапазона)

# Это экономит память!
import sys
print(sys.getsizeof("hello"))  # Размер объекта

# Интернирование экономит память для больших коллекций
millions_of_strings = ["hello"] * 1_000_000
print(id(millions_of_strings[0]))  # Все указывают на один объект!

Плюс 4: Кешируемость и функции

from functools import lru_cache

# ✅ Работает: параметры неизменяемы
@lru_cache(maxsize=128)
def fibonacci(n):
    """Кеш работает только с hashable параметрами"""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(30))  # Быстро благодаря кешу!
print(fibonacci.cache_info())  # Статистика кеша

# ❌ Не работает: параметр изменяемый
@lru_cache(maxsize=128)
def process_list(data):  # data не может быть list!
    return sum(data)

# Используй tuple вместо list
result = process_list((1, 2, 3))  # OK
# result = process_list([1, 2, 3])  # TypeError: unhashable type: 'list'

Плюс 5: Предсказуемое поведение

def add_name(name_list, new_name):
    """Думал, что функция возвращает список без изменения оригинала?"""
    name_list.append(new_name)
    return name_list

original = ["Alice"]
result = add_name(original, "Bob")
print(original)  # ["Alice", "Bob"] — ИЗМЕНИЛАСЬ!

# С неизменяемыми типами это невозможно
def add_name_immutable(names_tuple, new_name):
    """С tuple безопаснее"""
    return names_tuple + (new_name,)  # Новый tuple

original = ("Alice",)
result = add_name_immutable(original, "Bob")
print(original)  # ("Alice",) — не изменилась!
print(result)  # ("Alice", "Bob") — новый объект

3. Минусы неизменяемых типов

Минус 1: Низкая производительность при модификациях

import timeit

# ❌ Медленно: конкатенация строк
code_string = '''
result = ""
for i in range(1000):
    result += str(i)  # Создает новую строку каждый раз!
'''

print("String concatenation:", timeit.timeit(code_string, number=100))

# ✅ Быстро: использовать список
code_list = '''
parts = []
for i in range(1000):
    parts.append(str(i))
result = ''.join(parts)  # Один раз объединить
'''

print("List + join:", timeit.timeit(code_list, number=100))
# String: ~2.5 сек
# List: ~0.03 сек
# Разница в 80 раз!

Минус 2: Сложнее работать с коллекциями

# Изменяемый подход
mutable_data = {"user_id": 1, "name": "Alice", "scores": [90, 85, 88]}
mutable_data["scores"].append(95)  # Просто
print(mutable_data)

# Неизменяемый подход (более сложный)
from typing import NamedTuple

class UserData(NamedTuple):
    user_id: int
    name: str
    scores: tuple

immutable_data = UserData(1, "Alice", (90, 85, 88))
# immutable_data.scores.append(95)  # AttributeError: 'tuple' object has no attribute 'append'

# Нужно создать новый объект
new_data = UserData(
    immutable_data.user_id,
    immutable_data.name,
    immutable_data.scores + (95,)  # Новый tuple
)
print(new_data)

# Или использовать dataclass с позволением mutability
from dataclasses import dataclass

@dataclass
class MutableUser:
    user_id: int
    name: str
    scores: list

user = MutableUser(1, "Alice", [90, 85, 88])
user.scores.append(95)  # Изменяемо
print(user)

Минус 3: Увеличение потребления памяти

# Неизменяемость требует создания новых объектов
import sys

# Изменяемый список
mutable = [1, 2, 3]
mutable.append(4)  # Модифицируется на месте
print(f"List size: {sys.getsizeof(mutable)} bytes")

# Неизменяемый tuple
immutable = (1, 2, 3)
# immutable += (4,)  # Создает новый tuple!
new_immutable = immutable + (4,)  # Новый объект
print(f"Tuple size: {sys.getsizeof(new_immutable)} bytes")

# Если часто расширяешь, tuple расточительнее
data = ()
for i in range(1000):
    data = data + (i,)  # Создает новый tuple каждый раз!
    # Сложность: O(n^2)

# Лучше использовать list для такого
data = []
for i in range(1000):
    data.append(i)  # O(n) амортизированное время

Минус 4: Синтаксис может быть неудобным

# Изменяемый dict удобнее
user = {"name": "Alice", "age": 30}
user["age"] = 31  # Просто

# Неизменяемый подход требует больше кода
from dataclasses import dataclass
from typing import NamedTuple

# Способ 1: namedtuple
User1 = NamedTuple('User', [('name', str), ('age', int)])
user1 = User1("Alice", 30)
user1 = user1._replace(age=31)  # Неудобно

# Способ 2: dataclass с frozen=True
@dataclass(frozen=True)
class User2:
    name: str
    age: int

user2 = User2("Alice", 30)
# user2.age = 31  # FrozenInstanceError
# Нужно создавать новый объект через копирование
from dataclasses import replace
user2 = replace(user2, age=31)  # Работает, но неудобнее dict

4. Частичная неизменяемость

# Tuple может содержать изменяемые объекты!
my_tuple = (1, 2, [3, 4, 5])
# Сам tuple неизменяем
# my_tuple[0] = 999  # TypeError

# Но список внутри может меняться
my_tuple[2].append(6)
print(my_tuple)  # (1, 2, [3, 4, 5, 6]) — изменился!

# Это не истинная неизменяемость

# frozenset более строг
frozen = frozenset([1, 2, 3])
# frozen.add(4)  # AttributeError

5. Когда использовать что?

6. Best Practice

# ✅ Хороший стиль: используй неизменяемость по умолчанию
class Config:
    """Конфигурация не должна меняться случайно"""
    DEBUG = True
    DATABASE_URL = "postgresql://..."
    ALLOWED_HOSTS = ("example.com", "www.example.com")  # tuple вместо list

# ✅ Возвращай неизменяемые типы из функций
def get_user_ids() -> tuple:
    """Возвращаем tuple, чтобы caller не мог случайно модифицировать"""
    return (1, 2, 3, 4, 5)

ids = get_user_ids()
# ids.append(6)  # Ошибка — не может быть

# ✅ Используй dataclass с frozen=True для неизменяемых структур данных
from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: float
    y: float

p = Point(10, 20)
# p.x = 15  # FrozenInstanceError

# ✅ Используй list/dict только когда нужна mutability
colors = ["red", "green", "blue"]
colors.append("yellow")  # OK, нужна mutability

Резюме

Неизменяемость выбирай для:

• Потокобезопасности
• Использования в словарях и наборах
• Функционального программирования
• API и конфигурации

Изменяемость выбирай для:

• Производительности при частых изменениях
• Удобства использования
• Больших коллекций данных
• Мутирующих алгоритмов

Оптимальный подход — использовать неизменяемость по умолчанию и переходить на изменяемые типы только где это действительно необходимо.