Введение
В 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']
Решая такие задачи, вы лучше поймёте поведение изменяемых типов и научитесь применять их в реальных проектах.
❓FAQ по изменяемым типам данных в Python
В этом разделе собраны ответы на самые распространённые вопросы, связанные с изменяемыми типами данных в Python.
🔥 Почему list считается изменяемым, а tuple — нет?
Список (list) можно изменять после создания: добавлять, удалять и менять элементы по индексу. Кортеж (tuple)
— это неизменяемая структура, её содержимое фиксировано, и попытка
изменить элемент приведёт к ошибке. Изменяемость влияет на то, как
объекты ведут себя в памяти и при передаче между функциями.
🔥 Что будет, если изменить список внутри функции?
Если
функция получает изменяемый объект, например список, и внутри меняет
его (добавляет или удаляет элементы), то изменения сохранятся и после выхода из функции. Это связано с тем, что в Python передаются ссылки на объекты, а не их копии.
🔥 Как скопировать изменяемый объект, чтобы не затронуть оригинал?
Чтобы создать копию изменяемого объекта и избежать изменений исходного, используют:
- Поверхностное копирование: копирует сам объект, но вложенные объекты остаются общими. Для списков можно использовать метод .copy() или copy.copy().
- Глубокое копирование: создаёт независимые копии вложенных объектов с помощью copy.deepcopy().
Глубокое копирование важно использовать, если объект содержит вложенные изменяемые структуры.
Если статья была полезна — поставьте пожалуйста ей лайк!
Тогда статью увидит больше читателей, а мне будет приятнее готовить для вас ещё больше полезных материалов.