I den här artikeln kommer du att lära dig mer om grund kopia och djup kopia i Python med hjälp av exempel.
Kopiera ett objekt i Python
I Python använder vi =operator för att skapa en kopia av ett objekt. Du kanske tror att detta skapar ett nytt objekt; det gör det inte. Det skapar bara en ny variabel som delar referensen för det ursprungliga objektet.
Låt oss ta ett exempel där vi skapar en lista med namnet old_list och skickar en objektreferens till new_list med hjälp av =operator.
Exempel 1: Kopiera med = operator
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))
När vi kör över programmet kommer utmatningen att vara:
Gammal lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID för gammal lista: 140673303268168 Ny lista: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID för ny lista: 140673303268168
Som ni kan se från utgången båda variablerna old_list och new_list delar samma id dvs 140673303268168.
Så, om du vill ändra några värden i new_list eller old_list, är ändringen synlig i båda.
I grund och botten kanske du ibland vill ha de ursprungliga värdena oförändrade och bara ändra de nya värdena eller tvärtom. I Python finns det två sätt att skapa kopior:
- Grunt kopia
- Djup kopia
För att få dessa kopior att fungera använder vi copymodulen.
Kopiera modul
Vi använder copyPython-modulen för grunda och djupa kopieringsåtgärder. Antag att du måste kopiera sammansatta listan säg x. Till exempel:
importera kopia kopia.kopia (x) kopia.deepkopi (x)
Här copy()returneras en grunt kopia av x. På samma sätt deepcopy()returnerar du en djup kopia av x.
Grunt kopia
En grunt kopia skapar ett nytt objekt som lagrar referensen för originalelementen.
Så, en grund kopia skapar inte en kopia av kapslade objekt, utan kopierar bara referensen för kapslade objekt. Det betyder att en kopieringsprocess inte återger eller skapar kopior av kapslade objekt i sig.
Exempel 2: Skapa en kopia med grunt kopia
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)
När vi kör programmet blir resultatet:
Gammal lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Ny lista: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
I ovanstående program skapade vi en kapslad lista och kopierade sedan grunt med hjälp av copy()metoden.
Detta innebär att det kommer att skapa nytt och oberoende objekt med samma innehåll. För att verifiera detta skriver vi ut både old_list och new_list.
För att bekräfta att new_list skiljer sig från old_list försöker vi lägga till ett nytt kapslat objekt i originalet och kontrollera det.
Exempel 3: Lägga till (4, 4, 4) till old_list med grunt kopia
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)
När vi kör programmet kommer det att matas ut:
Gammal lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Ny lista: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
I ovanstående program skapade vi en grunt kopia av old_list. Den nya listan innehåller referenser till ursprungliga kapslade objekt som lagras i den gamla listan. Sedan lägger vi till den nya listan, dvs. (4, 4, 4)i old_list. Denna nya underlista kopierades inte till new_list.
Men när du ändrar några kapslade objekt i old_list visas ändringarna i new_list.
Exempel 4: Lägga till nytt kapslat objekt med grunt kopia
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)
När vi kör programmet kommer det att matas ut:
Gammal lista: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Ny lista: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
I ovanstående program, gjorde vi ändringar old_list dvs old_list(1)(1) = 'AA'. Båda sublistorna till old_list och new_list at index (1)(1)ändrades. Detta beror på att båda listorna delar referensen för samma kapslade objekt.
Djup kopia
En djup kopia skapar ett nytt objekt och adderar rekursivt kopiorna av kapslade objekt som finns i originalelementen.
Låt oss fortsätta med exempel 2. Vi ska dock skapa djupkopia med hjälp av deepcopy()funktionen som finns i copymodulen. Den djupa kopian skapar oberoende kopia av originalobjektet och alla dess kapslade objekt.
Exempel 5: Kopiera en lista med hjälp av 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)
När vi kör programmet kommer det att matas ut:
Gammal lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Ny lista: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
I programmet ovan använder vi deepcopy()funktionen för att skapa en kopia som ser likadan ut.
Men om du gör ändringar i några kapslade objekt i originalobjektet old_list ser du inga ändringar i kopian new_list.
Exempel 6: Lägga till ett nytt kapslat objekt i listan med 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)
När vi kör programmet kommer det att matas ut:
Gammal lista: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Ny lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
I ovanstående program, när vi tilldelar ett nytt värde till old_list, kan vi se att endast old_list har ändrats. Detta innebär att både den gamla och den nya listan är oberoende. Detta beror på att den gamla_listan kopierades rekursivt, vilket är sant för alla dess kapslade objekt.
