Šajā rakstā jūs uzzināsit par seklu un dziļu kopiju Python, izmantojot piemērus.
Kopējiet objektu Python
Programmā Python mēs izmantojam =operatoru, lai izveidotu objekta kopiju. Jūs domājat, ka tas rada jaunu objektu; tā nav. Tas tikai izveido jaunu mainīgo, kuram ir kopīga sākotnējā objekta atsauce.
Ņemsim piemēru, kur mēs izveidojam sarakstu ar nosaukumu old_list un nododam objekta atsauci new_list, izmantojot =operatoru.
1. piemērs: kopēšana, izmantojot operatoru =
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))
Kad mēs palaidīsim virs programmas, izeja būs:
Vecais saraksts: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Vecā saraksta ID: 140673303268168 Jaunais saraksts: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) Jaunā saraksta ID: 140673303268168
Kā redzams no izejas, abiem mainīgajiem mainās old_list un new_list ir tāds pats ID, ti 140673303268168.
Tātad, ja vēlaties mainīt vērtības new_list vai old_list, izmaiņas ir redzamas abās.
Būtībā dažreiz jūs varat mainīt sākotnējās vērtības un modificēt tikai jaunās vērtības vai otrādi. Programmā Python ir divi veidi, kā izveidot kopijas:
- Sekla kopija
- Dziļa kopija
Lai šīs kopijas darbotos, mēs izmantojam copymoduli.
Kopēt moduli
Mēs izmantojam copyPython moduli seklām un dziļām kopēšanas darbībām. Pieņemsim, ka jums ir jākopē saliktais saraksts, sakot x. Piemēram:
importēt kopiju copy.copy (x) copy.deepcopy (x)
Šeit copy()atgrieziet sekla x kopiju. Līdzīgi deepcopy()atgrieziet dziļu x kopiju.
Sekla kopija
Sekla kopija izveido jaunu objektu, kurā tiek saglabāta sākotnējo elementu atsauce.
Tātad, sekla kopija neveido ligzdotu objektu kopiju, tā vietā tikai kopē ligzdoto objektu atsauci. Tas nozīmē, ka kopēšanas process pats neatkārtojas un neveido ligzdoto objektu kopijas.
2. piemērs: izveidojiet kopiju, izmantojot seklu kopiju
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)
Kad mēs palaidīsim programmu, izeja būs:
Vecais saraksts: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Jauns saraksts: ((1, 2, 3), (4, 5, 6), (7 , 8., 9.)
Iepriekš minētajā programmā mēs izveidojām ligzdotu sarakstu un pēc tam sekli kopējiet to, izmantojot copy()metodi.
Tas nozīmē, ka tas radīs jaunu un neatkarīgu objektu ar tādu pašu saturu. Lai to pārbaudītu, mēs izdrukājam gan old_list, gan new_list.
Lai apstiprinātu, ka new_list atšķiras no old_list, mēs mēģinām oriģinālam pievienot jaunu ligzdotu objektu un pārbaudīt to.
3. piemērs: (4, 4, 4) pievienošana vecajam sarakstam, izmantojot seklu kopiju
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)
Kad palaidīsim programmu, tā izdos:
Vecais saraksts: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Jauns saraksts: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Iepriekš minētajā programmā mēs izveidojām seklu old_list kopiju. New_list satur atsauces uz sākotnējiem ligzdotajiem objektiem, kas saglabāti old_list. Tad mēs pievienojam jauno sarakstu, ti (4, 4, 4), old_list. Šis jaunais apakškārts netika nokopēts new_list.
Tomēr, mainot visus ligzdotos objektus old_list, izmaiņas tiek parādītas new_list.
4. piemērs: Jauna ligzdota objekta pievienošana, izmantojot Sekla kopija
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)
Kad palaidīsim programmu, tā izdos:
Vecais saraksts: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Jaunais saraksts: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Iepriekš minētajā programmā mēs veicām izmaiņas old_list ti old_list(1)(1) = 'AA'. Gan old_list, gan new_list apakšsaraksti indeksā (1)(1)tika modificēti. Tas ir tāpēc, ka abos sarakstos ir kopīga atsauce uz tiem pašiem ligzdotajiem objektiem.
Dziļa kopija
Dziļa kopija izveido jaunu objektu un rekursīvi pievieno ligzdoto objektu kopijas, kas atrodas sākotnējos elementos.
Turpināsim ar 2. piemēru. Tomēr mēs izveidosim dziļu kopiju, izmantojot modulī deepcopy()esošo funkciju copy. Dziļā kopija izveido oriģināla objekta un visu tā ligzdoto objektu neatkarīgu kopiju.
5. piemērs: Saraksta kopēšana, izmantojot dziļo kopiju ()
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)
Kad palaidīsim programmu, tā izdos:
Vecais saraksts: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Jaunais saraksts: ((1, 1, 1), (2, 2, 2), (3 , 3, 3)
Iepriekš minētajā programmā mēs izmantojam deepcopy()funkciju, lai izveidotu līdzīgu izskatu kopiju.
Tomēr, ja veicat izmaiņas kādā no ligzdotajiem objektiem sākotnējā objektā old_list, kopijas new_list izmaiņas netiks rādītas.
6. piemērs: Jauna ligzdota objekta pievienošana sarakstā, izmantojot 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)
Kad palaidīsim programmu, tā izdos:
Vecais saraksts: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Jaunais saraksts: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Iepriekš minētajā programmā, piešķirot jaunu vērtību old_list, mēs varam redzēt, ka modificēts ir tikai old_list. Tas nozīmē, ka gan old_list, gan new_list ir neatkarīgi. Tas ir tāpēc, ka old_list tika rekursīvi nokopēts, kas attiecas uz visiem tā ligzdotajiem objektiem.
