Ebben a cikkben példák segítségével megismerheti a Python sekély és mély másolatát.
Objektumok másolása a Pythonba
A Python-ban az =operátorral készítünk egy objektum másolatát. Gondolhatja, hogy ez új objektumot hoz létre; nem. Csak egy új változót hoz létre, amely megosztja az eredeti objektum hivatkozását.
Vegyünk egy példát, ahol létrehozunk egy old_list nevű listát, és az operátor segítségével átadunk egy objektum hivatkozást az új_ listának =.
1. példa: Másolás az = operátor használatával
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))
Amikor a program felett futunk, a kimenet a következő lesz:
Régi lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Régi lista azonosítója: 140673303268168 Új lista: (((1, 2, 3), (4, 5) , 6), (7, 8, 9)) Új lista azonosítója: 140673303268168
Amint az a kimenetből látható, a régi_lista és az újlista változók azonos azonosítóval rendelkeznek 140673303268168.
Tehát, ha az új_lista vagy a régi_lista bármely értékét módosítani szeretné, akkor a változás mindkét esetben látható lesz.
Lényegében néha érdemes megváltoztatnia az eredeti értékeket, és csak az új értékeket módosíthatja, vagy fordítva. A Pythonban kétféle módon lehet másolatokat létrehozni:
- Sekély másolat
- Mély másolat
A másolás működéséhez a copymodult használjuk .
Modul másolása
A copyPython modulját sekély és mély másolási műveletekhez használjuk. Tegyük fel, hogy át kell másolnia az összetett listát, mondjuk x. Például:
másolat importálása copy.copy (x) copy.deepcopy (x)
Itt adja copy()vissza az x sekély másolatát. Hasonlóképpen küldjön deepcopy()vissza egy mély másolatot az x-ből.
Sekély másolat
A sekély másolat új objektumot hoz létre, amely tárolja az eredeti elemek hivatkozását.
Tehát egy sekély másolat nem hoz létre másolatot a beágyazott objektumokról, hanem csak a beágyazott objektumok hivatkozását másolja. Ez azt jelenti, hogy a másolási folyamat maga nem ismétlődik és nem hoz létre másolatokat a beágyazott objektumokról.
2. példa: Készítsen másolatot sekély másolással
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)
A program futtatásakor a kimenet a következő lesz:
Régi lista: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Új lista: ((1, 2, 3), (4, 5, 6), (7 , 8., 9.)
A fenti programban létrehoztunk egy beágyazott listát, majd a copy()metódus segítségével sekélyen lemásoltuk .
Ez azt jelenti, hogy új és független, azonos tartalmú objektumot hoz létre. Ennek ellenőrzéséhez kinyomtatjuk a régi_listát és az új_listát is.
Annak megerősítésére, hogy az új_lista különbözik a régi_listától, megpróbálunk új beágyazott objektumot hozzáadni az eredetihez és ellenőrizni.
3. példa: A (4, 4, 4) hozzáadása a régi_listához sekély másolat használatával
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)
Amikor futtatjuk a programot, akkor a következőt adja ki:
Régi lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Új lista: (((1, 1, 1), (2) (2, 2), (3, 3, 3))
A fenti programban létrehoztuk a old_list sekély másolatát. Az új_lista hivatkozásokat tartalmaz a régi_listában tárolt eredeti beágyazott objektumokra. Ezután hozzáadjuk az új listát, azaz (4, 4, 4)a régi_listához. Ezt az új allistát nem másolta az új_lista.
Ha azonban a régi_listában lévő beágyazott objektumokat megváltoztatja, akkor a módosítások az új_lista mezőben jelennek meg.
4. példa: Új beágyazott objektum hozzáadása Sekély másolás használatával
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)
Amikor futtatjuk a programot, akkor a következőt adja ki:
Régi lista: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Új lista: (((1, 1, 1), (2, 'AA', 2) ), (3, 3, 3))
A fenti programban változtatásokat hajtottunk végre a old_list azaz old_list(1)(1) = 'AA'. Az indexen szereplő old_list és new_list allisták (1)(1)is módosultak. Ennek oka, hogy mindkét lista azonos beágyazott objektumok hivatkozásával rendelkezik.
Mély másolat
A mély másolat új objektumot hoz létre, és rekurzív módon hozzáadja az eredeti elemekben jelen lévő beágyazott objektumok másolatait.
Folytassuk a 2. példával. Azonban mély másolatot fogunk létrehozni deepcopy()a copymodulban található funkció segítségével . A mély másolat létrehozza az eredeti objektum és minden beágyazott objektum független másolatát.
5. példa: Lista másolása deepcopy () használatával
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)
Amikor futtatjuk a programot, akkor a következőt adja ki:
Régi lista: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Új lista: ((1, 1, 1), (2, 2, 2), (3 , 3., 3.)
A fenti programban a deepcopy()függvény segítségével készítünk hasonló megjelenésű másolatot.
Ha azonban az Old_list eredeti objektumban bármilyen beágyazott objektumot módosít, akkor az új_lista másolása nem fog módosulni.
6. példa: Új beágyazott objektum hozzáadása a listához a Deep copy használatával
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)
Amikor futtatjuk a programot, akkor a következőt adja ki:
Régi lista: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Új lista: (((1, 1, 1), (2, 2, 2), (3, 3, 3))
A fenti programban, amikor új értéket rendelünk a old_listhez, láthatjuk, hogy csak a régi_list módosul. Ez azt jelenti, hogy a régi_lista és az új_lista egyaránt független. A régi_listát rekurzívan másolták, ami minden beágyazott objektumra igaz.
