Создает ли python3 dict.copy только мелкие копии?

Целые числа неизменяемы, проблема возникает при ссылке на объекты, проверьте этот аналогичный пример:

import copy
a = {'one': [], 'two': 2, 'three': 3}
b = a.copy()
c = copy.deepcopy(a)
print(a is b) # False
print(a == b) # True

a['one'].append(5)
print(a) # {'one': [5], 'two': 2, 'three': 3}
print(b) # {'one': [5], 'two': 2, 'three': 3}
print(c) # {'one': [], 'two': 2, 'three': 3}

Вот он, вживую

То, что вы наблюдаете, вообще не имеет ничего общего со словарями. Вас смущает разница между связыванием и мутацией.

Давайте сначала забудем о словарях и продемонстрируем проблему с помощью простых переменных. Как только мы поймем основную мысль, мы сможем вернуться к примеру со словарем.

a = 1
b = a
a = 2
print(b)  # prints 1

• В первой строке вы создаете привязку между именем a и объектом 1.
• Во второй строке вы создаете привязку между именем b и значением выражения a ..., которое является тем же самым объектом 1, который был привязан к имени a в предыдущей строке.
• В третьей строке вы создаете связь между именем a и объектом 2, при этом забывая, что когда-либо была связь между a и 1.

Важно отметить, что этот последний шаг никоим образом не может повлиять на b!

Ситуация полностью симметрична, поэтому, если бы строка 3 была b = 2, это абсолютно не повлияло бы на a.

Теперь люди часто ошибочно утверждают, что это каким-то образом является результатом неизменности целых чисел. Целые числа являются неизменяемыми в Python, но это совершенно не имеет значения. Если мы проделаем нечто подобное с некоторыми изменяемыми объектами, скажем, списками, то получим эквивалентные результаты.

a = [1]
b = a
a = [2]
print(b) # prints [1]

Снова

• a привязан к какому-то объекту
• b привязан к тому же объекту
• a теперь перенаправляется на какой-то другой объект

Это не может каким-либо образом повлиять на b или объект, к которому он привязан [*]! Нигде не было предпринято никаких попыток мутировать какой-либо объект, поэтому изменчивость совершенно не имеет отношения к этой ситуации.

[*] на самом деле он изменяет счетчик ссылок на объект (по крайней мере, в CPython), но на самом деле это не наблюдаемое свойство объекта.

Однако если вместо перепривязки a мы

1. Используйте a для доступа к объекту, к которому он привязан.
2. Мутировать этот объект

то мы повлияем на b, потому что объект, к которому привязан b, будет видоизменен:

a = [1]
b = a
a[0] = 2
print(b)  # prints [2]

В общем, вы должны понять

1. Разница между связыванием и мутацией. Первый влияет на переменную (или, в более общем случае, на местоположение), а второй — на объект. В этом ключевое отличие

2. Повторная привязка имени (или местоположения в целом) не может повлиять на объект, к которому это имя было ранее привязано (помимо изменения счетчика ссылок).

Теперь в вашем примере вы создаете что-то, что выглядит (концептуально) так:

a ---> { 'three' ----------------------> 3
         'two'   -------------> 2        ^
         'one'   ---> 1 }       ^        |
                      ^         |        |
                      |         |        |
b ---> { 'one'   -----          |        |
         'two'   ---------------         |
         'three' -------------------------

а затем a['one'] = 5 просто перепривязывает местоположение a['one'] так, что оно больше не привязано к 1, а к 5. Другими словами, эта стрелка, выходящая из первого 'one', теперь указывает куда-то еще.

Важно помнить, что это не имеет абсолютно никакого отношения к неизменности целых чисел. Если вы сделаете каждое целое число в своем примере изменяемым (например, заменив его списком, который его содержит: т. е. замените каждое вхождение 1 на [1] (и аналогично для 2 и 3)), то вы все равно будете наблюдать по существу такое же поведение : a['one'] = [1] не повлияет на значение b['one'].

Теперь, в этом последнем примере, где значения, хранящиеся в вашем словаре, представляют собой списки и, следовательно, структурированы, становится возможным различать поверхностное и глубокое копирование:

• b = a вообще не будет копировать словарь: он просто создаст b новую привязку к тому же единственному словарю.
• b = copy.copy(b) создаст новый словарь с внутренними привязками к тем же спискам. Словарь копируется, но на его содержимое (ниже верхнего уровня) просто ссылается новый словарь.
• b = copy.deepcopy(a) также создаст новый словарь, но также создаст новые объекты для заполнения этого словаря, а не ссылки на исходные.

Следовательно, если вы мутируете (а не перепривязываете) что-то в случае неглубокой копии, другой словарь "увидит" мутацию, потому что два словаря имеют общие объекты. В глубокой копии этого не происходит.

пожалуйста, рассмотрите эту ситуацию объясненной, поэтому вы сможете легко понять метод ссылки и копирования().

    dic = {'data1': 100, 'data2': -54, 'data3': 247}
    dict1 = dic
    dict2 = dic.copy()
    print(dict2 is dic)
    # False
    print(dict1 is dic)
    # true

Первый оператор печати печатает false, потому что dict2 и dic являются двумя отдельными словарями с отдельными пространствами памяти, даже если они имеют одинаковое содержимое. Это происходит, когда мы используем функцию копирования. во-вторых, при назначении dic для dict1 не создается отдельный словарь с отдельными пространствами памяти, вместо этого dict1 ссылается на dic.

Поверхностная копия некоторого контейнера означает, что возвращается новый идентичный объект, но что его значения являются теми же самыми объектами.

Это означает, что изменение значений копии приведет к изменению значений оригинала. В вашем примере вы не изменяете значение, вместо этого вы обновляете ключ.

Вот пример изменения значения.

d = {'a': []}

d_copy = d.copy()

print(d is d_copy) # False
print(d['a'] is d['a']) # True

d['a'].append(1)
print(d_copy) # {'a': [1]}

С другой стороны, глубокая копия контейнера возвращает новый идентичный объект, но значения которого также были рекурсивно скопированы.