Cara menyalin kamus dan hanya mengedit salinannya

Bisakah seseorang tolong jelaskan hal ini kepada saya? Ini tidak masuk akal bagi saya.

Saya menyalin kamus ke kamus lain dan mengedit kamus kedua dan keduanya diubah. Mengapa ini terjadi?

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict1
>>> dict2
{'key2': 'value2', 'key1': 'value1'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key2': 'WHY?!', 'key1': 'value1'}

Python tidak pernah secara implisit menyalin objek. Ketika Anda mengatur dict2 = dict1, Anda membuat mereka merujuk ke objek dict yang sama persis, jadi ketika Anda memutasikannya, semua referensi padanya tetap merujuk ke objek dalam keadaan saat ini.

Jika Anda ingin menyalin dikt (yang jarang), Anda harus melakukannya secara eksplisit

dict2 = dict(dict1)

atau

dict2 = dict1.copy()

Ketika Anda menetapkan dict2 = dict1 , Anda tidak membuat salinan dict1, itu dict2hanya menjadi nama lain untuk dict1.

Untuk menyalin tipe yang bisa berubah-ubah seperti kamus, gunakan copy/ deepcopydari copymodul.

import copy

dict2 = copy.deepcopy(dict1)

Sementara dict.copy()dan dict(dict1)menghasilkan salinan, mereka hanya salinan dangkal . Jika Anda ingin salinan yang dalam , copy.deepcopy(dict1)diperlukan. Sebuah contoh:

>>> source = {'a': 1, 'b': {'m': 4, 'n': 5, 'o': 6}, 'c': 3}
>>> copy1 = x.copy()
>>> copy2 = dict(x)
>>> import copy
>>> copy3 = copy.deepcopy(x)
>>> source['a'] = 10  # a change to first-level properties won't affect copies
>>> source
{'a': 10, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy3
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> source['b']['m'] = 40  # a change to deep properties WILL affect shallow copies 'b.m' property
>>> source
{'a': 10, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy3  # Deep copy's 'b.m' property is unaffected
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}

Mengenai salinan dangkal vs dalam, dari modul Python copydocs :

Perbedaan antara penyalinan dangkal dan dalam hanya relevan untuk objek majemuk (objek yang berisi objek lain, seperti daftar atau instance kelas):

• Salinan dangkal membangun objek majemuk baru dan kemudian (sejauh mungkin) menyisipkan referensi ke objek yang ditemukan dalam aslinya.
• Salinan dalam membangun objek majemuk baru dan kemudian, secara rekursif, menyisipkan salinan ke dalamnya objek yang ditemukan dalam aslinya.

Pada python 3.5+ ada cara yang lebih mudah untuk mendapatkan salinan yang dangkal dengan menggunakan operator pembungkusan **. Didefinisikan oleh Pep 448 .

>>>dict1 = {"key1": "value1", "key2": "value2"}
>>>dict2 = {**dict1}
>>>print(dict2)
{'key1': 'value1', 'key2': 'value2'}
>>>dict2["key2"] = "WHY?!"
>>>print(dict1)
{'key1': 'value1', 'key2': 'value2'}
>>>print(dict2)
{'key1': 'value1', 'key2': 'WHY?!'}

** membongkar kamus ke kamus baru yang kemudian ditugaskan ke dict2.

Kami juga dapat mengonfirmasi bahwa setiap kamus memiliki id berbeda.

>>>id(dict1)
 178192816

>>>id(dict2)
 178192600

Jika salinan yang dalam diperlukan, maka copy.deepcopy () masih merupakan cara yang harus dilakukan.

Yang terbaik dan cara termudah untuk membuat salinan dari dict di kedua Python 2,7 dan 3 yang ...

Untuk membuat salinan kamus sederhana (level tunggal):

1. Menggunakan metode dict () , alih-alih menghasilkan referensi yang menunjuk ke dict yang ada.

my_dict1 = dict()
my_dict1["message"] = "Hello Python"
print(my_dict1)  # {'message':'Hello Python'}

my_dict2 = dict(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

2. Menggunakan metode pemutakhiran () kamus python bawaan.

my_dict2 = dict()
my_dict2.update(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

Untuk membuat salinan kamus bersarang atau kompleks:

Gunakan modul salin internal , yang menyediakan operasi salin dangkal dan dalam generik. Modul ini hadir dalam Python 2.7 dan 3. *

import copy

my_dict2 = copy.deepcopy(my_dict1)

Anda juga bisa membuat kamus baru dengan pemahaman kamus. Ini menghindari mengimpor salinan.

dout = dict((k,v) for k,v in mydict.items())

Tentu saja dengan python> = 2.7 yang dapat Anda lakukan:

dout = {k:v for k,v in mydict.items()}

Tetapi untuk compat mundur., Metode teratas lebih baik.

Selain solusi lain yang disediakan, Anda dapat menggunakan **untuk mengintegrasikan kamus ke dalam kamus kosong, misalnya,

shallow_copy_of_other_dict = {**other_dict}.

Sekarang Anda akan memiliki salinan "dangkal" other_dict .

Diterapkan pada contoh Anda:

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = {**dict1}
>>> dict2
{'key1': 'value1', 'key2': 'value2'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key1': 'value1', 'key2': 'value2'}
>>>

Pointer: Perbedaan antara copys dangkal dan dalam

Pernyataan penugasan dalam Python tidak menyalin objek, mereka membuat ikatan antara target dan objek.

jadi,, dict2 = dict1itu menghasilkan pengikatan lain antara dict2dan objek itudict1 merujuk.

jika Anda ingin menyalin sebuah dikt, Anda dapat menggunakan copy module. Modul salin memiliki dua antarmuka:

copy.copy(x)
Return a shallow copy of x.

copy.deepcopy(x)
Return a deep copy of x.

Perbedaan antara penyalinan dangkal dan dalam hanya relevan untuk objek majemuk (objek yang berisi objek lain, seperti daftar atau instance kelas):

Sebuah salinan dangkal membangun sebuah objek senyawa baru dan kemudian (sejauh mungkin) memasukkan referensi ke dalamnya untuk benda yang ditemukan dalam bahasa aslinya.

Sebuah salinan dalam membangun sebuah objek senyawa baru dan kemudian, secara rekursif, menyisipkan salinan ke dalamnya benda-benda yang ditemukan di aslinya.

Misalnya, dalam python 2.7.9:

>>> import copy
>>> a = [1,2,3,4,['a', 'b']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> a.append(5)
>>> a[4].append('c')

dan hasilnya adalah:

>>> a
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> b
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c']]
>>> d
[1, 2, 3, 4, ['a', 'b']]

Anda dapat menyalin dan mengedit salinan yang baru dibuat dalam sekali jalan dengan memanggil dictkonstruktor dengan argumen kata kunci tambahan:

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict(dict1, key2="WHY?!")
>>> dict1
{'key2': 'value2', 'key1': 'value1'}
>>> dict2
{'key2': 'WHY?!', 'key1': 'value1'}

Ini membingungkan saya juga, pada awalnya, karena saya berasal dari latar belakang C.

Dalam C, variabel adalah lokasi di memori dengan tipe yang ditentukan. Menetapkan ke variabel menyalin data ke lokasi memori variabel.

Tetapi dalam Python, variabel bertindak lebih seperti pointer ke objek. Jadi menugaskan satu variabel ke variabel lain tidak membuat salinan, itu hanya membuat nama variabel menunjuk ke objek yang sama.

Setiap variabel dalam python (hal-hal seperti dict1atau stratau __builtins__adalah pointer ke beberapa "objek" platonis tersembunyi di dalam mesin.

Jika Anda mengatur dict1 = dict2, Anda hanya menunjuk dict1ke objek yang sama (atau lokasi memori, atau analogi apa pun yang Anda suka) dict2. Sekarang, objek yang dirujuk oleh dict1adalah objek yang sama yang dirujuk oleh dict2.

Anda dapat memeriksa: dict1 is dict2seharusnya True. Juga, id(dict1)harus sama denganid(dict2) .

Anda mau dict1 = copy(dict2), ataudict1 = deepcopy(dict2) .

Perbedaan antara copydan deepcopy? deepcopyakan memastikan bahwa elemendict2 (apakah Anda mengarahkannya pada daftar?) juga merupakan salinan.

Saya tidak menggunakan deepcopybanyak - biasanya praktik buruk untuk menulis kode yang membutuhkannya (menurut saya).

dict1adalah simbol yang merujuk objek kamus yang mendasarinya. Menugaskan dict1untuk dict2hanya memberikan referensi yang sama. Mengubah nilai kunci melalui dict2simbol akan mengubah objek yang mendasarinya, yang juga memengaruhidict1 . Ini membingungkan.

Jauh lebih mudah untuk beralasan tentang nilai-nilai yang tidak dapat diubah daripada referensi, jadi buatlah salinan bila memungkinkan:

person = {'name': 'Mary', 'age': 25}
one_year_later = {**person, 'age': 26}  # does not mutate person dict

Secara sintaksis sama dengan:

one_year_later = dict(person, age=26)

dict2 = dict1tidak menyalin kamus. Ini hanya memberi Anda programmer cara kedua ( dict2) untuk merujuk ke kamus yang sama.

>>> dict2 = dict1
# dict2 is bind to the same Dict object which binds to dict1, so if you modify dict2, you will modify the dict1

Ada banyak cara untuk menyalin objek Dict, saya hanya menggunakan

dict_1 = {
           'a':1,
           'b':2
         }
dict_2 = {}
dict_2.update(dict_1)

Seperti yang dijelaskan orang lain, built-in dicttidak melakukan apa yang Anda inginkan. Tetapi dalam Python2 (dan mungkin 3 juga) Anda dapat dengan mudah membuat ValueDictkelas yang menyalin =sehingga Anda dapat yakin bahwa yang asli tidak akan berubah.

class ValueDict(dict):

    def __ilshift__(self, args):
        result = ValueDict(self)
        if isinstance(args, dict):
            dict.update(result, args)
        else:
            dict.__setitem__(result, *args)
        return result # Pythonic LVALUE modification

    def __irshift__(self, args):
        result = ValueDict(self)
        dict.__delitem__(result, args)
        return result # Pythonic LVALUE modification

    def __setitem__(self, k, v):
        raise AttributeError, \
            "Use \"value_dict<<='%s', ...\" instead of \"d[%s] = ...\"" % (k,k)

    def __delitem__(self, k):
        raise AttributeError, \
            "Use \"value_dict>>='%s'\" instead of \"del d[%s]" % (k,k)

    def update(self, d2):
        raise AttributeError, \
            "Use \"value_dict<<=dict2\" instead of \"value_dict.update(dict2)\""


# test
d = ValueDict()

d <<='apples', 5
d <<='pears', 8
print "d =", d

e = d
e <<='bananas', 1
print "e =", e
print "d =", d

d >>='pears'
print "d =", d
d <<={'blueberries': 2, 'watermelons': 315}
print "d =", d
print "e =", e
print "e['bananas'] =", e['bananas']


# result
d = {'apples': 5, 'pears': 8}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
d = {'apples': 5, 'pears': 8}
d = {'apples': 5}
d = {'watermelons': 315, 'blueberries': 2, 'apples': 5}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
e['bananas'] = 1

# e[0]=3
# would give:
# AttributeError: Use "value_dict<<='0', ..." instead of "d[0] = ..."

Lihat pola modifikasi nilai yang dibahas di sini: Python 2.7 - sintaksis bersih untuk modifikasi nilai . Pengamatan utama adalah itu strdan intberperilaku sebagai nilai-nilai dalam Python (meskipun mereka sebenarnya benda abadi di bawah tenda). Saat Anda mengamati itu, harap perhatikan juga bahwa tidak ada yang istimewa stratau ajaib int. dictdapat digunakan dalam banyak cara yang sama, dan saya bisa memikirkan banyak kasus di mana ValueDictmasuk akal.

kode berikut, yaitu pada dikt yang mengikuti sintaks json lebih dari 3 kali lebih cepat dari deepcopy

def CopyDict(dSrc):
    try:
        return json.loads(json.dumps(dSrc))
    except Exception as e:
        Logger.warning("Can't copy dict the preferred way:"+str(dSrc))
        return deepcopy(dSrc)

saya berlari ke perilaku aneh ketika mencoba untuk mendalami properti kamus dari kelas tanpa menetapkannya ke variabel

new = copy.deepcopy(my_class.a)tidak berfungsi yaitu memodifikasi newmemodifikasimy_class.a

tetapi jika Anda melakukannya old = my_class.adan new = copy.deepcopy(old)berfungsi dengan baik yaitu memodifikasi newtidak mempengaruhimy_class.a

Saya tidak yakin mengapa ini terjadi, tetapi saya harap ini bisa menghemat waktu! :)

karena, dict2 = dict1, dict2 memegang referensi ke dict1. Kedua dict1 dan dict2 menunjuk ke lokasi yang sama dalam memori. Ini hanya kasus normal saat bekerja dengan objek yang bisa berubah dalam python. Ketika Anda bekerja dengan objek yang bisa berubah dalam python Anda harus berhati-hati karena sulit untuk debug. Seperti contoh berikut ini.

 my_users = {
        'ids':[1,2],
        'blocked_ids':[5,6,7]
 }
 ids = my_users.get('ids')
 ids.extend(my_users.get('blocked_ids')) #all_ids
 print ids#output:[1, 2, 5, 6, 7]
 print my_users #output:{'blocked_ids': [5, 6, 7], 'ids': [1, 2, 5, 6, 7]}

Niat contoh ini adalah untuk mendapatkan semua id pengguna termasuk id yang diblokir. Itu kami dapatkan dari variabel id tetapi kami juga memperbarui nilai my_users secara tidak sengaja. ketika Anda memperpanjang id dengan blok_id, my_users diperbarui karena id merujuk ke my_users .

Menyalin dengan menggunakan for for:

orig = {"X2": 674.5, "X3": 245.0}

copy = {}
for key in orig:
    copy[key] = orig[key]

print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 674.5, 'X3': 245.0}
copy["X2"] = 808
print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 808, 'X3': 245.0}

Anda dapat menggunakan secara langsung:

dict2 = eval(repr(dict1))

di mana objek dict2 adalah salinan independen dict1, sehingga Anda dapat memodifikasi dict2 tanpa mempengaruhi dict1.

Ini berfungsi untuk semua jenis objek.