Dalam artikel ini, anda akan belajar mengenai salinan cetek dan salinan dalam di Python dengan bantuan contoh.
Salin Objek di Python
Di Python, kami menggunakan =operator untuk membuat salinan objek. Anda mungkin berfikir bahawa ini membuat objek baru; tidak. Ia hanya membuat pemboleh ubah baru yang berkongsi rujukan objek asal.
Mari kita ambil contoh di mana kita membuat senarai bernama old_list dan menyampaikan rujukan 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))
Apabila kita menjalankan program di atas, outputnya adalah:
Senarai Lama: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) ID Senarai Lama: 140673303268168 Senarai Baru: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) ID Senarai Baru: 140673303268168
Seperti yang anda lihat dari output kedua pemboleh ubah old_list dan new_list berkongsi id yang sama iaitu 140673303268168.
Oleh itu, jika anda ingin mengubah sebarang nilai dalam senarai baru atau senarai lama, perubahan itu dapat dilihat pada kedua-duanya.
Pada dasarnya, kadang-kadang anda mungkin mahu nilai asalnya tidak berubah dan hanya mengubah nilai baru atau sebaliknya. Di Python, terdapat dua cara untuk membuat salinan:
- Salinan Cetek
- Salinan Dalam
Untuk membuat salinan ini berfungsi, kami menggunakan copymodul.
Salin Modul
Kami menggunakan copymodul Python untuk operasi salinan cetek dan dalam. Katakan, anda perlu menyalin senarai kompaun katakanlah x. Sebagai contoh:
import copy copy.copy (x) copy.deepcopy (x)
Di sini, copy()kembalikan salinan cetek x. Begitu juga, deepcopy()kembalikan salinan dalam x.
Salinan Cetek
Salinan cetek mencipta objek baru yang menyimpan rujukan unsur-unsur asal.
Jadi, salinan cetek tidak membuat salinan objek bersarang, sebaliknya hanya menyalin rujukan objek bersarang. Ini bermaksud, proses penyalinan tidak berulang atau membuat salinan objek bersarang itu sendiri.
Contoh 2: Buat salinan menggunakan salinan cetek
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)
Semasa kita menjalankan program, outputnya adalah:
Senarai lama: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Senarai baru: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Dalam program di atas, kami membuat senarai bersarang dan kemudian menyalinnya cetek menggunakan copy()kaedah.
Ini bermaksud ia akan membuat objek baru dan bebas dengan kandungan yang sama. Untuk mengesahkannya, kami mencetak senarai lama_daftar lama dan baru.
Untuk mengesahkan bahawa new_list berbeza dari old_list, kami cuba menambahkan objek bersarang baru ke original dan memeriksanya.
Contoh 3: Menambah (4, 4, 4) ke old_list, menggunakan salinan cetek
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)
Apabila kita menjalankan program, ia akan menghasilkan:
Senarai lama: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Senarai baru: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Dalam program di atas, kami membuat salinan old_list yang cetek. The new_list mengandungi rujukan ke objek bersarang asli yang disimpan dalam senarai lama. Kemudian kita menambah senarai baru iaitu (4, 4, 4)ke senarai lama. Sub senarai baru ini tidak disalin dalam senarai_baru.
Namun, apabila anda mengubah objek yang bersarang dalam senarai lama_, perubahan akan muncul dalam senarai baru.
Contoh 4: Menambah objek bersarang baru menggunakan salinan Cetek
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)
Apabila kita menjalankan program, ia akan menghasilkan:
Senarai lama: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Senarai baru: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Dalam program di atas, kami membuat perubahan pada old_list iaitu old_list(1)(1) = 'AA'. Kedua-dua senarai lama_ senarai lama dan senarai baru di indeks (1)(1)telah diubah. Ini kerana, kedua-dua senarai berkongsi rujukan objek bersarang yang sama.
Salinan Dalam
Salinan mendalam menghasilkan objek baru dan secara rekursif menambahkan salinan objek bersarang yang terdapat dalam elemen asal.
Mari kita teruskan dengan contoh 2. Walau bagaimanapun, kita akan membuat salinan mendalam menggunakan deepcopy()fungsi yang terdapat dalam copymodul. Salinan mendalam menghasilkan salinan bebas dari objek asal dan semua objek bersarangnya.
Contoh 5: Menyalin senarai 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)
Apabila kita menjalankan program, ia akan menghasilkan:
Senarai lama: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Senarai baru: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Dalam program di atas, kami menggunakan deepcopy()fungsi untuk membuat salinan yang kelihatan serupa.
Walau bagaimanapun, jika anda membuat perubahan pada objek yang bersarang dalam senarai lama_tama objek, anda tidak akan melihat perubahan pada salinan senarai_baru.
Contoh 6: Menambah objek bersarang baru dalam senarai menggunakan Salinan dalam
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)
Apabila kita menjalankan program, ia akan menghasilkan:
Senarai lama: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Senarai baru: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Dalam program di atas, ketika kita menetapkan nilai baru untuk old_list, kita dapat melihat hanya old_list yang diubah. Ini bermaksud, senarai lama_ dan senarai_ baru adalah bebas. Ini kerana old_list disalin secara berulang, yang berlaku untuk semua objek bersarangnya.
