Копирование: присваивание не копирует ничего, copy — один уровень, deepcopy — граф целиком

База: три операции на четырёх строках

Весь урок вырастает из четырёх строк кода. Стоит выписать их целиком и один раз посмотреть, что каждая делает.

import copy
 
a = [[1, 2], [3]]         # список, внутри которого лежат другие списки
b = a                     # присваивание
c = copy.copy(a)          # поверхностная копия
d = copy.deepcopy(a)      # глубокая копия

Пока ничего не меняли, все четыре имени показывают на одинаковое содержимое, и == между ними даёт True во всех сочетаниях. Разница появляется ровно в один момент — когда меняют вложенный объект, а не верхний:

a[0].append(99)           # меняем список, лежащий ВНУТРИ
 
b[0]                      # [1, 2, 99] — b и есть a, другого объекта не появилось
c[0]                      # [1, 2, 99] — верхний список новый, а вложенный тот же
d[0]                      # [1, 2]     — у глубокой копии свой вложенный список

Три разных ответа на одно изменение. Читать их стоит так:

• b = a не создаёт объекта вовсе: это второе имя для того же списка;
• c — новый верхний список, но внутри у него те же самые вложенные списки, что и у a;
• d — новый верхний список, у которого и вложенные тоже новые.

И вот главный вопрос урока: на плоском списке эти три операции неотличимы — так до какой глубины на самом деле доходит каждая? Ответ уровня «база»: присваивание — ни до какой, поверхностная копия — до первого уровня, глубокая — дальше него.

Этого уже достаточно, чтобы ответить на базовый вопрос собеседования. Всё дальнейшее — про то, где проходит граница «дальше него»: что глубокая копия делает с объектом, который встретился ей дважды, что бывает со структурой, ссылающейся сама на себя, чего не копирует ни та ни другая операция и почему конструктор при копировании не вызывается ни разу.

Механизм 1: присваивание не копирует

Это первое место, где путаница начинается, и оно же самое простое. b = a не создаёт никакого нового объекта — появляется второе имя для одного и того же.

Проверяется одной строкой:

a = [1, 2, 3]
b = a
b.append(4)
print(a)        # [1, 2, 3, 4]
print(b is a)   # True

Отсюда правило, к которому всё сведётся: вопрос «копия или не копия» — это всегда вопрос про is, а не про ==. Равенство здесь ничего не различает: у оригинала, поверхностной и глубокой копии == даёт True во всех трёх случаях.

Механизм 2: один уровень — и что это значит

Определения из документации отличаются ровно одним словом, и это слово стоит прочитать буквально.

Ссылки против копий. Всё остальное — следствия.

Переключите на картинке случай «общий объект»: у глубокой копии inner окажется один на две ячейки. Потом «цикл»: у поверхностной единственная ячейка покажет на оригинал, а не на себя.

Поверхностную копию делают четырьмя способами, и все четыре — одно и то же:

b = a[:]
b = list(a)
b = a.copy()
b = copy.copy(a)

Разница между ними в пределах семи процентов на том же списке из тысячи записей — то есть её нет. А вот пятый способ, который часто пишут «заодно», обходится в 5,8 раза дороже остальных:

b = [x for x in a]      # 13,7 мкс против 2,3–2,5 мкс у остальных четырёх

Причина не в копировании: включение выполняет отдельный шаг цикла на каждый элемент, а a[:] и list(a) копируют массив указателей целиком.

Классическая ловушка отсюда же — повторение списка:

grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid)     # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

Внешнее * 3 не создало три строки. Оно создало три ссылки на одну строку — ровно то же, что делает поверхностная копия, только записанное короче.

Механизм 3: глубокая копия строит копию графа, а не обходит ссылки поодиночке

Вот место, где почти все объяснения врут. «Глубокая копия копирует всё дерево» и «копирует всё подряд» — неверно, и неверно дважды: во-первых, у структуры может не быть формы дерева вовсе, во-вторых, копируется не каждая встреченная ссылка. Точнее так: глубокая копия строит копию графа объектов, спрашивая у каждого встреченного объекта, как его копировать, и запоминая уже скопированное. Первое — протокол копирования: для каждого типа находится способ, а объект может и перехватить его сам. Второе — таблица, с которой deepcopy сверяется на каждом объекте.

Из этой формулировки сразу следуют два свойства, которые из «копирует всё дерево» не следуют никак: общий объект остаётся общим и в копии, а цикл не уводит копирование в бесконечность.

Решение названо там же — keeping a memo dictionary of objects already copied during the current copying pass (ведением словаря memo объектов, уже скопированных в текущем проходе копирования).

Что из этого следует на практике:

shared = {"config": 1}
orig = {"a": shared, "b": shared}
deep = copy.deepcopy(orig)
 
print(orig["a"] is orig["b"])       # True — один объект на два ключа
print(deep["a"] is deep["b"])       # True — и в копии он тоже ОДИН
print(deep["a"] is orig["a"])       # False — но уже другой

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

Ту же таблицу можно заполнить заранее — и тем самым запретить копировать конкретный объект:

memo = {id(shared): shared}
kept = copy.deepcopy(orig, memo)
print(kept["a"] is shared)          # True

Это способ сказать «скопируй всё, кроме вот этого», не трогая сами классы: второй аргумент deepcopy для того и открыт. Второй способ — перехват __deepcopy__, и он разобран ниже.

И тот же memo — причина, по которой цикл переживает копирование:

a = []
a.append(a)
 
s = copy.copy(a)
d = copy.deepcopy(a)
 
print(s[0] is a, s[0] is s)     # True  False
print(d[0] is a, d[0] is d)     # False True

Поверхностная копия списка, который содержал сам себя, сама себя не содержит: её единственная ячейка показывает на оригинал. Циклической структуры больше нет, хотя копировали именно её. Глубокая — цикл сохранила.

Механизм 4: чего не копирует ни та ни другая

Список назван в документации явно.

И здесь же — расхождение, которое каждый раз выглядит как ошибка интерпретатора:

Неизменяемость тут ни при чём. В Lib/copy.py два разных набора атомарных типов: у copy в нём есть tuple, frozenset, slice и super, у deepcopy — нет. frozenset и slice из-за этого идут длинным путём через __reduce_ex__, и deepcopy строит новый объект. Кортеж — отдельный случай, о нём сразу ниже. Результат одинаков на 3.11, 3.12, 3.13 и 3.14.7.

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

Механизм 5: __init__ не вызывается

Это следствие, о котором узнают поздно и дорого.

class Connection:
    def __init__(self, dsn):
        self.dsn = dsn
        self.socket = open_socket(dsn)
 
c1 = Connection("postgres://…")
c2 = copy.copy(c1)
c3 = copy.deepcopy(c1)

Ни одна из копий не вызывает __init__ — ноль вызовов на две копии, проверено счётчиком. Обе идут через __reduce_ex__ и восстанавливают __dict__ напрямую. Значит:

• проверки аргументов, стоящие в конструкторе, не выполняются;
• ресурсы, которые конструктор открывает, не открываются — они копируются как обычные поля. У поверхностной копии сокет тот же самый. Глубокая исключения для него не делает: она пытается скопировать сокет как обычное поле, и на настоящем сокете это обычно кончается ошибкой. Ровно поэтому документация и перечисляет такие типы отдельно.

Если у объекта есть что-то, чего копировать нельзя, перехват пишется руками:

class Connection:
    def __deepcopy__(self, memo):
        new = Connection.__new__(Connection)
        memo[id(self)] = new                       # ДО обхода полей
        new.dsn = copy.deepcopy(self.dsn, memo)    # memo передаётся дальше
        new.socket = open_socket(new.dsn)
        return new

Две строчки здесь неочевидны, и обе документированы. Запись в memo до обхода полей — иначе объект, ссылающийся на себя, уйдёт в бесконечную рекурсию. И передача memo вторым аргументом: 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 (Если реализации __deepcopy__ нужно сделать глубокую копию составной части, она должна вызвать функцию deepcopy(), передав эту часть первым аргументом, а словарь memo — вторым). Без второго аргумента разваливается ровно то, ради чего таблица и заведена.

Копирование — не восстановление инварианта

Отсюда следует практическое правило, которое стоит произносить целиком: копия — это снимок полей, а не заново собранный объект. Всё, за что отвечал конструктор — проверка dsn, открытый сокет, зарегистрированный обработчик, — в копии либо отсутствует, либо разделено с оригиналом.

Поэтому у deepcopy есть соседи, которые часто оказываются нужнее. Это не замены — они решают другие задачи, и выбирают между ними по задаче, а не по цене:

deepcopy остаётся там, где нужен именно снимок графа со всеми его внутренними связями — и там ему замены нет.

Глубже: что это стоит

Из картинки следует не «берите pickle», а два правила.

Запись в замере — это {"id": i, "tags": ["a", "b"], "meta": {"x": i}}: три уровня и четыре объекта на запись, то есть четыре тысячи объектов на тысячу записей. Отсюда и ×1809 — то есть это множитель для такой формы данных, а не свойство глубокой копии вообще: на другой форме он будет другим. Переносить стоит не его, а зависимость, из которой он получился.

Первое: цена глубокой копии растёт по числу объектов, а не по объёму данных. Десять тысяч чисел в списке копируются за 2,3 мс, десять тысяч списков по одному числу — за 10 мс. Чисел столько же, объём почти тот же; во втором случае прибавились десять тысяч списков, которые надо обойти и создать заново. Сами int не копируются вовсе — они атомарны и возвращаются как есть.

Второе: глубокая копия рекурсивна. На вложенности 498 при стандартном sys.getrecursionlimit() == 1000 она падает с RecursionError — то есть тратит два кадра стека на уровень. Дерево из пятисот уровней скопировать не получится, и выясняется это уже на боевом сервере.

Отдельно про быстрые замены. pickle туда-обратно быстрее глубокой копии в 5,8 раза — это другое сравнение, чем «включение против среза» выше, отношение просто совпало. Он сохраняет и общность объектов, и циклы, но требует, чтобы объект пиклился, — а сокет, файл и замыкание не пиклятся. json быстрее в 2,7 раза и молча меняет типы: {1: (2, 3)} возвращается как {'1': [2, 3]}, а на цикле падает с ValueError. Ручное копирование по известной форме быстрее в 14,2 раза ровно потому, что форма вписана в него руками — и живёт до первого нового поля.

Как отвечать на собеседовании

Короткий ответ: присваивание не копирует ничего — это второе имя для того же объекта; copy.copy создаёт новый верхний объект и оставляет вложенные общими; copy.deepcopy добирается и до вложенных. Разница видна только тогда, когда меняют вложенный объект: после поверхностной копии изменение видно через обе стороны, после глубокой — нет.

Этого достаточно, чтобы ответить верно. Дальше — то, что добавляют, если собеседник копает.

Если интервьюер копает глубже

Точная формулировка про глубокую копию звучит не как «копирует всё дерево», а как «строит копию графа объектов по протоколу копирования, запоминая уже скопированные». Отсюда сразу два свойства, ради которых её и уточняют: цикл не уводит копирование в бесконечность, а объект, лежавший под двумя ключами, остаётся одним и в копии — deep["a"] is deep["b"] даёт True.

И три вещи, которые редко называют, а стоят они дороже всего: __init__ не вызывается ни разу; deepcopy рекурсивна и ограничена пределом стека; цена считается по числу объектов внутри, а не по объёму данных.

Дальше спросят

Частые заблуждения

История версий

Практика

Две задачи. Сначала ответьте, потом сверьтесь с настоящим выводом: в обеих правильный ответ взят из прогона скрипта, а не назначен.

import copy

inner = {"n": 1}
outer = {"a": inner, "b": inner}
deep = copy.deepcopy(outer)
shallow = copy.copy(outer)

print(deep["a"] is deep["b"])
print(deep["a"] is inner)
print(shallow["a"] is inner)

True
False
True

False
False
True

True
True
True

False
False
False

Проверьте себя

Чем измерено

Числа этой статьи получены этими скриптами. Каждый открывается прямо отсюда — вместе с записью прогона: на чём считали, что получилось и с каким разбросом.

• bench/copy/cost.py
• bench/copy/graph.py