Обновили pandas, и ноутбук работает без ошибок. Только считает уже другое. Copy-on-Write.. Copy-on-Write. pandas.. Copy-on-Write. pandas. pandas 3.0.. Copy-on-Write. pandas. pandas 3.0. python.. Copy-on-Write. pandas. pandas 3.0. python. анализ данных.. Copy-on-Write. pandas. pandas 3.0. python. анализ данных. индексация DataFrame.. Copy-on-Write. pandas. pandas 3.0. python. анализ данных. индексация DataFrame. миграция библиотек.. Copy-on-Write. pandas. pandas 3.0. python. анализ данных. индексация DataFrame. миграция библиотек. обработка данных.. Copy-on-Write. pandas. pandas 3.0. python. анализ данных. индексация DataFrame. миграция библиотек. обработка данных. пропущенные значения.. Copy-on-Write. pandas. pandas 3.0. python. анализ данных. индексация DataFrame. миграция библиотек. обработка данных. пропущенные значения. типы данных.

pandas 3.0.0 вышел 21 января 2026 года, и к осени он попал почти в каждое новое окружение: pip install pandas без версии ставит его.

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

Потом кто‑то сравнивает выгрузку с прошлым месяцем, и цифры не сходятся.

Разработчики предупредили о двух главных изменениях:

  • Copy‑on‑Write стал единственным режимом.

  • Строки по умолчанию получили отдельный тип str.

Обе вещи давно обсуждались, но в ноутбуках живёт код, написанный в эпоху pandas 1.x, и он полагался на старое поведение, о котором никто не думал.

Все примеры дальше проверены на pandas 3.0.5, и большая часть из них ломается по сути молча.

Ни исключения, ни остановки, только предупреждение, которое в половине ноутбуков отключено первой же ячейкой.

Присваивание, которое ничего не присваивает

Такую строку писал каждый, кто работал с pandas больше недели:

df["price"][df["price"] > 200] = 0

Сначала берём столбец, потом маской выбираем строки и присваиваем. В pandas 2.x это работало, потому что df["price"] чаще всего возвращал представление, и запись проходила в исходную таблицу.

В pandas 3.0 любой результат индексации ведёт себя как копия. Запись уходит в эту копию, копия тут же выбрасывается, и в df ничего не меняется.

В моём прогоне таблица [100, 250, 300] после этой строки осталась [100, 250, 300], а рядом напечаталось ChainedAssignmentError.

ChainedAssignmentError здесь не исключение, хотя называется так. Это подкласс Warning. В скрипте он напечатается в stderr, в Jupyter появится розовой плашкой.

А теперь вспомним, сколько ноутбуков начинается с этих двух строк:

import warnings
warnings.filterwarnings("ignore")

С ними строка из начала раздела выполняется молча и ничего не делает. Цены выше 200 остаются как были, и дальше по ноутбуку считается выручка со скидками, которых нет.

Правильная запись одна, через .loc с маской и именем столбца в одних скобках:

df.loc[df["price"] > 200, "price"] = 0

Она работала и в pandas 1.x, и в 2.x, так что её можно вносить в код до обновления.

inplace на отдельном столбце

Вторая форма той же проблемы выглядит еще безобиднее:

df["discount"].fillna(0, inplace=True)
df["city"].replace("Мск", "Москва", inplace=True)

Метод вызывается на столбце, и inplace=True меняет этот столбец. Только столбец теперь — копия, и исходная таблица снова остаётся нетронутой.

В моём прогоне пропуск в discount пережил fillna и остался NaN, а рядом напечаталось то же предупреждение. Если после этого скидка участвует в формуле, строка с пропуском даст NaN в итоговой сумме, и sum() его тихо пропустит.

Исправление — в том, чтобы присвоить результат обратно:

df["discount"] = df["discount"].fillna(0)
df["city"] = df["city"].replace("Мск", "Москва")

Такая запись совместима со всеми версиями и читается проще. Видно, что столбец изменился, и для этого не нужно помнить семантику флага.

Почему так сделали

В pandas 2.x правила были такие. Результат индексации иногда был представлением, иногда копией, и зависело это от типа индексации, от того, однородны ли типы столбцов, и от внутреннего устройства блоков.

Для предупреждения о возможной ошибке завели SettingWithCopyWarning. Оно срабатывало и тогда, когда всё было правильно, и не срабатывало, когда запись терялась. Лет десять первым ответом на Stack Overflow про это предупреждение был совет его выключить.

Copy‑on‑Write делает правило простым: всё, что вернула индексация или метод, ведёт себя как копия.

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

Из‑за этого исчезла и обратная сторона старого поведения, о которой реже вспоминают:

prices = df["price"]
prices.iloc[0] = 1          # в pandas 2.x менял и df, в 3.0 только prices

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

Предупреждения в этом случае нет совсем, потому что запись в отдельную Series теперь законна.

Строки стали str

Второе крупное изменение касается типа. Раньше строковый столбец получал dtype object, теперь он получает str.

Если установлен pyarrow, данные хранятся в Arrow, если нет, то в обычных Python‑объектах, но тип всё равно str.

У меня не было pyarrow, и read_csv выдал StringDtype(storage='python', na_value=nan).

Первым ломается код, который определяет строковые столбцы по object:

text_cols = [c for c in df.columns if df[c].dtype == object]   # теперь пусто

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

С select_dtypes(include="object") pandas пока проявляет снисхождение: строковые столбцы он всё ещё отдаёт, но печатает Pandas4Warning и обещает перестать в четвёртой версии.

Надёжная проверка выглядит так:

from pandas.api.types import is_string_dtype
text_cols = [c for c in df.columns if is_string_dtype(df[c])]

Второе место, где новый тип меняет результат, — это пропуски.

Пустое значение в строковом столбце теперь NaN, даже если в исходном списке стоял None. В моём прогоне это выглядело так:

df = pd.DataFrame({"city": ["Омск", None, "Тула"]})
df["city"].map(lambda x: x is None).tolist()   # [False, False, False]
(df["city"] == None).tolist()                  # [False, False, False]
df["city"].isna().tolist()                     # [False, True, False]

Фильтр по x is None внутри apply перестаёт находить пустые строки, и строки без города уходят в отчёт как обычные.

Для пропусков работает только isna(), и так было правильно всегда, просто раньше x is None случайно срабатывал.

Третье изменение видно сразу, и это скорее хорошо.

Столбец str не принимает нестроковые значения, и df.loc[0, "city"] = 5 падает с TypeError: Invalid value '5' for dtype 'str'.

Раньше в такой столбец можно было положить что угодно, и где‑нибудь в середине object‑столбца жили числа, списки и datetime.

Если ваш код специально так делал, понадобится явный astype(object).

Даты в микросекундах

Это изменение я нашёл случайно, когда проверял перевод времени в Unix‑секунды. Строку такого вида я встречал во многих пайплайнах:

df["ts"] = pd.to_datetime(df["ts"])
df["epoch"] = df["ts"].astype("int64") // 10**9
  • В pandas 2.x to_datetime всегда давал наносекунды, и деление на 10**9 превращало их в секунды.

  • В pandas 3.0 разрешение по умолчанию выбирается по входным данным. Из строк получается datetime64[us], то есть микросекунды, и деление на миллиард теперь даёт число в тысячу раз меньше:

dtype:          datetime64[us]
astype(int64):  1767261600000000
// 10**9:       1767261          ожидали 1767261600

Хуже всего то, что разрешение разное в разных местах одного ноутбука.

pd.to_datetime(..., unit="s") из целых секунд даёт datetime64[s], и там то же деление на миллиард ошибается уже в другую сторону. Массив NumPy с явным datetime64[ns] сохраняет наносекунды.

Код, который полагался на наносекунды, придётся проверить везде, где дата превращается в число.

Перевод, не зависящий от разрешения, выглядит так:

df["epoch"] = (df["ts"] - pd.Timestamp(0)) // pd.Timedelta(seconds=1)

Если нужно сохранить старое поведение без переписывания арифметики, разрешение можно привести явно через df["ts"].dt.as_unit("ns").

Как найти это до того, как найдут цифры

Разработчики рекомендуют сначала обновиться до pandas 2.3 и включить там оба новых режима: pd.options.mode.copy_on_write = True и pd.options.future.infer_string = True.

Код начнёт вести себя как на третьей версии, но с подробными предупреждениями о каждом месте.

На третьей версии самую частую ошибку можно сделать громкой. Достаточно превратить предупреждение о цепочке присваиваний в исключение, и ноутбук остановится на нужной строке:

import warnings
import pandas as pd
warnings.simplefilter("error", pd.errors.ChainedAssignmentError)

В тестах то же самое делается настройкой pytest, и тогда CI упадёт на первой же потерянной записи:

[tool.pytest.ini_options]
filterwarnings = ["error::pandas.errors.ChainedAssignmentError"]

Для строк и дат такого флага нет, их проще найти поиском по коду:

  • inplace=True на столбце;

  • == object и "object" рядом с dtype;

  • astype("int64") рядом с датами;

  • is None внутри apply.

Почти всё, что сломалось, было неправильно и раньше, просто работало.

Цепочки присваиваний проходили благодаря деталям внутреннего устройства блоков, x is None попадал в пропуски, потому что строки хранились как Python‑объекты, а наносекунды были единственным разрешением, и никто не писал, откуда в формуле 10**9.

Третья версия убрала эти совпадения, и код стал делать то, что в нём написано.

Обновили pandas, и ноутбук работает без ошибок. Только считает уже другое - 1

После обновления pandas проверьте старые ноутбуки: действительно ли меняются значения после присваивания, заполняются ли пропуски и правильно ли рассчитываются показатели.

Чтобы увереннее работать с табличными данными на Python, приходите на бесплатный урок по обработке Excel‑таблиц:

  • 25 ноября, 20:00. «Искусство обработки Excel‑таблиц с Pandas». Записаться

Больше бесплатных вебинаров от преподавателей OTUS на этой неделе — в посте.

Автор: badcasedaily1

Источник