У овом чланку ћете научити о плиткој копији и дубинској копији у Питхону уз помоћ примера.
Копирајте објекат у Питхон
У Питхону користимо =оператор да бисмо креирали копију објекта. Можда мислите да ово ствара нови објекат; није. Ствара само нову променљиву која дели референцу оригиналног објекта.
Узмимо пример где креирамо листу која се зове олд_лист и преносимо референцу објекта на нев_лист помоћу =оператора.
Пример 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
Као што можете видети из резултата, променљиве олд_лист и нев_лист деле исти ид, тј 140673303268168.
Дакле, ако желите да измените било коју вредност у нев_лист или олд_лист, промена је видљива у оба.
У основи, понекад ћете можда желети да оригиналне вредности остану непромењене и да само модификујете нове вредности или обрнуто. У Питхону постоје два начина за стварање копија:
- Схаллов Цопи
- Дееп Цопи
Да би ове копије функционисале, користимо copyмодул.
Копирај модул
Користимо copyмодул Питхона за плитке и дубоке операције копирања. Претпоставимо да треба да копирате сложену листу рецимо к. На пример:
импорт цопи цопи.цопи (к) цопи.деепцопи (к)
Овде се copy()враћа плитка копија к. Слично томе, deepcopy()вратите дубинску копију к.
Схаллов Цопи
Плитка копија ствара нови објекат који чува референцу оригиналних елемената.
Дакле, плитка копија не ствара копију угнежђених објеката, већ само копира референцу угнежђених објеката. То значи да се поступак копирања не понавља или сам ствара копије угнежђених објеката.
Пример 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()методом.
То значи да ће створити нови и независни објекат са истим садржајем. Да бисмо то верификовали, исписујемо стару и нову.
Да бисмо потврдили да се нев_лист разликује од олд_лист, покушавамо да додамо нови угнежђени објекат у оригинал и проверимо га.
Пример 3: Додавање (4, 4, 4) на олд_лист, помоћу плитке копије
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))
У горе наведеном програму створили смо плитку копију олд_лист. Нев_лист садржи референце на оригиналне угнежђене објекте ускладиштене у олд_лист. Затим додајемо нову листу, тј. (4, 4, 4)У олд_лист. Ова нова подлистка није копирана у нев_лист.
Међутим, када промените угнежђене објекте у олд_лист, промене ће се појавити у нев_лист.
Пример 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, 'АА', 2), (3, 3, 3)) Нова листа: ((1, 1, 1), (2, 'АА', 2 ), (3, 3, 3))
У горе наведеном програму извршили смо промене на олд_лист тј old_list(1)(1) = 'AA'. Измењене су и подлистке старе и нове листе у индексу (1)(1). То је зато што обе листе деле референцу истих угнежђених објеката.
Дееп Цопи
Дубинска копија ствара нови објекат и рекурзивно додаје копије угнежђених објеката присутних у оригиналним елементима.
Наставимо са примером 2. Међутим, креираћемо дубоку копију помоћу deepcopy()функције присутне у copyмодулу. Дубинска копија ствара независну копију оригиналног објекта и свих његових угнежђених објеката.
Пример 5: Копирање листе помоћу дубоке копије ()
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()функцију за стварање копије која изгледа слично.
Међутим, ако направите промене у било којем угнежђеном објекту у оригиналном објекту олд_лист, нећете видети промене на копији нев_лист.
Пример 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), ('ББ', 2, 2), (3, 3, 3)) Нова листа: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
У горе наведеном програму, када додамо нову вредност старом_списку, можемо видети да је измењен само стари_попис. То значи да су и стара и нова листа независни. То је зато што је стари_лист био рекурзивно копиран, што је тачно за све његове угнежђене објекте.
