Skip to content

Копирование объектов (copy, deepcopy и их дандер-методы) ​

Когда в Python мы пишем box2 = box1, мы не создаем новый объект. Мы просто вешаем на одну и ту же коробку в памяти второй ярлык (создаем новую ссылку). Если мы изменим содержимое в box2, оно изменится и в box1.

В промышленной разработке часто требуется создать независимый дубликат объекта. Для этого в Python используется стандартный модуль copy. Однако поведение копирования кардинально меняется, если внутри вашего объекта лежат другие составные объекты (например, списки, словари или другие классы).

На этом уроке мы разберем разницу между поверхностным и глубоким копированием, а также научим наши классы управлять этим процессом изнутри.

1. Поверхностное (copy) против Глубокого (deepcopy) ​

Давайте разберем, как Python копирует объекты:

  1. Поверхностное копирование (copy.copy()):

    • Создает новый экземпляр вашего класса.
    • Копирует в него ссылки на все внутренние атрибуты.
    • Проблема: Если атрибутом является изменяемый объект (например, список items), то новая коробка получит ссылку на тот же самый список. Изменение списка в копии изменит его и в оригинале!
  2. Глубокое копирование (copy.deepcopy()):

    • Создает новый экземпляр вашего класса.
    • Рекурсивно обходит все атрибуты и создает абсолютно новые копии для каждого вложенного объекта. Изменения в копии никак не затронут оригинал.

2. Кастомизация копирования через __copy__ и __deepcopy__ ​

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

Чтобы перехватить управление, в Python используются дандер-методы __copy__ и __deepcopy__. Давайте внедрим их в нашу Почтовую Коробку. При глубоком копировании посылки мы должны:

  • Скопировать вещи в абсолютно новый список.
  • Автоматически сгенерировать для новой коробки новый уникальный трек-номер, добавив префикс CLONE-.
python
import copy

class ParcelBox:
    """Класс Почтовой Коробки с кастомной логикой копирования."""

    def __init__(self, tracking_number: str, items: list[str]) -> None:
        self.tracking_number: str = tracking_number
        self.items: list[str] = items  # Список вещей (изменяемый тип)

    def __copy__(self) -> "ParcelBox":
        """Кастомизация поверхностного копирования `copy.copy(box)`."""
        # При поверхностном копировании просто сохраняем старый трек и ссылку на тот же список
        return ParcelBox(self.tracking_number, self.items)

    def __deepcopy__(self, memo: dict) -> "ParcelBox":
        """Кастомизация глубокого копирования `copy.deepcopy(box)`.

        Args:
            memo (dict): Служебный словарь Python для предотвращения 
                бесконечной рекурсии при зацикленных ссылках.
        """
        # 1. Глубоко копируем список вещей, чтобы он стал полностью независимым
        cloned_items = copy.deepcopy(self.items, memo)
        
        # 2. Генерируем уникальный трек-номер для новой коробки-клона
        new_track = f"CLONE-{self.tracking_number}"
        
        # 3. Возвращаем полностью независимый объект
        return ParcelBox(new_track, cloned_items)

    def __repr__(self) -> str:
        return f"ParcelBox(track='{self.tracking_number}', items={self.items})"


# === Проверка работы копирования ===
if __name__ == "__main__":
    original_box = ParcelBox("RU-100", ["Книга", "Чашка"])

    # 1. Демонстрация проблемы поверхностного копирования
    shallow_clone = copy.copy(original_box)
    shallow_clone.items.append("Шарф")
    print(f"Оригинал после shallow: {original_box}")
    # Вывод: items=['Книга', 'Чашка', 'Шарф'] -> Оригинал пострадал!
    
    # Сбросим состояние списка
    original_box.items = ["Книга", "Чашка"]

    # 2. Демонстрация работы нашего кастомного deepcopy
    deep_clone = copy.deepcopy(original_box)
    deep_clone.items.append("Смартфон")
    
    print("\n--- Результат глубокого копирования ---")
    print(f"Оригинал: {original_box}")
    # Вывод: track='RU-100', items=['Книга', 'Чашка'] (Чистый!)
    print(f"Клон:    {deep_clone}")
    # Вывод: track='CLONE-RU-100', items=['Книга', 'Чашка', 'Смартфон'] (Уникальный трек и список!)

Роль аргумента memo в __deepcopy__

При переопределении __deepcopy__ метод обязан принимать второй аргумент (обычно именуемый memo). Это внутренний словарь Python, куда записываются уже скопированные ID объектов. Вы обязаны передавать его во все вложенные вызовы copy.deepcopy(self.attribute, memo), иначе, если ваши объекты ссылаются друг на друга по кругу, программа уйдет в бесконечный цикл и упадет.

Проверьте себя (автопроверка) ​

Выполните каждый блок кода и сравните фактический вывод с ожидаемым, записанным в конце строки комментариями. Класс ParcelBox с кастомными __copy__/__deepcopy__ уже определён в предыдущем разделе урока.

Тест 1. Поверхностная копия разделяет внутренний список:

python
shallow_box = ParcelBox("RU-200", ["Книга"])
shallow_copy = copy.copy(shallow_box)
shallow_copy.items.append("Чашка")
print(shallow_box.items is shallow_copy.items)   # True
print(shallow_box.items)   # ['Книга', 'Чашка'] — оригинал пострадал

Тест 2. Глубокая копия полностью независима и получает новый трек-номер:

python
deep_box = ParcelBox("RU-300", ["Свитер"])
deep_copy = copy.deepcopy(deep_box)
deep_copy.items.append("Шарф")
print(deep_box.items)   # ['Свитер'] — оригинал не тронут
print(deep_copy.tracking_number)   # CLONE-RU-300

Тест 3. Поверхностное копирование сохраняет исходный трек-номер:

python
same_track = copy.copy(deep_box)
print(same_track.tracking_number)   # RU-300
Пояснения к ответам

Тест 1. Кастомный __copy__ передаёт в новую коробку ту же ссылку на список items, поэтому изменение списка через копию видно и в оригинале — классическая проблема поверхностного копирования.

Тест 2. Кастомный __deepcopy__ рекурсивно копирует список (copy.deepcopy(self.items, memo)) и генерирует уникальный трек-номер с префиксом CLONE- — колон полностью независим.

Тест 3. Поверхностное копирование — это «дубликат ярлыка с теми же данными»: трек-номер и содержимое переносятся без изменений.

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

❓Что делает присваивание `box2 = box1`?
❓Что делает поверхностное копирование `copy.copy()`?
❓Что делает `copy.deepcopy()`?
❓Как перехватить управление копированием в своём классе?
❓Зачем `__deepcopy__` обязан принимать аргумент `memo`?
❓Что в примере урока делает `deepcopy` с трек-номером коробки?

Практические упражнения на копирование объектов ​

Выполните эти 5 практических заданий, чтобы научиться безопасно дублировать сложные структуры данных и тонко настраивать логику клонирования в ваших сквозных проектах.

Упражнение 1: Клонирование Римского Калькулятора (RomanCalcCloning) ​

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

Задание: Создайте класс RomanHistory, хранящий список римских строк _history:

  1. Реализуйте метод push(roman_str).
  2. Реализуйте метод __deepcopy__(self, memo). Он должен создавать полностью независимую копию объекта RomanHistory с новым, глубоко скопированным списком истории.
  3. Протестируйте: создайте историю, сделайте deepcopy, добавьте элемент в копию и убедитесь, что в оригинале этот элемент не появился.
python
# Ожидаемое поведение:
# hist1 = RomanHistory()
# hist1.push("V")
#
# hist2 = copy.deepcopy(hist1)
# hist2.push("X")
#
# print(hist1._history)  # Должно остаться: ['V']
# print(hist2._history)  # Должно стать: ['V', 'X']

Упражнение 2: Копирование Накладной Доставки с обнулением подписи (DeliveryInvoice) ​

При оформлении дубликата накладной на почтовом складе (DeliveryInvoice) все основные данные (адрес, список посылок) должны быть скопированы. Однако статус электронной подписи сотрудника is_signed у копии должен автоматически сбрасываться в False, так как копию нужно подписать заново.

Задание: Создайте класс DeliveryInvoice:

  1. Конструктор принимает address: str, items: list[str] и флаг is_signed: bool = True.
  2. Реализуйте метод __deepcopy__(self, memo). Метод должен глубоко скопировать список items, перенести address, но для нового объекта принудительно установить is_signed = False.

Упражнение 3: Поверхностное копирование карточки курьера (CourierBadge) ​

Иногда глубокое копирование избыточно. Для сущности «Бейдж курьера» (CourierBadge) имя сотрудника и название его текущего филиала — это обычные строки (неизменяемый тип). В таком случае достаточно быстрого поверхностного копирования.

Задание: Создайте класс CourierBadge:

  1. Конструктор принимает name: str и branch: str.
  2. Реализуйте метод __copy__(self). Он должен просто возвращать новый объект CourierBadge с теми же самыми значениями.
  3. Добавьте метод __deepcopy__(self, memo), который в данном случае будет просто перенаправлять вызов на __copy__, так как глубокое копирование для простых строк не имеет технического смысла:
python
def __deepcopy__(self, memo):
    return self.__copy__()

Упражнение 4: Глубокое копирование контейнера «Очередь погрузки» (LoadingQueueCopy) ​

Давайте вернемся к нашей очереди конвейерной ленты LoadingQueue (ADT Очередь). Если логист хочет разветвить поток посылок на две разные машины, ему нужно сделать полную копию текущей очереди.

Задание: Создайте класс LoadingQueue, содержащий список _queue:

  1. Реализуйте методы enqueue(item) и вывод __repr__.
  2. Реализуйте __deepcopy__(self, memo), который создает новый объект LoadingQueue, содержащий глубокую копию списка посылок.

Упражнение 5: Защита уникального сейфа от клонирования (UnclonableSafe) ​

В целях безопасности некоторые объекты в системе (например, главный цифровой сейф почтовых отправлений UnclonableSafe) строго запрещено копировать любыми способами. Попытка вызвать copy() или deepcopy() должна немедленно пресекаться вызовом ошибки.

Задание: Создайте класс UnclonableSafe:

  1. Переопределите методы __copy__(self) и __deepcopy__(self, memo).
  2. Внутри обоих методов вместо возврата объекта напишите инструкцию raise RuntimeError("Критическая ошибка безопасности: данный объект запрещено копировать!").
  3. Убедитесь, что при попытке скопировать сейф программа выбрасывает ошибку.
python
# Ожидаемое поведение:
# safe = UnclonableSafe()
# copy.copy(safe)  # raise RuntimeError: Критическая ошибка безопасности...

Решения для самопроверки ​

Посмотреть решение Упражнения 1 (RomanHistory)
python
import copy

class RomanHistory:
    def __init__(self) -> None:
        self._history: list[str] = []

    def push(self, roman_str: str) -> None:
        self._history.append(roman_str)

    def __deepcopy__(self, memo: dict) -> "RomanHistory":
        cloned_obj = RomanHistory()
        # Глубоко копируем вложенный изменяемый список
        cloned_obj._history = copy.deepcopy(self._history, memo)
        return cloned_obj

# Демонстрация:
hist1 = RomanHistory()
hist1.push("V")
hist2 = copy.deepcopy(hist1)
hist2.push("X")
print(hist1._history)   # ['V']
print(hist2._history)   # ['V', 'X']
Посмотреть решение Упражнения 2 (DeliveryInvoice)
python
import copy

class DeliveryInvoice:
    def __init__(self, address: str, items: list[str], is_signed: bool = True) -> None:
        self.address: str = address
        self.items: list[str] = items
        self.is_signed: bool = is_signed

    def __deepcopy__(self, memo: dict) -> "DeliveryInvoice":
        # Глубоко копируем список предметов
        new_items = copy.deepcopy(self.items, memo)
        # Возвращаем новую накладную, принудительно сбрасывая подпись в False
        return DeliveryInvoice(self.address, new_items, is_signed=False)

# Демонстрация:
invoice = DeliveryInvoice("Минск, ул. 1-я, 1", ["Посылка 1"], is_signed=True)
clone_invoice = copy.deepcopy(invoice)
print(invoice.is_signed, clone_invoice.is_signed)   # True False
print(clone_invoice.items is invoice.items)   # False — независимый список
Посмотреть решение Упражнения 3 (CourierBadge)
python
class CourierBadge:
    def __init__(self, name: str, branch: str) -> None:
        self.name: str = name
        self.branch: str = branch

    def __copy__(self) -> "CourierBadge":
        return CourierBadge(self.name, self.branch)

    def __deepcopy__(self, memo: dict) -> "CourierBadge":
        # Перенаправляем на __copy__, так как вложенных изменяемых объектов нет
        return self.__copy__()

# Демонстрация:
badge = CourierBadge("Алиса", "Филиал Северный")
badge_copy = copy.copy(badge)
print(badge_copy.name, badge_copy.branch)   # Алиса Филиал Северный
print(copy.deepcopy(badge) is badge_copy)   # False — deepcopy тоже создает новый объект
Посмотреть решение Упражнения 4 (LoadingQueue)
python
import copy

class LoadingQueue:
    def __init__(self) -> None:
        self._queue: list[str] = []

    def enqueue(self, item: str) -> None:
        self._queue.append(item)

    def __deepcopy__(self, memo: dict) -> "LoadingQueue":
        new_queue_obj = LoadingQueue()
        new_queue_obj._queue = copy.deepcopy(self._queue, memo)
        return new_queue_obj

# Демонстрация:
lq = LoadingQueue()
lq.enqueue("Посылка 1")
lq.enqueue("Посылка 2")
lq_copy = copy.deepcopy(lq)
lq_copy.enqueue("Посылка 3")
print(len(lq._queue), len(lq_copy._queue))   # 2 3 — потоки разветвлены
Посмотреть решение Упражнения 5 (UnclonableSafe)
python
class UnclonableSafe:
    def __copy__(self) -> None:
        raise RuntimeError("Критическая ошибка безопасности: данный объект запрещено копировать!")

    def __deepcopy__(self, memo: dict) -> None:
        raise RuntimeError("Критическая ошибка безопасности: данный объект запрещено копировать!")

# Демонстрация:
safe = UnclonableSafe()
try:
    copy.copy(safe)
except RuntimeError as err:
    print(err)   # Критическая ошибка безопасности: данный объект запрещено копировать!
try:
    copy.deepcopy(safe)
except RuntimeError as err:
    print(err)

Перед завершением урока убедитесь, что вы твердо усвоили: • Обычное присваивание a = b не копирует объект, а лишь дублирует ссылку на него в памяти. • Поверхностное копирование создает новый объект, но оставляет общими все вложенные изменяемые структуры (списки, словари). • Метод __deepcopy__ обязан принимать аргумент memo и передавать его во все дочерние вызовы copy.deepcopy().