Selles artiklis saate näiteid kasutades õppida Pythonis tehtud madalat ja sügavat koopiat.
Objekti kopeerimine Pythonis
Pythonis kasutame =objekti koopia loomiseks operaatorit. Võite arvata, et see loob uue objekti; see pole nii. See loob ainult uue muutuja, mis jagab algse objekti viidet.
Võtame näite, kus loome loendi nimega old_list ja edastame =operaatori abil objekti viite uuele_listile .
Näide 1: kopeerimine operaatori = abil
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))
Kui käivitame programmi üle, on väljund järgmine:
Vana loend: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Vana loendi ID: 140673303268168 Uus loend: ((1, 2, 3), (4, 5) , 6), (7, 8, 9)) Uue loendi ID: 140673303268168
Nagu väljundist näha, jagavad mõlemad muutujad old_list ja new_list sama ID st 140673303268168.
Niisiis, kui soovite muuta väärtusi uues loendis või vanas loendis, on muudatus mõlemas nähtav.
Põhimõtteliselt võite mõnikord soovida, et algsed väärtused muutuksid ja muudaksite ainult uusi väärtusi või vastupidi. Pythonis on koopiate loomiseks kaks võimalust:
- Madal koopia
- Sügav koopia
Nende koopiate toimimiseks kasutame copymoodulit.
Kopeeri moodul
Kasutame copyPythoni moodulit madalate ja sügavate kopeerimistoimingute jaoks. Oletame, et peate kopeerima liitloendi, näiteks x. Näiteks:
impordi koopia copy.copy (x) copy.deepcopy (x)
Siin copy()tagastage x-i madal koopia. Samamoodi deepcopy()tagastage x-i sügav koopia.
Madal koopia
Madal koopia loob uue objekti, mis salvestab viite algsetele elementidele.
Niisiis, madal koopia ei loo koopia pesastatud objektidest, vaid kopeerib lihtsalt pesastatud objektide viite. See tähendab, et kopeerimisprotsess ei kordu ega loo ise pesastatud objektidest koopiaid.
Näide 2: koopia loomiseks kasutage madalat koopiat
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)
Programmi käivitamisel on väljund:
Vana loend: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Uus loend: ((1, 2, 3), (4, 5, 6), (7 , 8, 9)
Ülalolevas programmis lõime pesastatud loendi ja kopeerisime selle seejärel copy()meetodi abil.
See tähendab, et see loob uue ja iseseisva sama sisuga objekti. Selle kinnitamiseks printime nii vana kui uue loendi.
Selle kinnitamiseks, et uus_loend erineb vanast-loendist, proovime lisada uue pesastatud objekti originaalile ja kontrollida seda.
Näide 3: (4, 4, 4) lisamine vanasse loendisse, kasutades madalat koopiat
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)
Kui käivitame programmi, väljastab see:
Vana loend: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Uus loend: ((1, 1, 1), (2 , 2, 2, 3, 3, 3)
Ülalolevas programmis lõime vana_list madala koopia. Uus_loend sisaldab viiteid algsele pesastatud objektidele, mis on salvestatud vanasse_loendisse. Seejärel lisame uue loendi st (4, 4, 4)vanasse_loendisse. Seda uut alamloendit ei kopeeritud uude loendisse.
Kui aga vanas loendis olevaid pesastatud objekte muudate, kuvatakse muudatused uues loendis.
Näide 4: Uue pesastatud objekti lisamine Shallow copy abil
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)
Kui käivitame programmi, väljastab see:
Vana loend: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Uus loend: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Ülalolevas programmis tegime muudatusi vanas_loendis st old_list(1)(1) = 'AA'. Nii vanade kui ka uute_loendite alamloendeid indeksis (1)(1)muudeti. Seda seetõttu, et mõlemas loendis on viide samadele pesastatud objektidele.
Sügav koopia
Sügav koopia loob uue objekti ja lisab rekursiivselt algsetel elementidel olevad pesastatud objektide koopiad.
Jätkame näitega 2. Siiski loome moodulis oleva deepcopy()funktsiooni abil sügava koopia copy. Sügav koopia loob algse objekti ja kõigi selle pesastatud objektide sõltumatu koopia.
Näide 5: Loendi kopeerimine sügavkopeerimise () abil
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)
Kui käivitame programmi, väljastab see:
Vana loend: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Uus loend: ((1, 1, 1), (2, 2, 2), (3 , 3, 3)
Ülaltoodud programmis kasutame deepcopy()funktsiooni sarnase väljanägemisega koopia loomiseks.
Kui aga muudate algse objekti old_list mis tahes pesastatud objekti, ei näe te koopia new_list muudatusi.
Näide 6: Uue pesastatud objekti lisamine loendisse Deep copy abil
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)
Kui käivitame programmi, väljastab see:
Vana loend: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Uus loend: ((1, 1, 1), (2, 2, 2), (3, 3, 3)
Kui määrame vanale loendile uue väärtuse, näeme ülaltoodud programmis, et ainult vana_loend on muudetud. See tähendab, et nii vana kui uus nimekiri on sõltumatud. Seda seetõttu, et old_list kopeeriti rekursiivselt, mis kehtib kõigi selle pesastatud objektide kohta.
