"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.
