Телеграм канал «Постоянный репозиторий по Python»

Почему copy() и deepcopy() – это не одно и то же

Очень частая ситуация: нужно скопировать список или структуру данных.

Пишут так:

import copy
original = [[1, 2], [3, 4]]
# два способа копирования
shallow = original.copy() # поверхностная копия
deep = copy.deepcopy(original) # глубокая копия
# меняем вложенный элемент
shallow[0][0] = 999
print("original:", original)
print("shallow:", shallow)
print("deep:", deep)

Ожидание у многих такое:
• изменится только shallow
• original останется нетронутым

Но реальность другая 👇

original: [[999, 2], [3, 4]] ❗️
shallow: [[999, 2], [3, 4]]
deep: [[1, 2], [3, 4]]

Что произошло?

copy() создаёт новый внешний список, но внутренние объекты остаются теми же.
То есть:
• original и shallow – разные списки
• но их вложенные списки – одни и те же объекты в памяти

Поэтому изменение внутри «протекает» обратно.

В чём разница на уровне идеи

• copy() → копирует только верхний уровень
• deepcopy() → копирует всё рекурсивно

Когда это становится проблемой

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

Как выбрать правильно

• если структура плоская → можно copy()
• если есть вложенность → почти всегда нужен deepcopy()
• если сомневаешься → лучше явно проверить

Полезный лайфхак

Если хочешь быстро понять, есть ли общие ссылки:
print(original[0] is shallow[0]) # True → один и тот же объект

Главное правило

Если в данных есть вложенные изменяемые объекты – поверхностная копия почти всегда приведёт к багам.

Вывод

Python не копирует «значения», он копирует ссылки на объекты.
И пока это не понимаешь – такие баги неизбежны.

Почему список списков через * может сломать вам всю логику
На первый взгляд этот код выглядит абсолютно нормально:
# хотим создать таблицу 3x3, заполненную нулями
matrix = [[0] * 3] * 3

# меняем один элемент
matrix[0][1] = 7

print(matrix)
Многие ожидают такой результат:
[[0, 7, 0],
[0, 0, 0],
[0, 0, 0]]
Но на деле получится:
[[0, 7, 0],
[0, 7, 0],
[0, 7, 0]]
И вот это уже выглядит как магия.
Хотя на самом деле это просто особенность ссылок в Python.

Что здесь происходит?
Проблема в этой строке:
matrix = [[0] * 3] * 3
Кажется, будто Python создаёт три независимых списка.
Но нет.

Он создаёт один внутренний список и затем повторяет ссылку на него три раза.
То есть все строки матрицы указывают на один и тот же объект в памяти.
Поэтому изменение одного элемента фактически меняет сразу все «строки».

Как создать матрицу правильно
Нужно, чтобы каждая строка создавалась отдельно:
matrix = [[0] * 3 for _ in range(3)]

matrix[0][1] = 7
print(matrix)
Теперь результат будет корректным:
[[0, 7, 0],
[0, 0, 0],
[0, 0, 0]]
Потому что каждая строка — это уже свой собственный список.

Почему это опасно?
Такая ошибка особенно неприятна, когда вы работаете с:
• двумерными массивами
• динамическим программированием
• таблицами состояний
• игровыми полями
• сетками, картами, матрицами
Код может выглядеть правильно, но логика начнёт ломаться в самых неожиданных местах.
Особенно часто это всплывает в задачах на алгоритмы.

Как быстро запомнить
Если внутри структура изменяемая, то конструкция через * может быть опасной.
То есть вот так:
[ [0] * 3 ] * 3
— подозрительно.
А вот так:
[ [0] * 3 for _ in range(3) ]
— безопасно.

Главное правило
Оператор * хорошо подходит для простых списков,
но плохо подходит для вложенных изменяемых структур.
Именно поэтому матрицы через умножение списков — классическая ловушка Python.

🐍 .loc vs .iloc в pandas – почему это важно понимать

Очень частая ситуация: нужно выбрать данные из таблицы.

И тут начинается магия (и ошибки)

Как обычно делают
import pandas as pd

df = pd.DataFrame({
"name": ["Alice", "Bob", "Charlie"],
"score": [85, 92, 78]
}, index=[10, 20, 30])

И дальше кто-то пишет:

df.loc[0]

И получает… ошибку
В чём разница?

👉 .loc – работает с метками (labels)
👉 .iloc – работает с позициями (индексами)

Разберём на примере
# доступ по индексу (метке)
df.loc[10]

Вернёт строку с индексом 10.
# доступ по позиции
df.iloc[0]
Вернёт первую строку, независимо от значения индекса.

Где чаще всего ошибаются
Когда индекс не 0,1,2…, а, например:
• ID пользователей
• даты
• кастомные значения
df.loc[0] # ❌ может не существовать
df.iloc[0] # ✔️ первая строка

Ещё один важный момент
Срезы работают по-разному:
df.loc[10:20] # включает 20
df.iloc[0:2] # НЕ включает 2
Это тоже часто ломает логику.

Как запомнить
• .loc → логика данных (label)
• .iloc → логика позиции (index)

Когда что использовать?

✔️ .loc:
• работаешь с реальными ID
• фильтруешь по значениям индекса
• пишешь читаемый аналитический код

✔️ .iloc:
• нужен доступ по позиции
• работаешь как с массивом
• делаешь быстрые прототипы

Вывод
Если путаешь .loc и .iloc – рано или поздно словишь очень неприятный баг.
Это не синтаксис — это логика работы с данными.