Madala ja sügava koopia mõistmine Pythonis

Python pakub andmete haldamiseks mitmeid tõhusaid lähenemisviise. Madala ja sügava koopia kontseptsioonide mõistmine on ülioluline andmestruktuuridega, näiteks pesastatud loendite, sõnaraamatute või kohandatud objektidega töötamisel.

Nii madal kui ka sügav koopia võimaldavad teil teha andmestruktuuride koopiaid, kuid need toimivad pesastatud andmete puhul erinevalt.

Shallow Copy kasutamine

Madal koopia töötab, luues originaalobjekti tipptaseme struktuurist koopia. See tähendab, et kui originaalobjekt sisaldab pesastatud objekte, viitab koopia samadele pesastatud objektidele, mida originaalis. Teisisõnu dubleerib objektist pinnapealse koopia tegemine selle välimist struktuuri, mitte pesastatud objekte, mida see võib sisaldada.

Pinnapealse koopia tegemiseks Pythonis saate kasutada kopeerimismoodulit kopeeri () funktsioon või .copy() meetod objektil.

Kaaluge näidet Pythonis loendi või sõnastikuga töötamine.

import copy
main_list = [29, 49, ["Q", "R"]]
shallow_copy = copy.copy(main_list)
# Modify the nested list
shallow_copy[2][0] = 99
main_list[2][1] = 100
print(f"The main list: {main_list}")
print(f"The shallow copy list: {shallow_copy}")

Ülaltoodud koodis on main_list muutuja sisaldab täisarve sisaldavat loendit ja tähti sisaldavat sisemist loendit (pesastatud objekt). Kopeerimisfunktsioon loob koopia main_list mille kood salvestab teises muutujas, madal_koopia.

Kõik muudatused, mida teete madal_koopia pesastatud loend mõjutab otseselt ka loendi loendit main_list ja vastupidi. Need muudatused näitavad, et pesastatud või sisemine loend madal_koopia on lihtsalt viide sellele main_list, muutes muudatused kehtima main_list ka.

Samal ajal on välistes üksustes (täisarvudes) tehtud muudatused kummaski madal_koopia või main_list mõjutab ainult seda juhtumit. Need välised elemendid on iseseisvad väärtused, mitte ainult viited.

import copy
main_list = [29, 49, ["Q", "R"]]
shallow_copy = copy.copy(main_list)
# Modify the outer items
shallow_copy[0] = "M"
main_list[1] = "N"
print(f"The main list: {main_list}")
print(f"The shallow copy list: {shallow_copy}")

Väljund näitab, et mõlemad loendi välimised üksused on üksteisest sõltumatud:

Sama mõte kehtib ka sõnaraamatutega töötamisel.

dict1 = {'ten': 10, 'twenty': 20, 'double':{'thirty': 30, 'sixty': 60}}
dict2 = dict1.copy()
# Modify inner and outer elements
dict1['double']['thirty'] = 30.00
dict1['ten'] = 10.00
print(f"The main dictionary, {dict1}")
print(f"The shallow copy dictionary, {dict2}")

Pesastatud sõnastikus tehtud muudatused dikt1 mõjutavad mõlemat dikt1 ja dikt2. Samal ajal muudatusi välimistes üksustes dikt1 mõjutab ainult seda.

Deep Copy kasutamine

Selle asemel, et viidata originaalkoopia pesastatud objektidele, teeb sügavkoopia originaalobjektist ja selle pesastatud objektidest täiesti eraldi koopia. Süvakoopia muutmine ei mõjuta algset objekti ja vastupidi; need on tõeliselt eraldiseisvad väärtused.

Pythonis sügava koopia tegemiseks kasutage sügavkoopia () kopeerimismooduli funktsioon.

Vaatleme loendiga töötamise näidet.

import copy
main_list = [200, 300, ["I", "J"]]
deep_copy = copy.deepcopy(main_list)
# Modify the inner and outer list
deep_copy[2][0] = "K"
main_list[0] = 500
print(f"The main list: {main_list}")
print(f"The deep copy list: {deep_copy}")

Siin teeb kood sügava koopia main_list, luues iseseisva koopia nimega sügav_koopia.

Kui muudate pesastatud loendit või väliseid üksusi sügav_koopia, teie muudatused ei mõjuta algset loendit ja vastupidi. See näitab, et pesastatud loendit või väliseid elemente ei jagata kahe koopia vahel.

Kohandatud objektidega töötamine

Saate luua kohandatud objekti Pythoni klassi määratlemine ja klassi eksemplari loomine.

Siin on näide lihtsa objekti loomisest a Raamat klass:

classBook:
def__init__(self, title, authors, price):
 self.title = title
 self.authors = authors
 self.price = price
def__str__(self):
returnf"Book(title='{self.title}', author='{self.authors}', \
price='{self.price}')"

Nüüd tehke sellest eksemplarist nii madal koopia kui ka sügav koopia Raamat klassi kasutades kopeerida moodul.

import copy
# Create a Book object
book1 = Book("How to MakeUseOf Shallow Copy", \
 ["Bobby Jack", "Princewill Inyang"], 1000)
# Make a shallow copy
book2 = copy.copy(book1)
# Modify the original object
book1.authors.append("Yuvraj Chandra")
book1.price = 50
# Check the objects
print(book1)
print(book2)

Nagu näete, on madal koopia (raamat2) on uus objekt, kuid see viitab samale sisemisele objektile (autorite loendile) mis algne objekt (raamat 1). Seega mõjutab algse objekti autorite muutmine mõlemat eksemplari (raamat1 ja raamat2), samas kui muutus välises üksuses (hind) mõjutab ainult algset objekti (raamat 1).

Teisest küljest loob sügava koopia tegemine originaalobjektist sõltumatu koopia, sealhulgas kõigi selles sisalduvate objektide koopiad.

# Create a Book object
book1 = Book("Why MakeUseOf Deep Copy?", \
 ["Bobby Jack", "Yuvraj Chandra"], 5000)
# Make a deep copy
book2 = copy.deepcopy(book1)
# Modify the original object
book1.authors.append("Princewill Inyang")
book1.price = 60
# Check the objects
print(book1)
print(book2)

Sel juhul sügav koopia (raamat2) on täiesti iseseisev objekt ja muudab algset objekti (raamat 1) ei mõjuta seda.

Kasutatakse madala koopia ja sügava koopia jaoks

Väga oluline on mõista sügavat ja madalat koopiat, et saaksite valida andmetega manipuleerimiseks sobiva lähenemisviisi. Siin on mõned stsenaariumid, kus iga meetod on rakendatav.

• Kasutage madalat koopiat, kui soovite paljundada keerulist objekti ilma selle pesastatud objektide uusi eksemplare genereerimata. See lähenemisviis on mälutõhusam ja kiirem kui sügavkoopia, kuna see ei dubleeri pesastatud objekte.
• Kasutage pinnapealset koopiat, et luua objekti olekust hetktõmmis, jagades samal ajal mõningaid alusandmeid originaal- ja kopeeritud objektide vahel.
• Kasutage sügavat koopiat, kui soovite muuta objekti koopiat originaali mõjutamata. See loob pesastatud objektidest sõltumatud koopiad, tagades, et koopia muudatused ei kehti originaali kohta.
• Sügavkoopia on kriitiline, kui vajate pesastatud andmestruktuuride sõltumatuid koopiaid, peamiselt rekursiivsete või keerukate objektide hierarhiate puhul.

Toimivus ja kaalutlused

Kuna madalkoopia ei loo uusi pesastatud objektide eksemplare, töötab see tavaliselt kiiremini ja kasutab vähem mälu kui sügavkoopia. Kuid originaalil ja madalal koopial võivad jagatud sisemiste üksuste muutmisel olla soovimatud kõrvalmõjud.

Eriti suurte ja sügavalt pesastatud andmestruktuuride puhul, sügavkoopia, rekursiivne protseduur, võib olla aeglasem ja kasutada rohkem mälu. Siiski tagab see täieliku sõltumatuse originaali ja sügava duplikaadi vahel, muutes keeruka andmetega manipuleerimise turvalisemaks.

Parim teie andmete kopeerimisvalik

Paljud programmeerimiskeeled kasutavad madala ja sügava koopia kontseptsiooni. Selle mõistmine võimaldab teil andmeid manipuleerida ilma ettenägematute tagajärgedeta.

Kasutades madalaid ja sügavaid kopeerimistehnikaid, saate valida parima meetodi oma andmestruktuuride turvaliseks dubleerimiseks. Kui mõistate mõju oma andmetele, saate oma koodist usaldusväärsemad ja prognoositavamad tulemused.