Tässä artikkelissa opit matalasta kopiosta ja syväkopioinnista Pythonissa esimerkkien avulla.
Kopioi objekti Pythonissa
Pythonissa käytämme =operaattoria objektin kopion luomiseen. Saatat ajatella, että tämä luo uuden objektin; se ei. Se luo vain uuden muuttujan, joka jakaa alkuperäisen objektin viitteen.
Otetaan esimerkki, jossa luodaan luettelo nimeltä vanha_lista ja välitetään objektiviittaus uudelle listalle =operaattorin avulla.
Esimerkki 1: Kopioi käyttämällä = operaattoria
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))
Kun suoritamme ohjelman yläpuolella, tulos on:
Vanha luettelo: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Vanhan luettelon tunnus: 140673303268168 Uusi luettelo: ((1, 2, 3), (4, 5) , 6), (7, 8, 9)) Uuden luettelon tunnus: 140673303268168
Kuten tulosteesta näkyy, molemmilla muuttujilla old_list ja new_list on sama tunnus eli 140673303268168.
Joten, jos haluat muokata arvoja new_list tai old_list, muutos näkyy molemmissa.
Pohjimmiltaan joskus haluat ehkä muuttaa alkuperäisiä arvoja ja muuttaa vain uusia arvoja tai päinvastoin. Pythonissa kopioita voidaan luoda kahdella tavalla:
- Matala kopio
- Syvä kopio
Jotta nämä kopiot toimisivat, käytämme copymoduulia.
Kopioi moduuli
Käytämme copyPython-moduulia mataliin ja syvään kopiointiin. Oletetaan, että sinun on kopioitava yhdistelmäluettelo sanomalla x. Esimerkiksi:
tuo kopio copy.copy (x) copy.deepcopy (x)
Tässä copy()paluuta matala kopioida x. Samoin deepcopy()palauttaa syvä kopion X.
Matala kopio
Pieni kopio luo uuden objektin, joka tallentaa viittauksen alkuperäisiin elementteihin.
Joten matala kopio ei luo kopiota sisäkkäisistä kohteista, vaan vain kopioi sisäkkäisten objektien viitteen. Tämä tarkoittaa, että kopiointiprosessi ei toistu eikä luo itse kopioita sisäkkäisistä kohteista.
Esimerkki 2: Luo kopio käyttämällä matalaa kopiota
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)
Kun suoritamme ohjelmaa, tulos on:
Vanha luettelo: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Uusi luettelo: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Yllä olevassa ohjelmassa loimme sisäkkäisen luettelon ja kopioimme sen sitten matalalla copy()menetelmällä.
Tämä tarkoittaa, että se luo uuden ja itsenäisen objektin, jolla on sama sisältö. Tämän vahvistamiseksi tulostamme sekä old_list että new_list.
Yritämme lisätä uusi sisäkkäinen objekti alkuperäiseen ja tarkistaa se sen varmistamiseksi, että uusi_luettelo eroaa vanhasta.
Esimerkki 3: Lisätään (4, 4, 4) vanhaan listaan käyttämällä matalaa kopiota
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)
Kun suoritamme ohjelman, se tuottaa:
Vanha luettelo: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Uusi luettelo: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Edellä olevassa ohjelmassa loimme matalan kopion old_lististä. Uusi_luettelo sisältää viittauksia alkuperäisiin sisäkkäisiin kohteisiin, jotka on tallennettu vanhaan_listaan. Sitten lisätään uusi luettelo eli (4, 4, 4)old_list. Tätä uutta aliluetteloa ei kopioitu uuteen luetteloon.
Kun kuitenkin muutat sisäkkäisiä objekteja old_list, muutokset näkyvät new_list-luettelossa.
Esimerkki 4: Uuden sisäkkäisen objektin lisääminen Shallow copy -toiminnon avulla
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)
Kun suoritamme ohjelman, se tuottaa:
Vanha luettelo: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Uusi luettelo: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
In the above program, we made changes to old_list i.e old_list(1)(1) = 'AA'. Both sublists of old_list and new_list at index (1)(1) were modified. This is because, both lists share the reference of same nested objects.
Deep Copy
A deep copy creates a new object and recursively adds the copies of nested objects present in the original elements.
Let’s continue with example 2. However, we are going to create deep copy using deepcopy() function present in copy module. The deep copy creates independent copy of original object and all its nested objects.
Example 5: Copying a list using 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)
When we run the program, it will output:
Old list: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) New list: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
In the above program, we use deepcopy() function to create copy which looks similar.
Jos kuitenkin teet muutoksia alkuperäisen objektin old_list sisäkkäisiin objekteihin, kopion new_list-luetteloon ei tule muutoksia.
Esimerkki 6: Uuden sisäkkäisen objektin lisääminen luetteloon käyttämällä Deep copy -toimintoa
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)
Kun suoritamme ohjelman, se tuottaa:
Vanha luettelo: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Uusi luettelo: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Kun annamme uudelle arvolle old_list, yllä olevassa ohjelmassa voimme nähdä, että vain old_list on muokattu. Tämä tarkoittaa, että sekä vanha_lista että uusi_lista ovat riippumattomia. Tämä johtuu siitä, että old_list kopioitiin rekursiivisesti, mikä pätee kaikkiin sen sisäkkäisiin kohteisiin.
