Б41 Чистый Python. Тонкости программирования для профи. Спб.: Питер

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

---

4 .4 . Клонирование объектов для дела и веселья 119
Глубокая копия (deep copy) выполняет процесс копирования рекурсивно. 
Это означает конструирование сначала нового объекта коллекции, а за-
тем рекурсивное его заполнение копиями дочерних объектов, найденных 
в оригинале. При копировании объекта таким способом выполняется об-
ход всего дерева объектов целиком, и создается полностью независимый 
клон исходного объекта и всех его потомков.
Понимаю, что это была довольно заумная тирада. Поэтому обратимся 
к нескольким примерам, которые доведут до сознания разницу между 
глубокими и мелкими копиями.
Создание мелких копий
В приведенном ниже примере мы создадим новый вложенный список 
и затем мелко его скопируем при помощи фабричной функции 
list()
:
>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
>>> ys = list(xs) # Сделать мелкую копию 
Это означает, что список 
ys
теперь будет новым и независимым объектом 
с тем же самым содержимым, что и список 
xs
. Это можно проверить, про-
инспектировав оба объекта:
>>> xs 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
>>> ys 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Чтобы подтвердить, что список 
ys
действительно независим от ориги-
нала, давайте разработаем маленький эксперимент. Можно попробовать 
добавить новый подсписок в оригинал (
xs
) и затем убедиться, что эта 
модификация не затронула копию (
ys
):
>>> xs.append(['новый подсписок']) 
>>> xs 
[[1, 2, 3], [4, 5, 6], [7, 8, 9], ['новый подсписок']] 
>>> ys 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

---

120 Глава 4 • Классы и ООП
Как видите, эффект был ожидаем. С изменением скопированного списка 
на «поверхностном» уровне никаких проблем не возникло.
Однако поскольку мы создали лишь мелкую копию оригинального спи-
ска, список 
ys
по-прежнему содержит ссылки на оригинальные дочерние 
объекты, хранящиеся в 
xs
.
Эти дочерние элементы не были скопированы. Все свелось к тому, что 
в скопированном списке на них снова содержатся ссылки.
Поэтому, когда вы модифицируете один из дочерних объектов в спи-
ске 
xs
, эта модификация также будет отражена в списке 
ys
— таким 
образом, оба списка совместно используют одинаковые дочерние объек-
ты. Эта копия представляет собой всего лишь мелкую копию с одним 
уровнем в глубину:
>>> xs[1][0] = 'X' 
>>> xs 
[[1, 2, 3], ['X', 5, 6], [7, 8, 9], ['новый подсписок']] 
>>> ys 
[[1, 2, 3], ['X', 5, 6], [7, 8, 9]]
В примере выше мы (казалось бы) изменили только список 
xs
. Но ока-
зывается, что в индексе 
1
списков 
xs
и 
ys
были изменены оба подсписка. 
Опять-таки, это произошло, потому что мы создали всего-навсего мелкую 
копию оригинального списка.
Если бы на первом шаге мы создали глубокую копию списка 
xs
, то оба объ-
екта были бы полностью независимы. В этом и заключается практическая 
разница между мелкими и глубокими копиями объектов.
Теперь вы знаете, как создавать мелкие копии некоторых встроенных 
классов коллекций, и знаете разницу между мелким и глубоким копиро-
ванием. Вопросы, ответы на которые мы по-прежнему хотим получить, 
следующие:
‰
‰
Как создавать глубокие копии встроенных коллекций?
‰
‰
Как создавать копии (мелкие и глубокие) произвольных объектов, 
включая собственные классы?

---

4 .4 . Клонирование объектов для дела и веселья 121
Ответы на эти вопросы лежат в модуле 
copy
стандартной библиотеки 
Python. Этот модуль обеспечивает простой интерфейс для создания мел-
ких и глубоких копий произвольных объектов Python.
Создание глубоких копий
Давайте повторим предыдущий пример с копированием списка, но с од-
ним важным различием. В этот раз мы собираемся создать глубокую 
копию, используя вместо встроенной фабричной функции функцию 
deepcopy()
, определенную в модуле 
copy
:
>>> import copy 
>>> xs = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
>>> zs = copy.deepcopy(xs) 
Когда вы проинспектируете список 
xs
и его клон 
zs
, созданный нами 
с помощью 
copy.deepcopy()
, вы увидите, что они оба снова выглядят 
идентичными— точно так же, как и в предыдущем примере:
>>> xs 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
>>> zs 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Однако если вы внесете модификацию в один из дочерних объектов в ори-
гинальном объекте (
xs
), то вы увидите, что эта модификация не затронет 
глубокую копию (
zs
).
Оба объекта, оригинал и копия, на этот раз полностью независимы. Спи-
сок 
xs
был клонирован рекурсивно, включая все его дочерние объекты:
>>> xs[1][0] = 'X' 
>>> xs 
[[1, 2, 3], ['X', 5, 6], [7, 8, 9]] 
>>> zs 
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Возможно, вам стоит сделать паузу, чтобы обратиться к интерпретатору 
Python и прямо сейчас выполнить все эти примеры. Усвоить копирование 

---

122 Глава 4 • Классы и ООП
объектов легче, когда вы имеете возможность набраться опыта и поэкспе-
риментировать с примерами из первых рук.
Между прочим, при помощи функции в модуле 
copy
вы также можете 
создавать мелкие копии. Функция 
copy.copy()
создает мелкие копии 
объектов.
Это полезно, если вам нужно четко сообщить, что где-то в своем про-
граммном коде вы создаете мелкую копию. Использование 
copy.copy()
позволяет указывать на этот факт. Однако что касается встроенных 
коллекций, то для создания их мелких копий более питоновским стилем 
будет считаться использование фабричных функций 
list
, 
dict
и 
set
.
Копирование произвольных объектов
Вопрос, на который мы по-прежнему должны ответить, состоит в том, как 
создавать копии (мелкие и глубокие) произвольных объектов, включая 
собственные классы. Теперь давайте обратимся к этому вопросу.
И снова на выручку приходит модуль 
copy
. Его функции 
copy.copy()
и 
copy.deepcopy()
могут использоваться для создания дубликата любого 
объекта.
И снова наилучший способ понять, как их использовать, — поставить 
простой эксперимент. Я собираюсь взять за основу предыдущий пример 
с копированием списка. Давайте начнем с определения простого класса 
двумерной точки:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f'Point({self.x!r}, {self.y!r})'
Надеюсь, вы согласитесь, что это было довольно прямолинейно. Я добавил 
реализацию 
__repr__()
, с тем чтобы мы могли легко проинспектировать 
создаваемые на основе этого класса объекты в интерпретаторе Python.

---

4 .4 . Клонирование объектов для дела и веселья 123
Далее мы создадим экземпляр 
Point
, а затем его (мелко) скопируем, ис-
пользовав модуль 
copy
:
>>> a = Point(23, 42) 
>>> b = copy.copy(a) 
Если проинспектировать содержимое оригинального объекта 
Point
и его 
(мелкого) клона, то мы увидим то, что и ожидали:
>>> a 
Point(23, 42) 
>>> b 
Point(23, 42) 
>>> a is b 
False
Следует иметь в виду кое-что еще. Поскольку наш объект-точка для сво-
их координат использует примитивные типы (целые числа), то в данном 
случае нет никакой разницы между мелкой и глубокой копией. Но я рас-
ширю пример секунду спустя.
Теперь перейдем к более сложному примеру. Я собираюсь определить еще 
один класс, который будет представлять двумерные прямоугольники. 
Я сделаю это таким образом, который позволяет создавать более сложную 
иерархию объектов, — мои прямоугольники будут использовать объекты 
Point
, представляющие их координаты:
class Rectangle:
def __init__(self, topleft, bottomright):
self.topleft = topleft
self.bottomright = bottomright
def __repr__(self):
return (f'Rectangle({self.topleft!r},'
f'{self.bottomright!r})')
Сначала мы попытаемся создать мелкую копию экземпляра 
Rectangle
:
rect = Rectangle(Point(0, 1), Point(5, 6)) 
srect = copy.copy(rect)

---

124 Глава 4 • Классы и ООП
Если вы проинспектируете оригинальный прямоугольник и его копию, 
то увидите, что переопределение метода 
__repr__()
прекрасно сработало 
и процесс мелкого копирования был выполнен, как мы и ждали:
>>> rect 
Rectangle(Point(0, 1), Point(5, 6)) 
>>> srect 
Rectangle(Point(0, 1), Point(5, 6)) 
>>> rect is srect 
False
Помните, как в предыдущем примере со списком иллюстрировалась 
разница между глубокими и мелкими копиями? Здесь я собираюсь при-
менить тот же самый подход. Я изменю объект, находящийся глубоко 
в иерархии объектов, и затем вы вновь увидите, как это изменение будет 
отражено в (мелкой) копии:
>>> rect.topleft.x = 999 
>>> rect 
Rectangle(Point(999, 1), Point(5, 6)) 
>>> srect 
Rectangle(Point(999, 1), Point(5, 6))
Надеюсь, что этот пример показал то, что вы ожидали. Далее, я создам 
глубокую копию оригинального прямоугольника. Затем внесу в нее одно 
изменение, и вы увидите, какие объекты были затронуты:
>>> drect = copy.deepcopy(srect) 
>>> drect.topleft.x = 222 
>>> drect 
Rectangle(Point(222, 1), Point(5, 6)) 
>>> rect
Rectangle(Point(999, 1), Point(5, 6)) 
>>> srect 
Rectangle(Point(999, 1), Point(5, 6))
Вуаля! На этот раз глубокая копия (
drect
) полностью независима от 
оригинала (
rect
) и мелкой копии (
srect
).
В этом разделе мы рассмотрели многие вопросы, и при этом остались еще 
некоторые тонкости, связанные с копированием объектов.

---

4 .5 . Абстрактные базовые классы держат наследование под контролем 125
Эта тема стоит того, чтобы в нее углубиться (еще бы!), поэтому, возмож-
но, вам стоит плотнее заняться документацией модуля 
copy
1
. Например, 
объекты могут управлять тем, как они копируются, если в них определить 
специальные методы 
__copy__()
и 
__deepcopy__()
. Приятного времяпре-
провождения!
Ключевые выводы
‰
‰
В результате создания мелкой копии объекта дочерние объекты не 
клонируются. По этой причине результирующая копия не является 
полностью независимой от оригинала.
‰
‰
В процессе глубокого копирования объекта дочерние объекты клони-
руются рекурсивно. Клон полностью независим от оригинала, но на 
создание глубокой копии уходит больше времени.
‰
‰
При помощи модуля 
copy
вы можете копировать произвольные объ-
екты (включая собственные классы).
4 .5 . Абстрактные базовые классы держат 
наследование под контролем
Абстрактные классы (АК), иногда также называемые абстрактными ба-