Что такое изменяемые типы в Python?

Изменяемые и неизменяемые типы данных в Python

Изменяемые типы (Mutable) — это объекты, содержимое которых можно менять после создания. Неизменяемые типы (Immutable) — это объекты, содержимое которых нельзя менять.

Вот в чём разница:

Изменяемые типы

1. List (список)

my_list = [1, 2, 3]

# Могу изменять элементы
my_list[0] = 100
print(my_list)  # [100, 2, 3]

# Могу добавлять
my_list.append(4)
print(my_list)  # [100, 2, 3, 4]

# Могу удалять
my_list.pop()
print(my_list)  # [100, 2, 3]

# Список ИЗМЕНЯЕМЫЙ

2. Dictionary (словарь)

my_dict = {'name': 'Alice', 'age': 30}

# Могу изменять значения
my_dict['age'] = 31
print(my_dict)  # {'name': 'Alice', 'age': 31}

# Могу добавлять ключи
my_dict['city'] = 'NYC'
print(my_dict)  # {'name': 'Alice', 'age': 31, 'city': 'NYC'}

# Словарь ИЗМЕНЯЕМЫЙ

3. Set (множество)

my_set = {1, 2, 3}

# Могу добавлять элементы
my_set.add(4)
print(my_set)  # {1, 2, 3, 4}

# Могу удалять
my_set.remove(2)
print(my_set)  # {1, 3, 4}

# Множество ИЗМЕНЯЕМО

Неизменяемые типы

1. Tuple (кортеж)

my_tuple = (1, 2, 3)

# НЕ МОЖНО изменять
my_tuple[0] = 100  # ❌ TypeError: 'tuple' object does not support item assignment

# НЕ МОЖНО добавлять
my_tuple.append(4)  # ❌ AttributeError: 'tuple' object has no attribute 'append'

# Кортеж НЕИЗМЕНЯЕМ

2. String (строка)

my_string = "hello"

# НЕ МОЖНО изменять
my_string[0] = 'H'  # ❌ TypeError: 'str' object does not support item assignment

# Строка НЕИЗМЕНЯЕМА
# Вместо изменения создаю новую строку
my_string = my_string.upper()  # "HELLO"
print(my_string)  # HELLO (это новая строка, не изменение старой)

3. Integer, Float, Boolean (числа и булевы)

x = 10

# Числа неизменяемы
# Это выглядит как изменение, но на самом деле создаёт новый объект
x = 20  # новый объект, не изменение старого

print(id(x))  # посмотри id — это другой объект

Таблица сравнения

Почему это важно? Практические примеры

Пример 1: Ошибка с изменяемым по умолчанию аргументом

# ❌ НЕПРАВИЛЬНО
def add_item(item, my_list=[]):
    my_list.append(item)
    return my_list

result1 = add_item(1)  # [1]
result2 = add_item(2)  # [1, 2] ← НЕОЖИДАННО!
result3 = add_item(3)  # [1, 2, 3] ← ОНА БЫЛА ПЕРЕИСПОЛЬЗОВАНА!

print(result1)  # [1, 2, 3]
print(result2)  # [1, 2, 3]
print(result3)  # [1, 2, 3]

# Причина: список создаётся один раз при определении функции
# и переиспользуется для всех вызовов

# ✅ ПРАВИЛЬНО
def add_item(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

result1 = add_item(1)  # [1]
result2 = add_item(2)  # [2]
result3 = add_item(3)  # [3]

Пример 2: Копирование списков

original = [1, 2, 3]

# ❌ НЕПРАВИЛЬНО (поверхностное копирование)
copy_bad = original  # Это НЕ копия, это ссылка на тот же объект

copy_bad[0] = 999
print(original)   # [999, 2, 3] ← ИЗМЕНИЛСЯ!
print(copy_bad)   # [999, 2, 3]

# ✅ ПРАВИЛЬНО (глубокое копирование)
import copy
copy_good = copy.deepcopy(original)

copy_good[0] = 999
print(original)   # [1, 2, 3] ← не изменился
print(copy_good)  # [999, 2, 3]

Пример 3: Преимущества неизменяемых типов

# Кортежи можно использовать как ключи словаря
my_dict = {}
my_dict[(1, 2)] = 'coordinates'  # ✅ Работает

# Списки нельзя использовать как ключи
my_dict[[1, 2]] = 'coordinates'  # ❌ TypeError: unhashable type: 'list'

Пример в контексте анализа данных

import pandas as pd

# Изменяемые типы в pandas
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35]
})

# Могу изменять DataFrame (изменяемый)
df['age'] = df['age'] + 1  # Изменяю колонку
df.loc[0, 'name'] = 'Alicia'  # Изменяю ячейку

print(df)

# Series (колонка) тоже изменяема
df['age'][0] = 100  # Могу менять

print(df['age'])  # [100, 31, 36]

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

# Проверить изменяемый ли тип
x = [1, 2, 3]  # list
y = (1, 2, 3)  # tuple
z = {1, 2, 3}  # set

print(isinstance(x, (list, dict, set)))  # True (изменяемые)
print(isinstance(y, (tuple, str, int)))  # True (неизменяемые)

Хеширование (важная концепция)

# Неизменяемые объекты можно хешировать
hash((1, 2, 3))  # -2528391537973371311 ✅ Работает
hash('hello')    # 6502017453486340235 ✅ Работает

# Изменяемые объекты нельзя хешировать
hash([1, 2, 3])  # ❌ TypeError: unhashable type: 'list'
hash({'a': 1})   # ❌ TypeError: unhashable type: 'dict'

# Почему: потому что если содержимое может измениться,
# хеш станет невалиден

Практический совет для аналитика

Используй:

• List когда нужна коллекция, которую буду менять
• Tuple когда данные не должны меняться (более безопасно)
• Dict для key-value пар
• Set для уникальных значений

Пример в реальном анализе:

# Константы (неизменяемые)
TOP_CITIES = ('New York', 'Los Angeles', 'Chicago')
COUNTRY_CODES = {'USA': 'US', 'Russia': 'RU', 'Germany': 'DE'}

# Данные которые меняю (изменяемые)
customer_list = []  # буду добавлять покупателей
metrics = {}  # буду добавлять метрики

for customer in customers:
    customer_list.append(customer)  # ✅ Безопасно
    if customer['city'] in TOP_CITIES:
        metrics[customer['id']] = customer['ltv']

print(customer_list)
print(metrics)

Вывод

Изменяемые типы:

• List, Dictionary, Set
• Можно менять содержимое
• Нельзя использовать как ключи словаря
• Потенциально опаснее (побочные эффекты)

Неизменяемые типы:

• Tuple, String, Integer, Float, Boolean
• Нельзя менять содержимое
• Можно использовать как ключи
• Безопаснее (нет побочных эффектов)

Золотое правило: Когда передаёшь изменяемый объект как аргумент — помни что он может быть изменён внутри функции. Используй копирование если нужна гарантия неизменности.