У цій статті за допомогою прикладів ви дізнаєтесь про неглибоку та глибоку копію в 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)) Ідентифікатор старого списку: 140673303268168 Новий список: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) Ідентифікатор нового списку: 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: Додавання нового вкладеного об’єкта до списку за допомогою глибокої копії
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. Це означає, що старий і новий списки незалежні. Це тому, що старий_список був рекурсивно скопійований, що вірно для всіх його вкладених об'єктів.
