Memahami Salinan Dangkal dan Dalam dengan Python

Python menawarkan beberapa pendekatan efisien untuk mengelola data. Memahami konsep penyalinan yang dangkal dan mendalam sangat penting ketika bekerja dengan struktur data seperti daftar bertumpuk, kamus, atau objek khusus.

Salinan dangkal dan dalam memungkinkan Anda membuat replika struktur data, namun tindakannya berbeda terkait data bertumpuk.

Menggunakan Salinan Dangkal

Salinan dangkal berfungsi dengan membuat salinan struktur tingkat atas dari objek asli. Artinya, jika objek asli berisi objek bertumpuk, salinannya akan mereferensikan objek bertumpuk yang sama dengan objek asli. Dengan kata lain, membuat salinan dangkal suatu objek akan menduplikasi struktur terluarnya, bukan objek bertumpuk apa pun yang mungkin ada di dalamnya.

Untuk melakukan penyalinan dangkal dengan Python, Anda dapat menggunakan modul penyalinan menyalin() fungsi atau .menyalin() metode pada objek tersebut.

Perhatikan contoh bekerja dengan daftar atau kamus dengan Python.

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}")

Pada kode di atas, daftar_utama variabel menyimpan daftar yang berisi bilangan bulat dan daftar bagian dalam (objek bersarang) yang berisi huruf. Fungsi salin membuat salinan daftar_utama yang kodenya disimpan di variabel lain, salinan dangkal.

Setiap perubahan yang Anda buat pada salinan dangkal daftar bersarang juga akan secara langsung mempengaruhi daftar tersebut daftar_utama dan sebaliknya. Perubahan ini menunjukkan bahwa daftar bersarang atau dalam salinan dangkal hanyalah referensi untuk itu daftar_utama, membuat perubahan diterapkan daftar_utama juga.

Sedangkan perubahan apa pun dilakukan pada item terluar (bilangan bulat) di keduanya salinan dangkal atau daftar_utama hanya akan mempengaruhi kejadian itu. Butir-butir luar ini merupakan nilai-nilai yang berdiri sendiri, bukan sekedar referensi belaka.

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}")

Outputnya menunjukkan bahwa kedua item terluar daftar tidak bergantung satu sama lain:

Ide yang sama berlaku ketika bekerja dengan kamus.

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}")

Perubahan dilakukan pada kamus bersarang dikte1 mempengaruhi keduanya dikte1 Dan dikte2. Pada saat yang sama, perubahan pada item luar dikte1 hanya mempengaruhi itu.

Menggunakan Salinan Dalam

Alih-alih mereferensikan objek bertumpuk dari salinan asli, salinan dalam membuat salinan yang sepenuhnya terpisah dari objek asli dan objek bertumpuknya. Memodifikasi salinan dalam tidak akan mempengaruhi objek aslinya dan sebaliknya; mereka benar-benar merupakan nilai yang terpisah.

Untuk membuat salinan mendalam dengan Python, gunakan salinan dalam() fungsi modul salin.

Perhatikan contoh bekerja dengan daftar.

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}")

Di sini, kode melakukan penyalinan mendalam daftar_utama, membuat salinan independen bernama deep_copy.

Saat Anda mengubah daftar bersarang atau item luar di deep_copy, perubahan Anda tidak mempengaruhi daftar asli, dan sebaliknya. Hal ini menunjukkan bahwa daftar bersarang atau elemen luar tidak dibagi antara dua salinan.

Bekerja Dengan Objek Kustom

Anda dapat membuat objek khusus dengan mendefinisikan kelas Python dan membuat instance kelas.

Berikut contoh pembuatan objek sederhana dari a Buku kelas:

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}')"

Sekarang, buatlah salinan dangkal dan salinan dalam dari contoh ini Buku kelas menggunakan menyalin modul.

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)

Seperti yang Anda lihat, salinan dangkal (buku2) adalah objek baru, namun mereferensikan objek dalam (daftar penulis) yang sama dengan objek asli (buku1). Oleh karena itu, perubahan pada penulis objek asli mempengaruhi kedua contoh (buku1 dan buku2), sedangkan perubahan pada item luar (harga) hanya mempengaruhi objek aslinya (buku1).

Di sisi lain, membuat salinan dalam akan menghasilkan salinan independen dari objek aslinya, termasuk salinan semua objek yang ada di dalamnya.

# 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)

Dalam hal ini, salinan dalam (buku2) adalah objek yang sepenuhnya independen, dan memodifikasi objek asli (buku1) tidak mempengaruhinya.

Digunakan untuk Salinan Dangkal dan Salinan Dalam

Sangat penting untuk memahami salinan yang dalam dan dangkal sehingga Anda dapat memilih pendekatan yang tepat untuk memanipulasi data. Berikut adalah beberapa skenario di mana setiap metode dapat diterapkan:

• Gunakan salinan dangkal jika Anda ingin mereplikasi objek kompleks tanpa membuat instance baru dari objek bersarangnya. Pendekatan ini lebih hemat memori dan lebih cepat daripada penyalinan dalam karena tidak menduplikasi objek yang disarangkan.
• Gunakan salinan dangkal untuk membuat cuplikan status objek sambil tetap berbagi beberapa data mendasar antara objek asli dan objek yang disalin.
• Gunakan salinan mendalam jika Anda ingin memodifikasi replika suatu objek tanpa memengaruhi aslinya. Ini menghasilkan salinan independen dari objek bersarang, memastikan bahwa perubahan apa pun pada salinan tidak berlaku pada aslinya.
• Salinan dalam sangat penting ketika Anda memerlukan salinan independen dari struktur data bertingkat, terutama ketika berhadapan dengan hierarki objek yang rekursif atau rumit.

Kinerja dan Pertimbangan

Karena salinan dangkal tidak menghasilkan instance baru dari objek bersarang, salinan ini biasanya berjalan lebih cepat dan menggunakan lebih sedikit memori dibandingkan salinan dalam. Namun, salinan asli dan dangkal mungkin memiliki efek samping yang tidak diinginkan dari perubahan item internal bersama.

Khususnya untuk struktur data yang besar dan sangat bersarang, salinan dalam, prosedur rekursif, bisa lebih lambat dan menggunakan lebih banyak memori. Namun, ini memastikan independensi total antara yang asli dan duplikat yang dalam, sehingga membuat manipulasi data yang rumit menjadi lebih aman.

Opsi Salin Terbaik untuk Data Anda

Banyak bahasa pemrograman menggunakan konsep salinan dangkal dan dalam. Memahaminya memungkinkan Anda memanipulasi data tanpa konsekuensi yang tidak terduga.

Dengan menggunakan teknik penyalinan dangkal dan mendalam, Anda dapat memilih pendekatan terbaik untuk menduplikasi struktur data Anda dengan aman. Dengan memahami dampaknya terhadap data, Anda akan mendapatkan hasil yang lebih dapat diandalkan dan diprediksi dari kode Anda.