Pada artikel ini, Anda akan belajar tentang salinan dangkal dan salinan dalam dengan Python dengan bantuan contoh.
Salin Objek dengan Python
Di Python, kami menggunakan =operator untuk membuat salinan objek. Anda mungkin berpikir bahwa ini menciptakan objek baru; tidak. Ini hanya membuat variabel baru yang membagikan referensi dari objek asli.
Mari kita ambil contoh di mana kita membuat daftar bernama old_list dan meneruskan referensi objek ke new_list menggunakan =operator.
Contoh 1: Salin menggunakan = 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))
Ketika kita menjalankan program di atas, outputnya adalah:
Daftar Lama: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID dari Daftar Lama: 140673303268168 Daftar Baru: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID dari Daftar Baru: 140673303268168
Seperti yang Anda lihat dari output, kedua variabel old_list dan new_list berbagi id yang sama yaitu 140673303268168.
Jadi, jika Anda ingin mengubah nilai apa pun di new_list atau old_list, perubahannya terlihat di keduanya.
Pada dasarnya, terkadang Anda mungkin ingin nilai asli tidak berubah dan hanya mengubah nilai baru atau sebaliknya. Di Python, ada dua cara untuk membuat salinan:
- Salinan dangkal
- Deep Copy
Untuk membuat salinan ini berfungsi, kami menggunakan copymodul.
Salin Modul
Kami menggunakan copymodul Python untuk operasi penyalinan dangkal dan dalam. Misalkan, Anda perlu menyalin daftar gabungan katakanlah x. Sebagai contoh:
impor copy copy.copy (x) copy.deepcopy (x)
Di sini, copy()kembalikan salinan dangkal x. Demikian pula, deepcopy()kembalikan salinan dalam x.
Salinan dangkal
Salinan dangkal membuat objek baru yang menyimpan referensi elemen asli.
Jadi, salinan dangkal tidak membuat salinan objek bersarang, melainkan hanya menyalin referensi objek bertingkat. Artinya, proses penyalinan tidak berulang atau membuat salinan dari objek bersarang itu sendiri.
Contoh 2: Buat salinan menggunakan salinan dangkal
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)
Saat kita menjalankan program, outputnya adalah:
Daftar lama: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Daftar baru: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Dalam program di atas, kami membuat daftar bersarang dan kemudian menyalinnya secara dangkal menggunakan copy()metode.
Artinya akan membuat objek baru dan independen dengan konten yang sama. Untuk memverifikasi ini, kami mencetak old_list dan new_list.
Untuk mengonfirmasi bahwa new_list berbeda dari old_list, kami mencoba menambahkan objek bersarang baru ke aslinya dan memeriksanya.
Contoh 3: Menambahkan (4, 4, 4) ke old_list, menggunakan salinan dangkal
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)
Saat kami menjalankan program, itu akan menampilkan:
Daftar lama: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Daftar baru: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Dalam program di atas, kami membuat salinan dangkal dari old_list. New_list berisi referensi ke objek bersarang asli yang disimpan di old_list. Kemudian kami menambahkan daftar baru yaitu (4, 4, 4)ke old_list. Sublist baru ini tidak disalin di new_list.
Namun, saat Anda mengubah objek bersarang di old_list, perubahan muncul di new_list.
Contoh 4: Menambahkan objek bertingkat baru menggunakan salinan Dangkal
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)
Saat kami menjalankan program, itu akan menampilkan:
Daftar lama: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Daftar baru: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Dalam program di atas, kami membuat perubahan pada old_list ie old_list(1)(1) = 'AA'. Baik sublist dari old_list dan new_list pada indeks (1)(1)telah diubah. Ini karena, kedua daftar berbagi referensi objek bertingkat yang sama.
Deep Copy
Salinan dalam membuat objek baru dan secara rekursif menambahkan salinan objek bersarang yang ada di elemen asli.
Mari lanjutkan dengan contoh 2. Namun, kita akan membuat salinan dalam menggunakan deepcopy()fungsi yang ada di copymodul. Salinan dalam membuat salinan independen dari objek asli dan semua objek bersarangnya.
Contoh 5: Menyalin daftar menggunakan 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)
Saat kami menjalankan program, itu akan menampilkan:
Daftar lama: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Daftar baru: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Pada program di atas, kami menggunakan deepcopy()fungsi untuk membuat salinan yang mirip.
Namun, jika Anda membuat perubahan pada objek bersarang di objek asli old_list, Anda tidak akan melihat perubahan pada salinan daftar_baru.
Contoh 6: Menambahkan objek bersarang baru dalam daftar menggunakan 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)
Saat kami menjalankan program, itu akan menampilkan:
Daftar lama: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Daftar baru: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Pada program di atas, ketika kita memberikan nilai baru ke old_list, kita hanya bisa melihat old_list diubah. Ini berarti, old_list dan new_list adalah independen. Ini karena old_list disalin secara rekursif, yang berlaku untuk semua objek bertingkatnya.
