В этой статье вы узнаете о поверхностном и глубоком копировании в Python с помощью примеров.
Копировать объект в Python
В Python мы используем =оператор для создания копии объекта. Вы можете подумать, что это создает новый объект; это не так. Он только создает новую переменную, которая использует ссылку на исходный объект.
Рассмотрим пример, в котором мы создаем список с именем old_list и передаем ссылку на объект в new_list с помощью =оператора.
Пример 1. Копирование с использованием оператора =
old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 'a')) new_list = old_list new_list(2)(2) = 9 print('Old List:', old_list) print('ID of Old List:', id(old_list)) print('New List:', new_list) print('ID of New List:', id(new_list))
Когда мы запустим вышеуказанную программу, вывод будет:
Старый список: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID старого списка: 140673303268168 Новый список: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID нового списка: 140673303268168
Как вы можете видеть из вывода оба переменных old_list и new_list разделяет тот же идентификатор т 140673303268168.
Итак, если вы хотите изменить какие-либо значения в new_list или old_list, изменение будет видно в обоих.
По сути, иногда вы можете захотеть оставить исходные значения без изменений и изменить только новые значения или наоборот. В Python есть два способа создания копий:
- Мелкая копия
- Глубокая копия
Чтобы эти копии работали, мы используем copyмодуль.
Копировать модуль
Мы используем copyмодуль Python для операций мелкого и глубокого копирования. Предположим, вам нужно скопировать составной список, скажем x. Например:
импортировать копию copy.copy (x) copy.deepcopy (x)
Здесь copy()возвращается неглубокая копия x. Точно так же deepcopy()верните полную копию x.
Мелкая копия
Неглубокая копия создает новый объект, в котором хранятся ссылки на исходные элементы.
Таким образом, неглубокая копия не создает копию вложенных объектов, вместо этого она просто копирует ссылку на вложенные объекты. Это означает, что процесс копирования не выполняет рекурсию и не создает копии самих вложенных объектов.
Пример 2: Создание копии с помощью мелкой копии
import copy old_list = ((1, 2, 3), (4, 5, 6), (7, 8, 9)) new_list = copy.copy(old_list) print("Old list:", old_list) print("New list:", new_list)
Когда мы запустим программу, вывод будет:
Старый список: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Новый список: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
В приведенной выше программе мы создали вложенный список, а затем неглубоко скопировали его с помощью copy()метода.
Это означает, что он создаст новый и независимый объект с таким же содержимым. Чтобы убедиться в этом, мы печатаем как old_list, так и new_list.
Чтобы убедиться, что new_list отличается от old_list, мы пытаемся добавить новый вложенный объект в исходный и проверить его.
Пример 3: Добавление (4, 4, 4) в old_list с использованием неглубокой копии
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list.append((4, 4, 4)) print("Old list:", old_list) print("New list:", new_list)
Когда мы запустим программу, она выведет:
Старый список: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Новый список: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
В приведенной выше программе мы создали мелкую копию old_list. New_list содержит ссылки на исходные вложенные объекты, хранящиеся в old_list. Затем мы добавляем новый список, т.е. (4, 4, 4)в old_list. Этот новый подсписок не был скопирован в new_list.
Однако, когда вы изменяете какие-либо вложенные объекты в old_list, изменения появляются в new_list.
Пример 4: Добавление нового вложенного объекта с помощью мелкой копии
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.copy(old_list) old_list(1)(1) = 'AA' print("Old list:", old_list) print("New list:", new_list)
Когда мы запустим программу, она выведет:
Старый список: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Новый список: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
В приведенной выше программе, мы внесли изменения в old_list то есть old_list(1)(1) = 'AA'. Оба подсписка old_list и new_list в индексе (1)(1)были изменены. Это потому, что оба списка используют ссылки на одни и те же вложенные объекты.
Глубокая копия
Глубокая копия создает новый объект и рекурсивно добавляет копии вложенных объектов, присутствующих в исходных элементах.
Продолжим пример 2. Однако мы собираемся создать глубокую копию, используя deepcopy()функцию, присутствующую в copyмодуле. Глубокая копия создает независимую копию исходного объекта и всех его вложенных объектов.
Пример 5: Копирование списка с помощью deepcopy ()
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) print("Old list:", old_list) print("New list:", new_list)
Когда мы запустим программу, она выведет:
Старый список: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Новый список: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
В приведенной выше программе мы используем deepcopy()функцию для создания копии, которая выглядит примерно так же.
Однако, если вы внесете изменения в какие-либо вложенные объекты в исходном объекте old_list, вы не увидите изменений в копии new_list.
Пример 6: Добавление нового вложенного объекта в список с помощью Deep copy
import copy old_list = ((1, 1, 1), (2, 2, 2), (3, 3, 3)) new_list = copy.deepcopy(old_list) old_list(1)(0) = 'BB' print("Old list:", old_list) print("New list:", new_list)
Когда мы запустим программу, она выведет:
Старый список: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Новый список: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
В приведенной выше программе, когда мы присваиваем новое значение old_list, мы видим, что изменяется только old_list. Это означает, что и old_list, и new_list независимы. Это потому, что old_list был рекурсивно скопирован, что верно для всех его вложенных объектов.
