Bu makalede, örnekler yardımıyla Python'da sığ kopya ve derin kopya hakkında bilgi edineceksiniz.
Python'da Bir Nesneyi Kopyalama
Python'da, =bir nesnenin kopyasını oluşturmak için operatörü kullanırız. Bunun yeni bir nesne yarattığını düşünebilirsiniz; değil. Yalnızca orijinal nesnenin referansını paylaşan yeni bir değişken oluşturur.
Old_list adlı bir liste oluşturduğumuz ve =operatörü kullanarak new_list'e bir nesne başvurusu ilettiğimiz bir örnek alalım .
Örnek 1: = operatörünü kullanarak kopyalayın
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))
Yukarıdaki programı çalıştırdığımızda çıktı şöyle olacaktır:
Eski Liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Eski Liste Kimliği: 140673303268168 Yeni Liste: ((1, 2, 3), (4, 5 , 6), (7, 8, 9)) Yeni Liste Kimliği: 140673303268168
Çıktıdan da görebileceğiniz gibi, hem old_list hem de new_list değişkenleri aynı kimliği paylaşıyor yani 140673303268168.
Bu nedenle, new_list veya old_list içindeki herhangi bir değeri değiştirmek isterseniz, değişiklik her ikisinde de görülebilir.
Esasen, bazen orijinal değerlerin değişmeden kalmasını ve yalnızca yeni değerleri değiştirmek veya tersini yapmak isteyebilirsiniz. Python'da kopya oluşturmanın iki yolu vardır:
- Sığ Kopya
- Derin Kopya
Bu kopyaların çalışması için copymodülü kullanıyoruz.
Kopyalama Modülü
Biz kullanmak copysığ ve derin kopyalama işlemleri için Python modülü. Diyelim ki, bileşik listeyi kopyalamanız gerekiyor. Örneğin:
kopyasını içe aktar copy.copy (x) copy.deepcopy (x)
Burada, copy()x'in sığ bir kopyasını döndürür. Benzer şekilde, deepcopy()x'in derin bir kopyasını döndür.
Sığ Kopya
Yüzeysel bir kopya, orijinal öğelerin referansını saklayan yeni bir nesne oluşturur.
Dolayısıyla, yüzeysel bir kopya, iç içe yerleştirilmiş nesnelerin bir kopyasını oluşturmaz, bunun yerine yalnızca iç içe geçmiş nesnelerin referansını kopyalar. Bu, bir kopyalama işleminin iç içe geçmiş nesnelerin kopyalarını tekrarlamadığı veya oluşturmadığı anlamına gelir.
Örnek 2: Basit kopya kullanarak bir kopya oluşturun
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)
Programı çalıştırdığımızda çıktı şöyle olacaktır:
Eski liste: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) Yeni liste: ((1, 2, 3), (4, 5, 6), (7 , 8, 9))
Yukarıdaki programda, iç içe geçmiş bir liste oluşturduk ve ardından copy()yöntemi kullanarak basit kopyaladık .
Bu, aynı içeriğe sahip yeni ve bağımsız nesneler yaratacağı anlamına gelir. Bunu doğrulamak için hem old_list hem de new_list yazdırıyoruz.
New_list'in old_list'ten farklı olduğunu doğrulamak için, orijinale yeni iç içe nesne eklemeye ve kontrol etmeye çalışırız.
Örnek 3: Basit kopya kullanarak old_list'e (4, 4, 4) ekleme
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)
Programı çalıştırdığımızda çıktı:
Eski liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) Yeni liste: ((1, 1, 1), (2 , 2, 2), (3, 3, 3))
Yukarıdaki programda old_list'in basit bir kopyasını oluşturduk. New_list, old_list içinde depolanan orijinal iç içe geçmiş nesnelere referanslar içerir. Sonra yeni listeyi yani (4, 4, 4)old_list'e ekliyoruz. Bu yeni alt liste, new_list'e kopyalanmadı.
Ancak, old_list içindeki herhangi bir yuvalanmış nesneyi değiştirdiğinizde, değişiklikler new_list içinde görünür.
Örnek 4: Sığ kopya kullanarak yeni iç içe nesne ekleme
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)
Programı çalıştırdığımızda çıktı:
Eski liste: ((1, 1, 1), (2, 'AA', 2), (3, 3, 3)) Yeni liste: ((1, 1, 1), (2, 'AA', 2 ), (3, 3, 3))
Yukarıdaki programda old_list yani old_list(1)(1) = 'AA'. Hem old_list hem de new_list'in indeksteki alt listeleri (1)(1)değiştirildi. Bunun nedeni, her iki listenin aynı yuvalanmış nesnelerin referansını paylaşmasıdır.
Derin Kopya
Derin bir kopya, yeni bir nesne oluşturur ve orijinal öğelerde bulunan iç içe geçmiş nesnelerin kopyalarını yinelemeli olarak ekler.
Örnek 2 ile devam edelim. Ancak, modülde deepcopy()bulunan işlevi kullanarak derin kopya oluşturacağız copy. Derin kopya, orijinal nesnenin ve tüm iç içe geçmiş nesnelerinin bağımsız bir kopyasını oluşturur.
Örnek 5: Deepcopy () kullanarak bir listenin kopyalanması
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)
Programı çalıştırdığımızda çıktı:
Eski liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3)) Yeni liste: ((1, 1, 1), (2, 2, 2), (3 , 3, 3))
Yukarıdaki programda, deepcopy()benzer görünen bir kopya oluşturmak için function kullanıyoruz .
Bununla birlikte, orijinal nesne old_list'teki iç içe geçmiş nesnelerde değişiklik yaparsanız, new_list kopyasında herhangi bir değişiklik görmezsiniz.
Örnek 6: Derin kopyayı kullanarak listeye yeni bir yuvalanmış nesne ekleme
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)
Programı çalıştırdığımızda çıktı:
Eski liste: ((1, 1, 1), ('BB', 2, 2), (3, 3, 3)) Yeni liste: ((1, 1, 1), (2, 2, 2), (3, 3, 3))
Yukarıdaki programda old_list'e yeni bir değer atadığımızda sadece old_list'in değiştirildiğini görebiliriz. Bu, hem old_list hem de new_list'in bağımsız olduğu anlamına gelir. Bunun nedeni, eski_listenin özyinelemeli olarak kopyalanmasıdır; bu, tüm iç içe nesneler için geçerlidir.
