# `copy` --- Shallow and deep copy operations

Kode sumber: Lib/copy.py

Pernyataan penetapan dalam Python tidak menyalin objek, mereka membuat ikatan antara target dengan sebuah objek. Untuk collections yang dapat diubah atau memiliki item-item yang dapat diubah, sebuah penyalinan terkadang dibutuhkan sehingga seseorang dapat mengubah salinan tanpa mengubah yang lainnya. Modul ini menyediakan operasi salinan dangkal dan salinan dalam (dijelaskan dibawah ini).

Ringkasan antarmuka:

copy.copy(obj)

  Return a shallow copy of obj.

copy.deepcopy(obj[, memo])

  Return a deep copy of obj.

copy.replace(obj, /, **changes)

  Creates a new object of the same type as obj, replacing fields with values from changes.

  Added in version 3.13.

exception copy.Error

  Di angkat untuk error spesifik dari modul.

Perbedaan antara shallow copy dan deep copy hanya relevan untuk objek majemuk (objek yang berisi objek lainnya, seperti list atau kelas):

- Sebuah shallow copy membangun sebuah objek majemuk baru dan kemudian (sejauh mungkin) menyisipkan referensi ke dalamnya ke objek yang ditemukan di aslinya.

- Sebuah deep copy membangun objek majemuk baruk dan kemudian, secara rekursif, menyisipkan salinan ke dalamnya ke objek yang ditemukan di aslinya.

Dua masalah yang sering muncul pada operasi deep copy yang tidak muncul pada operasi shallow copy:

- Objek rekursif (objek majemuk yang secara langsung atau tidak langsung berisi sebuah referensi ke dirinya sendiri) mungkin menyebabkan sebuah perulangan rekursif.

- Karena deep copy menyalin segalanya sehingga mungkin menyalin terlalu banyak, seperti data yang dimaksudkan untuk dibagikan kepada salinan lain.

Fungsi `deepcopy()` menghindari masalah diatas dengan:

- menyimpan sebuah `memo` kamus dari objek yang sudah disalin selama penyalinan saat ini; dan

- membiarkan kelas-kelas yang didefinisikan oleh user menimpa operasi penyalinan atau kumpulan komponen yang disalin.

This module does not copy types like module, method, stack trace, stack frame, file, socket, window, or any similar types. It does "copy" functions and classes (shallow and deeply), by returning the original object unchanged; this is compatible with the way these are treated by the `pickle` module.

Salinan dangkal dari kamus dapat di buat menggunakan `dict.copy()`, dan list dengan menetapkan potongan dari keseluruhan list, sebagai contoh, `copied_list = original_list[:]`.

Kelas-kelas dapat menggunakan antarmuka yang sama untuk mengontrol penyalinan yang mereka gunakan untuk mengontrol pengawetan. Lihat deskripsi dari modul `pickle` untuk informasi dari metode ini. Faktanya, modul `copy` menggunakan fungsi pengawetan yang terdaftar dari modul `copyreg`.

In order for a class to define its own copy implementation, it can define special methods `__copy__()` and `__deepcopy__()`.

object.__copy__(self)

  Called to implement the shallow copy operation; no additional arguments are passed.

object.__deepcopy__(self, memo)

  Called to implement the deep copy operation; it is passed one argument, the memo dictionary. If the `__deepcopy__` implementation needs to make a deep copy of a component, it should call the `deepcopy()` function with the component as first argument and the memo dictionary as second argument. The memo dictionary should be treated as an opaque object.

Function `copy.replace()` is more limited than `copy()` and `deepcopy()`, and only supports named tuples created by `namedtuple()`, `dataclasses`, and other classes which define method `__replace__()`.

object.__replace__(self, /, **changes)

  This method should create a new object of the same type, replacing fields with values from changes.

Lihat juga

Modul `pickle`

  Diskusi tentang metode khusus yang digunakan untuk mendukung pengambilan dan pemulihan status objek.