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

Введение

В Python все типы данных делятся на две большие группы: изменяемые и неизменяемые. Это фундаментальное различие, которое влияет на то, как ведут себя переменные при передаче в функции, копировании и работе с памятью.

В этой статье мы подробно разберём изменяемые типы данных — расскажем, что это такое, какие типы считаются изменяемыми, как с ними работать, и на что нужно обратить внимание. Приведём примеры, объясним распространённые ошибки и предложим задачи для практики.

В следующей статье мы поговорим о неизменяемых типах, таких как строки, числа и кортежи.

Читайте дальше — всё объясним простыми словами и с практикой.

1. Что такое изменяемые типы данных в Python

В Python все объекты можно условно разделить на изменяемые и неизменяемые. Изменяемые типы данных — это такие структуры, содержимое которых можно менять после их создания. То есть, вы можете добавлять, удалять или изменять элементы внутри объекта без создания нового.

В отличие от них, неизменяемые типы данных не позволяют менять своё содержимое. Любое изменение приводит к созданию нового объекта. Примеры неизменяемых типов: int, float, str, tuple.

Почему это важно? Потому что понимание изменяемости помогает избежать ошибок, особенно при работе с функциями, копированием объектов и обработкой данных в памяти. Например, при передаче изменяемого объекта в функцию вы можете непреднамеренно изменить исходные данные.

Пример:

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # [1, 2, 3, 4] — объект один и тот же, он был изменён

Из этого примера видно, что переменные a и b ссылаются на один и тот же изменяемый объект — список.

2. Основные изменяемые типы данных в Python

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

1. Списки (list)
Список — это упорядоченная коллекция объектов, доступных по индексу. Его можно свободно изменять: добавлять, удалять, сортировать элементы.

my_list = [1, 2, 3]
my_list.append(4)

2. Словари (dict)
Словарь — это коллекция пар “ключ-значение”, где ключи уникальны. Содержимое словаря можно менять: добавлять, обновлять и удалять элементы.

my_dict = {"name": "Alice"}
my_dict["age"] = 25

3. Множества (set)
Множество — это неупорядоченная коллекция уникальных элементов. Элементы можно добавлять и удалять, но порядок хранения не гарантируется.

my_set = {1, 2, 3}
my_set.add(4)

4. Массив байтов (bytearray)
Этот тип используется для работы с бинарными данными и тоже поддерживает изменение содержимого.

b = bytearray(b"hello")
b[0] = 72  # заменяет первую букву на 'H'

Все эти типы позволяют изменять своё содержимое без создания новых объектов — именно это делает их изменяемыми типами данных.

3. Как работают изменяемые объекты в Python

Изменяемые объекты в Python работают по принципу ссылок на область памяти, где хранится сам объект. Когда вы присваиваете один изменяемый объект другой переменной, вы не копируете его содержимое, а просто создаёте новую ссылку на тот же объект в памяти.

Это важно понимать при работе с функциями. Если вы передаёте изменяемый объект в функцию, и функция изменяет его — эти изменения сохраняются и за пределами функции.

Пример:

def modify_list(lst):
    lst.append(100)

data = [1, 2, 3]
modify_list(data)
print(data)  # [1, 2, 3, 100]

Здесь список data был изменён внутри функции, потому что lst и data ссылаются на один и тот же объект.

Также следует учитывать поведение при копировании. Если вы просто присваиваете один список другому, это не создаёт копию — нужна либо поверхностная копия (copy()), либо глубокая копия (deepcopy()), если структура вложенная.

Пример поверхностной копии:

import copy
a = [1, 2, [3, 4]]
b = copy.copy(a)
b[2].append(5)
print(a)  # [1, 2, [3, 4, 5]] — вложенный список остался общим

Понимание устройства работы с памятью и ссылками помогает правильно использовать изменяемые типы данных и избегать неожиданных ошибок при разработке на Python.

4. Частые методы и операции с изменяемыми типами

Изменяемые типы данных в Python поддерживают широкий набор методов для работы с содержимым. Разберём основные операции, которые часто используются при программировании.

Списки (list)

• append(item) — добавление элемента в конец списка.
• insert(index, item) — вставка элемента по индексу.
• remove(item) — удаление первого вхождения элемента.
• pop(index) — удаление элемента по индексу (или последнего, если не указан).
• sort() — сортировка списка.
• reverse() — разворот списка.
• Изменение по индексу: my_list[0] = "новое значение".

my_list = [10, 20, 30]
my_list.append(40)
my_list[1] = 25
print(my_list)  # [10, 25, 30, 40]

Словари (dict)

• update() — обновление значений по ключам.
• pop(key) — удаление элемента по ключу.
• get(key) — безопасное получение значения.
• keys(), values(), items() — работа с содержимым словаря.

person = {"name": "John", "age": 30}
person["age"] = 31
person["city"] = "New York"

Множества (set)

• add(item) — добавление элемента.
• remove(item) — удаление элемента (ошибка, если элемента нет).
• discard(item) — удаление без ошибки.
• union(), intersection(), difference() — операции над множествами.

s = {1, 2, 3}
s.add(4)
s.discard(2)

Встроенные функции

Python предоставляет универсальные функции, работающие с коллекциями:

• len() — длина объекта
• sum() — сумма элементов (для числовых)
• sorted() — возвращает отсортированную копию
• enumerate() — удобный перебор с индексами
• zip() — объединение нескольких коллекций поэлементно

Умение применять эти методы позволяет эффективно обрабатывать данные и управлять логикой программы.

5. Примеры и задачи для практики

Закрепим знания о изменяемых типах данных в Python с помощью практических задач. Ниже — реальные сценарии, где полезны списки, словари и множества.

Задача 1: Корзина покупок

Смоделируйте простую корзину, куда добавляются товары:

cart = []
cart.append("яблоко")
cart.append("банан")
cart.remove("яблоко")
print(cart)

Задача 2: Подсчёт количества повторений

Используем словарь для подсчёта повторяющихся элементов:

data = ["a", "b", "a", "c", "b", "a"]
counter = {}
for item in data:
    counter[item] = counter.get(item, 0) + 1
print(counter)  # 6

Задача 3: Фильтрация данных

Фильтруем список чисел, оставляя только чётные:

numbers = [1, 2, 3, 4, 5, 6]
numbers = [n for n in numbers if n % 2 == 0]
print(numbers )  # [2, 4, 6]

Задача 4: Удаление дубликатов

С помощью множества можно быстро удалить дубликаты:

items = ["apple", "banana", "apple", "orange"]
unique_items = list(set(items))
print(unique_items)  # ['banana', 'orange', 'apple']

Решая такие задачи, вы лучше поймёте поведение изменяемых типов и научитесь применять их в реальных проектах.

6. FAQ по изменяемым типам данных в Python

В этом разделе собраны ответы на самые распространённые вопросы, связанные с изменяемыми типами данных в Python.

Почему list считается изменяемым, а tuple — нет?
Список (list) можно изменять после создания: добавлять, удалять и менять элементы по индексу. Кортеж (tuple) — это неизменяемая структура, её содержимое фиксировано, и попытка изменить элемент приведёт к ошибке. Изменяемость влияет на то, как объекты ведут себя в памяти и при передаче между функциями.

Что будет, если изменить список внутри функции?
Если функция получает изменяемый объект, например список, и внутри меняет его (добавляет или удаляет элементы), то изменения сохранятся и после выхода из функции. Это связано с тем, что в Python передаются ссылки на объекты, а не их копии.

Как скопировать изменяемый объект, чтобы не затронуть оригинал?
Чтобы создать копию изменяемого объекта и избежать изменений исходного, используют:

• Поверхностное копирование: копирует сам объект, но вложенные объекты остаются общими. Для списков можно использовать метод .copy() или copy.copy().
• Глубокое копирование: создаёт независимые копии вложенных объектов с помощью copy.deepcopy().

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