Приведи примеры изменяемых структур в Python

Изменяемые (mutable) структуры в Python

Изменяемые структуры — это объекты, которые можно модифицировать после создания. При изменении объект остаётся тем же (тот же id в памяти), но его содержимое меняется.

1. List (Список)

Мост часто используемая изменяемая структура.

# Создание и модификация
my_list = [1, 2, 3]
print(id(my_list))  # Например: 140234234

# Добавление элемента
my_list.append(4)
print(my_list)      # [1, 2, 3, 4]
print(id(my_list))  # Тот же ID!

# Изменение элемента по индексу
my_list[0] = 10
print(my_list)      # [10, 2, 3, 4]

# Удаление
my_list.pop()
print(my_list)      # [10, 2, 3]

# Расширение
my_list.extend([5, 6])
print(my_list)      # [10, 2, 3, 5, 6]

# Сортировка на месте
my_list.sort()
print(my_list)      # [2, 3, 5, 6, 10]

Важно: операции как append(), sort(), reverse() изменяют список на месте и возвращают None.

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

Мощная и часто используемая структура ключ-значение.

# Создание и модификация
data = {'name': 'Alice', 'age': 30}
print(id(data))     # Например: 140234567

# Добавление нового ключа
data['city'] = 'Moscow'
print(data)         # {'name': 'Alice', 'age': 30, 'city': 'Moscow'}
print(id(data))     # Тот же ID!

# Изменение значения
data['age'] = 31
print(data)         # {'name': 'Alice', 'age': 31, 'city': 'Moscow'}

# Удаление
del data['city']
print(data)         # {'name': 'Alice', 'age': 31}

# Метод pop()
age = data.pop('age')
print(age)          # 31
print(data)         # {'name': 'Alice'}

# Обновление из другого словаря
data.update({'age': 32, 'job': 'DS'})
print(data)         # {'name': 'Alice', 'age': 32, 'job': 'DS'}

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

Неупорядоченная коллекция уникальных элементов.

# Создание и модификация
my_set = {1, 2, 3}
print(id(my_set))   # Например: 140234789

# Добавление элемента
my_set.add(4)
print(my_set)       # {1, 2, 3, 4}
print(id(my_set))   # Тот же ID!

# Удаление элемента
my_set.remove(2)    # Вызовет исключение, если элемент не существует
print(my_set)       # {1, 3, 4}

# Удаление с discard (не вызывает исключение)
my_set.discard(10)  # Ничего не происходит
print(my_set)       # {1, 3, 4}

# Операции множеств
set1 = {1, 2, 3}
set2 = {3, 4, 5}

union = set1 | set2  # Объединение: {1, 2, 3, 4, 5}
intersection = set1 & set2  # Пересечение: {3}
difference = set1 - set2  # Разность: {1, 2}

# На месте
set1.update(set2)   # Добавить все элементы set2
print(set1)         # {1, 2, 3, 4, 5}

4. Bytearray

Последовательность байтов, которая может быть изменена.

# Создание
ba = bytearray(b'Hello')
print(ba)           # bytearray(b'Hello')
print(id(ba))       # Например: 140234901

# Изменение элемента
ba[0] = ord('J')    # Заменить H на J
print(ba)           # bytearray(b'Jello')
print(id(ba))       # Тот же ID!

# Добавление
ba.extend(b' World')
print(ba)           # bytearray(b'Jello World')

# Удаление
del ba[0]
print(ba)           # bytearray(b'ello World')

5. Пользовательские классы (обычно)

По умолчанию экземпляры пользовательских классов изменяемы.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person('Alice', 30)
print(id(person))   # Например: 140235000

# Изменение атрибутов
person.age = 31
person.city = 'Moscow'  # Добавление нового атрибута
print(id(person))   # Тот же ID!

print(person.age)   # 31
print(person.city)  # Moscow

Сравнение с неизменяемыми структурами

# НЕИЗМЕНЯЕМАЯ: tuple
my_tuple = (1, 2, 3)
print(id(my_tuple))  # 140236000

# Попытка изменить вызовет ошибку
# my_tuple[0] = 10  # TypeError: 'tuple' object does not support item assignment

# Создание нового кортежа
my_tuple = (10, 2, 3)
print(id(my_tuple))  # ДРУГОЙ ID! (140236100)

# НЕИЗМЕНЯЕМАЯ: str
text = 'Hello'
print(id(text))      # 140236200

# Попытка изменить вызовет ошибку
# text[0] = 'J'      # TypeError: 'str' object does not support item assignment

# Создание новой строки
text = 'Jello'
print(id(text))      # ДРУГОЙ ID! (140236300)

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

Производительность: Изменяемые структуры как правило быстрее, когда нужны частые модификации. Например, append к списку O(1) в среднем, а конкатенация строк требует создания новой строки O(n).

Передача в функцию:

def modify_list(lst):
    lst.append(4)  # Изменяет ОРИГИНАЛЬНЫЙ список

original = [1, 2, 3]
modify_list(original)
print(original)     # [1, 2, 3, 4] — изменился!

# С неизменяемым объектом:
def modify_tuple(t):
    # t = t + (4,)  # Создаёт новый кортеж, оригинальный не меняется
    return t + (4,)

original_tuple = (1, 2, 3)
result = modify_tuple(original_tuple)
print(original_tuple)  # (1, 2, 3) — не изменился!
print(result)          # (1, 2, 3, 4)

Использование в качестве ключей словаря:

# Можно использовать неизменяемые как ключи
data = {(1, 2): 'point', 'city': 'Moscow'}
print(data[(1, 2)])  # point

# Нельзя использовать изменяемые как ключи
# data[[1, 2]] = 'point'  # TypeError: unhashable type: 'list'

Итог

Основные изменяемые структуры в Python: list, dict, set, bytearray, и большинство пользовательских классов. Понимание mutability критично для написания правильного кода и избежания неожиданных побочных эффектов.