В тази статия ще научите за плитки копия и дълбоки копия в 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 at index (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 е модифициран. Това означава, че както старият, така и новият списък са независими. Това е така, защото old_list е рекурсивно копиран, което е вярно за всички негови вложени обекти.
