Shallow и Deep Copy в Python: разница и когда использовать

Shallow copy в Python – это когда ты создаёшь 📦 новый объект, который выглядит как оригинал, но все вложенные объекты внутри него – это просто ссылки 🔗 на оригинальные. Представь, что ты делаешь фото 📸 своего рюкзака с вещами внутри: сам рюкзак новый, но вещи внутри – те же самые.

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

Почему это важно? Понимание разницы между shallow и deep copy помогает избежать неприятных сюрпризов 🎁💥. Когда ты меняешь что-то в копии, созданной через shallow copy, это может повлиять и на оригинал, если внутри есть вложенные объекты. Знать, когда использовать каждый тип копирования, значит контролировать, как твои изменения в одном месте влияют на всю программу. Это делает твой код более предсказуемым и надежным.

Пример

Представьте, что вы решили организовать вечеринку и создали список покупок в вашем любимом приложении для заметок. В этом списке у вас есть разделы: "Еда", "Напитки", и "Разное". Вы решили, что ваш друг тоже должен иметь доступ к этому списку, чтобы добавлять свои пункты. Вы делаете "копию" списка и отправляете его другу. Но вот что интересно: когда ваш друг добавляет в список "Напитки" пункт "Сок", этот пункт появляется и в вашем оригинальном списке. Почему так происходит? Потому что вы сделали не полную копию (deep copy), а "поверхностную копию" (shallow copy) списка.

import copy

# Создаем оригинальный список покупок
original_shopping_list = {"Еда": ["Хлеб", "Мясо"], "Напитки": ["Вода", "Чай"], "Разное": ["Салфетки", "Тарелки"]}

# Делаем поверхностную копию списка покупок
friend_shopping_list = copy.copy(original_shopping_list)

# Друг добавляет в список напитков "Сок"
friend_shopping_list["Напитки"].append("Сок")

# Выводим оба списка
print("Оригинальный список покупок:", original_shopping_list)
print("Список покупок друга:", friend_shopping_list)

В результате, оба списка покупок показывают, что в разделе "Напитки" есть "Сок", хотя вы не добавляли его в свой оригинальный список. Это произошло, потому что при поверхностном копировании создается новый объект на верхнем уровне, но вложенные объекты, такие как списки в разделах "Еда", "Напитки", "Разное", остаются общими между оригинальным и скопированным списками. Изменения в этих вложенных списках отражаются и в оригинальном, и в скопированном списках, так как они ссылаются на одни и те же данные в памяти.

Этот пример показывает, как поверхностное копирование может привести к неожиданным и нежелательным результатам, когда вы работаете с составными объектами, содержащими вложенные объекты.

Как работает поверхностное копирование в Python

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

Примеры поверхностного копирования

Давайте рассмотрим простой пример, который показывает, как сделать shallow copy списка:

import copy

original_list = [1, 2, [3, 4]]
shallow_copied_list = copy.copy(original_list)

# Изменяем вложенный список в копии
shallow_copied_list[2].append(5)

print("Оригинальный список:", original_list)
print("Поверхностно скопированный список:", shallow_copied_list)

В этом примере, после добавления элемента в вложенный список shallow_copied_list, изменения отражаются и в original_list. Это происходит потому, что оба списка ссылаются на один и тот же вложенный список.

Проблемы с поверхностным копированием и как их избежать

Основная проблема с shallow copy заключается в том, что изменения в копии могут неожиданно повлиять на оригинал и наоборот. Это может привести к багам, особенно в сложных структурах данных с множеством вложенных объектов.

Чтобы избежать этих проблем, важно понимать, когда использование shallow copy оправдано, и когда лучше использовать deep copy. Если вам нужна полная независимость копии от оригинала, используйте deep copy.

Deep copy как альтернатива

Глубокое копирование создает полностью независимую копию объекта со всеми его вложенными элементами. Используя функцию deepcopy() из модуля copy, вы можете создать копию объекта, изменения в которой не повлияют на оригинал.

Подробнее об этом расскажет наш спикер на видео

Пример глубокого копирования

import copy

original_list = [1, 2, [3, 4]]
deep_copied_list = copy.deepcopy(original_list)

# Изменяем вложенный список в копии
deep_copied_list[2].append(5)

print("Оригинальный список:", original_list)
print("Глубоко скопированный список:", deep_copied_list)

В этом случае изменения в deep_copied_list не затрагивают original_list, что делает их полностью независимыми друг от друга.

Когда использовать shallow copy и когда deep copy

Выбор между поверхностным и глубоким копированием зависит от вашей задачи. Если вам нужен новый объект на верхнем уровне, но нет необходимости в независимости вложенных объектов, shallow copy будет более эффективным выбором. Это может сэкономить время и память, особенно при работе с большими структурами данных.

Однако, если вам нужна полная независимость копии от оригинала, чтобы изменения в одном не влияли на другой, deep copy – ваш выбор. Это особенно важно, когда вы работаете с объектами, изменения в которых не должны отражаться на исходных данных.

В заключение, понимание разницы между shallow и deep copy в Python критично для корректной работы с объектами. Это знание поможет вам избежать неожиданных багов и сделать ваш код более надежным и предсказуемым.