Как правильно скопировать список в Python
Ошибки, связанные с копированием списков, относятся к самым коварным в Python: код не падает, а данные молча меняются в неожиданном месте. Причина почти всегда одна: переменная хранит не сам список, а ссылку на него, и "копия" на деле оказывается вторым именем того же объекта. Разберем, как устроены ссылки, чем поверхностная копия отличается от глубокой, какой способ копирования выбрать и откуда берется знаменитая ловушка с [[0] * 3] * 3.

Содержание статьи
Присваивание не копирует список
В Python переменная - это имя, привязанное к объекту. Оператор = не создает новый объект, а привязывает еще одно имя к существующему. Для неизменяемых типов (числа, строки, кортежи) это незаметно, потому что их нельзя изменить на месте. Список изменяем, и все имена, указывающие на него, видят изменения.
a = [1, 2, 3]
b = a # не копия, а второе имя того же списка
b.append(4)
print(a) # -> [1, 2, 3, 4]
print(a is b) # -> True
print(id(a) == id(b)) # -> True
Оператор is проверяет, являются ли два имени одним объектом, а == сравнивает содержимое. Это главный инструмент отладки: если a is b дает True, никакой копии нет. О том, как переменные связаны с объектами, подробнее в статье Переменные и константы в Python.
Ссылки при передаче в функцию
Тот же механизм работает при вызове функции: параметр получает ссылку на переданный список. Если функция меняет список на месте (append, sort, del, присваивание по индексу), изменения видны снаружи.
def add_total(prices):
prices.append(sum(prices))
return prices
cart = [100, 250]
report = add_total(cart)
print(cart) # -> [100, 250, 350] (исходный список изменился)
def add_total_safe(prices):
result = prices.copy()
result.append(sum(result))
return result
Правило хорошего тона: функция, которая возвращает результат, не должна менять входные данные. Если менять нужно, назовите ее так, чтобы это было очевидно, и возвращайте None, как это делает list.sort().
Изменяемое значение по умолчанию
Родственная ошибка: список в качестве значения параметра по умолчанию. Он создается один раз при определении функции и разделяется между всеми вызовами.
def add_item(item, bucket=[]):
bucket.append(item)
return bucket
print(add_item("a")) # -> ['a']
print(add_item("b")) # -> ['a', 'b'] (тот же список)
def add_item_fixed(item, bucket=None):
if bucket is None:
bucket = []
bucket.append(item)
return bucket
Поверхностная копия: copy, срез, list()
Поверхностная (shallow) копия создает новый объект списка и заполняет его ссылками на те же элементы. Сам список новый, его можно менять независимо, а элементы общие. Для списка чисел или строк этого полностью достаточно. Есть несколько равнозначных способов.
import copy
src = [1, 2, 3]
c1 = src.copy() # метод списка, Python 3.3+
c2 = src[:] # срез от начала до конца
c3 = list(src) # конструктор
c4 = [*src] # распаковка
c5 = copy.copy(src) # универсальная функция модуля copy
for c in (c1, c2, c3, c4, c5):
c.append(99)
print(src) # -> [1, 2, 3] (исходный список не тронут)
print(c1 is src) # -> False
Какой из них выбрать? По скорости они практически одинаковы, copy() и срез чуть быстрее остальных. По читаемости лучшим считается lst.copy(): он явно говорит о намерении. Срез lst[:] встречается в старом коде и в учебниках, подробно он разобран в статье срезы в Python. Конструктор list(x) удобен тем, что принимает любой итерируемый объект, например кортеж, множество или генератор, и всегда возвращает именно список.
Где поверхностная копия перестает работать
Проблема появляется, когда элементы списка сами изменяемые: вложенные списки, словари, объекты классов. Копия получает ссылки на те же вложенные объекты, и изменение внутри них видно в обоих списках.
matrix = [[1, 2], [3, 4]]
shallow = matrix.copy()
shallow.append([5, 6]) # меняем сам список-копию
shallow[0][0] = 100 # меняем вложенный список
print(matrix) # -> [[100, 2], [3, 4]]
print(shallow) # -> [[100, 2], [3, 4], [5, 6]]
print(matrix[0] is shallow[0]) # -> True
Добавление нового элемента в копию на оригинал не повлияло, потому что внешние списки разные. А изменение shallow[0][0] затронуло оригинал: оба внешних списка ссылаются на один внутренний [1, 2]. Именно это различие порождает вопросы "почему поменялся исходный список, ведь я его скопировал".
Глубокая копия: copy.deepcopy
Функция copy.deepcopy рекурсивно копирует объект и все вложенные изменяемые объекты. Результат полностью независим от оригинала на любой глубине.
import copy
config = {
"servers": [{"host": "db1", "ports": [5432]}],
"retries": 3,
}
test_config = copy.deepcopy(config)
test_config["servers"][0]["ports"].append(6432)
test_config["servers"][0]["host"] = "test-db"
print(config["servers"])
# -> [{'host': 'db1', 'ports': [5432]}]
print(test_config["servers"])
# -> [{'host': 'test-db', 'ports': [5432, 6432]}]
Несколько деталей, которые полезно знать:
- Неизменяемые объекты (числа, строки, кортежи из неизменяемых элементов) не копируются, а переиспользуются: копировать их нет смысла.
deepcopyкорректно обрабатывает циклические ссылки и повторяющиеся объекты. Внутри он ведет словарьmemoуже скопированных объектов, поэтому если один и тот же список встречается в структуре дважды, в копии он тоже будет одним объектом.- Объекты пользовательских классов копируются вместе с атрибутами. Поведение можно настроить методами
__copy__и__deepcopy__. - Некоторые объекты скопировать нельзя: открытые файлы, сокеты, блокировки потоков. Попытка вызовет
TypeError.
Цена глубокой копии
Глубокое копирование заметно медленнее поверхностного: функция обходит всю структуру на Python-уровне и проверяет тип каждого объекта. На больших структурах разница достигает десятков раз. Не используйте deepcopy "на всякий случай" в горячем коде. Если структура известна, копию часто можно собрать вручную, и это будет быстрее.
matrix = [[1, 2, 3], [4, 5, 6]]
# Для списка списков чисел достаточно копировать один уровень вложенности
fast_copy = [row.copy() for row in matrix]
fast_copy[0][0] = 0
print(matrix) # -> [[1, 2, 3], [4, 5, 6]]
Такой генератор списка копирует внешний список и каждую строку, а числа внутри неизменяемы, поэтому результат независим, как при deepcopy. Синтаксис генераторов списков разобран в статье List comprehension в Python.
Сравнение способов копирования
| Способ | Тип копии | Вложенные объекты | Комментарий |
|---|---|---|---|
b = a | Нет копии | Общие | Второе имя того же списка |
a.copy() | Поверхностная | Общие | Самый читаемый вариант |
a[:] | Поверхностная | Общие | Классическая идиома |
list(a) | Поверхностная | Общие | Принимает любой итерируемый объект |
[*a] | Поверхностная | Общие | Удобно при склейке: [*a, *b] |
copy.copy(a) | Поверхностная | Общие | Работает для любых объектов |
[x.copy() for x in a] | Двухуровневая | Копии первого уровня | Быстро для матриц |
copy.deepcopy(a) | Глубокая | Независимые | Надежно, но медленно |
Ловушка [[0] * 3] * 3
Самая известная ошибка при создании списка списков. Оператор умножения списка повторяет ссылки, а не копирует элементы. Для чисел это безопасно, а для вложенных списков дает несколько ссылок на один и тот же внутренний список.
grid = [[0] * 3] * 3
grid[0][0] = 1
print(grid) # -> [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
print(grid[0] is grid[1]) # -> True
Здесь [0] * 3 создает один список [0, 0, 0], а внешнее * 3 кладет в новый список три ссылки на него. Меняя "первую строку", вы меняете единственную строку, которую видно трижды. Внутреннее [0] * 3 при этом корректно: в нем три ссылки на неизменяемый ноль, и присваивание row[0] = 1 просто заменяет ссылку.
Правильный способ создать список списков - генератор, который на каждой итерации создает новый внутренний список:
grid = [[0] * 3 for _ in range(3)]
grid[0][0] = 1
print(grid) # -> [[1, 0, 0], [0, 0, 0], [0, 0, 0]]
print(grid[0] is grid[1]) # -> False
Та же ловушка встречается в других формах: [[]] * n, [{}] * n, dict.fromkeys(keys, []). Во всех случаях один изменяемый объект разделяется между всеми позициями. Для словаря списков используйте {k: [] for k in keys} или collections.defaultdict(list).
groups = dict.fromkeys(["a", "b"], [])
groups["a"].append(1)
print(groups) # -> {'a': [1], 'b': [1]}
groups = {k: [] for k in ["a", "b"]}
groups["a"].append(1)
print(groups) # -> {'a': [1], 'b': []}
Другие частые ошибки
В этом разделе: изменение списка во время обхода, разница между += и +, кортеж со списком внутри.
Изменение списка во время обхода
Удаление элементов из списка внутри цикла for по этому же списку приводит к пропуску элементов: после удаления индексы сдвигаются, а итератор продолжает со следующей позиции.
nums = [1, 2, 2, 3, 2]
for n in nums:
if n == 2:
nums.remove(n)
print(nums) # -> [1, 3, 2] (одна двойка осталась)
nums = [1, 2, 2, 3, 2]
for n in nums.copy(): # обходим копию, меняем оригинал
if n == 2:
nums.remove(n)
print(nums) # -> [1, 3]
nums = [1, 2, 2, 3, 2]
nums = [n for n in nums if n != 2] # обычно лучше просто собрать новый список
print(nums) # -> [1, 3]
Разница между += и +
Для списков a += b изменяет список на месте (эквивалент a.extend(b)), а a = a + b создает новый список. Если на a есть другие ссылки, результат различается.
a = [1, 2]
alias = a
a += [3]
print(alias) # -> [1, 2, 3] (изменился тот же объект)
a = [1, 2]
alias = a
a = a + [3]
print(alias) # -> [1, 2] (a теперь указывает на новый список)
Кортеж со списком внутри
Кортеж неизменяем, но это касается только ссылок, которые он хранит. Если внутри кортежа лежит список, сам список менять можно. Поэтому кортеж не защищает вложенные данные от изменения, и при передаче такой структуры наружу тоже может понадобиться deepcopy.
t = (1, [2, 3])
t[1].append(4)
print(t) # -> (1, [2, 3, 4])
Копирование объектов собственных классов
Функции модуля copy работают и с экземплярами ваших классов. copy.copy создает новый объект и копирует в него словарь атрибутов поверхностно, то есть атрибут-список останется общим. copy.deepcopy копирует атрибуты рекурсивно. Если стандартное поведение не подходит, определите методы __copy__ и __deepcopy__.
import copy
class Playlist:
def __init__(self, name, tracks):
self.name = name
self.tracks = tracks
def __copy__(self):
# Копия плейлиста получает собственный список треков
return Playlist(self.name, self.tracks.copy())
original = Playlist("Дорога", ["track1", "track2"])
clone = copy.copy(original)
clone.tracks.append("track3")
print(original.tracks) # -> ['track1', 'track2']
print(clone.tracks) # -> ['track1', 'track2', 'track3']
Без метода __copy__ список треков был бы общим, и добавление трека в копию изменило бы оригинал. Для dataclass-классов есть удобная альтернатива: функция dataclasses.replace(obj, **changes) создает новый объект с измененными полями, но копия остальных полей тоже поверхностная.
Защитная копия в классе
Если класс хранит список, полученный извне, и отдает его наружу через метод или свойство, внешний код может изменить внутреннее состояние объекта в обход его логики. Стандартный прием: копировать список при сохранении и при выдаче, либо отдавать неизменяемый кортеж.
class Order:
def __init__(self, items):
self._items = list(items) # копия на входе
@property
def items(self):
return tuple(self._items) # неизменяемое представление на выходе
def add(self, item):
self._items.append(item)
src = ["хлеб"]
order = Order(src)
src.append("молоко")
print(order.items) # -> ('хлеб',)
Такая дисциплина особенно важна в библиотечном коде и в классах, которые хранят настройки: одна случайная мутация общего списка может проявиться далеко от места ошибки.
Когда копия не нужна
Копирование не бесплатно, и делать его везде "для надежности" тоже ошибка. Копия не нужна, если функция только читает список, если вы сразу строите новый список генератором или функцией вроде sorted, map, filter, и если данные состоят из неизменяемых объектов, которые никто не будет менять. Копируйте там, где действительно есть два владельца одних данных и хотя бы один из них их меняет.
Как найти общие объекты при отладке
Когда данные меняются "сами собой", первым делом проверьте, не делят ли две структуры один и тот же вложенный объект. Функция id() возвращает идентификатор объекта, уникальный на время его жизни, а оператор is сравнивает именно идентичность. Небольшая вспомогательная функция быстро покажет, какие элементы копии на самом деле общие с оригиналом.
def shared_items(a, b):
return [i for i, (x, y) in enumerate(zip(a, b)) if x is y and not isinstance(x, (int, str, float, tuple))]
rows = [[1, 2], [3, 4], {"k": 1}]
copy1 = rows.copy()
copy1[1] = [3, 4]
print(shared_items(rows, copy1)) # -> [0, 2]
Неизменяемые значения из проверки исключены: то, что два списка ссылаются на одно и то же число, ни на что не влияет. Подозрительны только общие списки, словари, множества и объекты классов. В отладчике IDE удобно добавить в список наблюдаемых выражений id(obj) для интересующего списка: если идентификатор совпадает в двух местах программы, вы смотрите на один и тот же объект под разными именами. Похожую проверку стоит включать в тесты функций, которые обещают не менять входные данные: сохраните копию входа через deepcopy до вызова и сравните с ней вход после вызова.
Как выбрать способ копирования
- Список простых значений (числа, строки, кортежи из них) -
lst.copy(). - Список списков чисел -
[row.copy() for row in lst]. - Сложная вложенная структура со словарями и списками -
copy.deepcopy. - Нужно передать данные наружу так, чтобы их нельзя было испортить - копия при отдаче или неизменяемые типы (кортеж,
frozenset). - Сомневаетесь, есть ли копия - проверьте
a is bиa[0] is b[0].
Частые вопросы
Несколько вопросов, которые часто задают начинающие, и ответы на них.
В чем разница между copy и deepcopy?
copy создает новый внешний объект, но вложенные объекты остаются общими с оригиналом. deepcopy рекурсивно копирует все вложенные изменяемые объекты, и копия становится полностью независимой. Для плоского списка чисел результаты одинаковы, разница проявляется только при вложенности.
Какой способ копирования списка самый быстрый?
lst.copy() и lst[:] практически равны и чуть быстрее list(lst). copy.deepcopy медленнее в десятки раз, поэтому используйте его только при реальной вложенности.
Как скопировать словарь?
Точно так же: d.copy(), dict(d) или {**d} дают поверхностную копию, copy.deepcopy(d) дает глубокую. Правила для вложенных списков и словарей внутри те же, что и для списков.
Почему tuple(t) и t[:] не создают копию кортежа?
Кортеж неизменяем, поэтому копировать его бессмысленно: Python возвращает тот же объект, и t[:] is t дает True. Для строк поведение такое же.
Как скопировать массив numpy?
Используйте arr.copy(). Срез массива numpy, в отличие от среза списка, возвращает представление (view) на те же данные, и изменения в нем видны в исходном массиве. Подробнее о библиотеке в статье Модуль numpy.