kopiera ett objekt i Python

i Python använder vi= operatör 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 = – operatören.,

exempel 1: Kopiera med hjälp av = operator

När vi kör över programmet kommer utdata att vara:

Old List: , , ]ID of Old List: 140673303268168New List: , , ]ID of New List: 140673303268168

som du kan se från utdata båda variablerna old_list och new_list delar samma id i.e140673303268168.

så, om du vill ändra några värden i new_list eller old_list, är ändringen synlig i båda.

Ibland kanske du vill ha de ursprungliga värdena oförändrade och bara ändra de nya värdena eller vice versa., I Python finns det två sätt att skapa kopior:

1. Grunt kopia
2. djup kopia

för att göra dessa kopieringsarbeten använder vi copy – modulen.

Kopieringsmodul

vi användercopy – modulen i Python för grunda och djupa kopieringsoperationer. Antag att du måste kopiera den sammansatta listan säger x. till exempel:

import copycopy.copy(x)copy.deepcopy(x)

här returnerar copy() en grund kopia av x. på samma sätt returnerar deepcopy() en djup kopia av x.,

Grundkopia

en grundkopia skapar ett nytt objekt som lagrar referensen för de ursprungliga elementen.

så, en grund kopia skapar inte en kopia av kapslade objekt, istället kopierar den bara referensen av kapslade objekt. Det betyder att en kopieringsprocess inte återkommer eller skapar kopior av kapslade objekt själv.,

exempel 2: skapa en kopia med grunt kopia

import copyold_list = , , ]new_list = copy.copy(old_list)print("Old list:", old_list)print("New list:", new_list)

När vi kör programmet kommer utmatningen att vara:

Old list: , , ]New list: , , ]

i ovanstående program skapade vi en kapslad lista och sedan Grunt kopiera den medcopy() – metoden.

detta innebär att det kommer att skapa nya 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 nytt kapslat objekt till originalet och kontrollera det.

exempel 3: Lägga till old_list, med grunt kopia

När vi kör programmet, kommer det att mata ut:

Old list: , , , ]New list: , , ]

i ovanstående program skapade vi en grund kopia av old_list. New_list innehåller referenser till original kapslade objekt som lagras i old_list. Sedan lägger vi till den nya listan dvs I old_list., Den nya underlistan kopierades inte i new_list.

När du ändrar några kapslade objekt i old_list visas ändringarna i new_list.

exempel 4: lägga till nya kapslade objekt med Grunt kopia

import copyold_list = , , ]new_list = copy.copy(old_list)old_list = 'AA'print("Old list:", old_list)print("New list:", new_list)

När vi kör programmet, kommer det att mata ut:

Old list: , , ]New list: , , ]

djup kopia

en djup kopia skapar ett nytt objekt och rekursivt lägger kopior av kapslade objekt som finns i de ursprungliga elementen.

låt oss fortsätta med exempel 2., Vi kommer dock att skapa djup kopia meddeepcopy() – funktionen som finns icopy – modulen. Den djupa kopian skapar oberoende kopia av originalobjekt och alla dess kapslade objekt.

exempel 5: Kopiera en lista med deepcopy ()

import copyold_list = , , ]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:

Old list: , , ]New list: , , ]

i ovanstående program använder videepcopy() funktion för att skapa kopia som ser liknande ut.,

om du gör ändringar i alla kapslade objekt i originalobjektet old_list ser du inga ändringar i Kopiera new_list.

exempel 6: lägga till ett nytt kapslat objekt i listan med Deep copy

När vi kör programmet kommer det att matas ut:

Old list: , , ]New list: , , ]

i ovanstående program, när vi tilldelar ett nytt värde till old_list, kan vi bara se att old_list ändras. Det betyder att både old_list och new_list är oberoende. Detta beror på att old_list kopierades rekursivt, vilket är sant för alla dess kapslade objekt.