Šiame straipsnyje, naudodamiesi pavyzdžiais, sužinosite apie „Python“ negilias ir gilias kopijas.
Nukopijuokite objektą „Python“
„Python“ mes naudojame =operatorių, kad sukurtume objekto kopiją. Galite pagalvoti, kad tai sukuria naują objektą; taip nėra. Tai sukuria tik naują kintamąjį, kuris dalijasi pirminio objekto nuoroda.
Paimkime pavyzdį, kai mes sukuriame sąrašą pavadinimu „old_list“ ir perduodame objekto nuorodą į „new_list“ naudodami =operatorių.
1 pavyzdys: nukopijuokite naudodami = operatorių
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))
Kai vykdysime virš programos, išvestis bus:
Senasis sąrašas: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Senojo sąrašo ID: 140673303268168 Naujas sąrašas: ((1, 2, 3), (4, 5) , 6), (7, 8, 9)) Naujojo sąrašo ID: 140673303268168
Kaip matote iš išvesties, abu kintamieji old_list ir new_list turi tą patį ID, t 140673303268168.
Taigi, jei norite pakeisti kokias nors reikšmes „new_list“ arba „old_list“, pakeitimai matomi abiejuose.
Iš esmės kartais gali tekti nekeisti pradinių verčių ir modifikuoti tik naujas reikšmes arba atvirkščiai. „Python“ yra du būdai sukurti kopijas:
- Sekli kopija
- Gili kopija
Kad ši kopija veiktų, mes naudojame copymodulį.
Kopijuoti modulį
„ copyPython “ modulį naudojame seklioms ir gilioms kopijavimo operacijoms. Tarkime, reikia nukopijuoti sudėtinį sąrašą, sakant x. Pavyzdžiui:
importuoti kopiją copy.copy (x) copy.deepcopy (x)
Čia copy()pateikite negilų x egzempliorių. Panašiai deepcopy()grąžinkite gilią x kopiją.
Sekli kopija
Negili kopija sukuria naują objektą, kuriame saugoma originalių elementų nuoroda.
Taigi, sekli kopija nesukuria įdėtų objektų kopijų, o tiesiog nukopijuoja įdėtų objektų nuorodą. Tai reiškia, kad kopijavimo procesas nesikartoja ir pats nesukuria įdėtų objektų kopijų.
2 pavyzdys: sukurkite kopiją naudodami seklią kopiją
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)
Kai vykdysime programą, išvestis bus:
Senas sąrašas: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Naujas sąrašas: ((1, 2, 3), (4, 5, 6), (7 , 8, 9)
Pirmiau pateiktoje programoje mes sukūrėme įdėtą sąrašą ir tada sekliai nukopijuokite jį naudodami copy()metodą.
Tai reiškia, kad bus sukurtas naujas ir nepriklausomas to paties turinio objektas. Norėdami tai patvirtinti, atspausdiname ir seną_, ir naują_ sąrašą.
Norėdami patvirtinti, kad new_list skiriasi nuo old_list, mes stengiamės pridėti naują įdėtą objektą prie originalo ir jį patikrinti.
3 pavyzdys: (4, 4, 4) įtraukimas į old_list, naudojant negilų egzempliorių
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)
Kai vykdysime programą, ji išves:
Senas sąrašas: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Naujas sąrašas: ((1, 1, 1), (2 , 2, 2, 3, 3, 3)
Pirmiau pateiktoje programoje mes sukūrėme negilią old_list kopiją. Naujame sąraše yra nuorodų į originalius įdėtus objektus, saugomus senajame sąraše. Tada mes įtraukiame naują sąrašą, ty (4, 4, 4)į old_list. Šis naujas antrinis sąrašas nebuvo nukopijuotas į „new_list“.
Tačiau pakeitus bet kuriuos įdėtus objektus „old_list“, pakeitimai rodomi „new_list“.
4 pavyzdys: Naujo įdėto objekto pridėjimas naudojant „Shallow copy“
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)
Kai vykdysime programą, ji išves:
Senas sąrašas: ((1, 1, 1), (2, „AA“, 2), (3, 3, 3)) Naujas sąrašas: ((1, 1, 1), (2, „AA“, 2 ), (3, 3, 3))
Pirmiau pateiktoje programoje mes pakeitėme „old_list“, t old_list(1)(1) = 'AA'. Abiejuose „old_list“ ir „new_list“ sublistuose (1)(1)buvo pakeista. Taip yra todėl, kad abiejuose sąrašuose yra tų pačių įdėtų objektų nuoroda.
Gili kopija
Gilioji kopija sukuria naują objektą ir rekursyviai prideda įdėtų objektų kopijas, esančias originaliuose elementuose.
Tęskime 2 pavyzdį. Tačiau mes sukursime gilią kopiją naudodami modulyje esančią deepcopy()funkciją copy. Gilioji kopija sukuria nepriklausomą originalaus objekto ir visų jo įdėtų objektų kopijas.
5 pavyzdys: sąrašo kopijavimas naudojant gylio kopiją ()
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)
Kai vykdysime programą, ji išves:
Senas sąrašas: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Naujas sąrašas: ((1, 1, 1), (2, 2, 2), (3 , 3, 3)
Aukščiau pateiktoje programoje mes naudojame deepcopy()funkciją, kad sukurtume panašią kopiją.
Tačiau jei atliksite pakeitimus bet kuriame įdėtame objekte, esančiame pradiniame objekte „old_list“, „copy new_list“ pakeitimų nematysite.
6 pavyzdys: Naujo įdėto objekto įtraukimas į sąrašą naudojant „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)
Kai vykdysime programą, ji išves:
Senas sąrašas: ((1, 1, 1), („BB“, 2, 2), (3, 3, 3)) Naujas sąrašas: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Pirmiau pateiktoje programoje, priskirdami naują reikšmę senam_sąrašui, matome, kad modifikuotas tik senasis_s sąrašas. Tai reiškia, kad tiek senas_, tiek naujas_ sąrašas yra nepriklausomi. Taip yra todėl, kad „old_list“ buvo rekursyviai nukopijuotas, tai pasakytina apie visus įdėtus objektus.
