# Pandas 3.0 у 2026: Нові API, Критичні Зміни та Питання для Співбесіди > Pandas 3.0 впроваджує Copy-on-Write, PyArrow strings та pd.col(). Аналіз breaking changes, шаблонів міграції та питань для співбесід з аналітики даних. - Published: 2026-05-05 - Updated: 2026-05-05 - Author: Anthony Fillion-Maillet - Tags: pandas, python, data-analytics, interview - Reading time: 12 min --- Pandas 3.0 — це найбільший реліз бібліотеки за останні п'ять років. Версія переосмислює внутрішню архітектуру, запроваджує Copy-on-Write як поведінку за замовчуванням, замінює NumPy-рядки на PyArrow backend та додає декларативний API через `pd.col()`. Для інженерів з аналітики даних, які готуються до технічних співбесід, розуміння цих змін стає обов'язковим — рекрутери вже включають питання про міграцію на Pandas 3.0 до стандартних інтерв'ю. > Pandas 3.0 вийшов у стабільній версії в лютому 2026. Якщо проєкт досі працює на Pandas 2.x, рекомендовано встановити `pandas>=3.0` та запустити тести з прапорцем `pd.set_option("mode.copy_on_write", True)` для перевірки сумісності. ## Copy-on-Write: Кінець SettingWithCopyWarning Одна з найбільш очікуваних змін у Pandas 3.0 — повне впровадження семантики Copy-on-Write (CoW). У попередніх версіях розробники постійно стикалися з `SettingWithCopyWarning`, що сигналізувало про потенційне непередбачуване мутування даних через ланцюгове індексування. Тепер кожна операція, яка повертає DataFrame або Series, створює лінивий вигляд (lazy view) оригінальних даних. Фактичне копіювання відбувається лише при спробі модифікації — звідси назва Copy-on-Write. ```python import pandas as pd df = pd.DataFrame({"name": ["Alice", "Bob", "Charlie"], "score": [85, 92, 78]}) # Pandas 2.x: subset може бути view або copy — невизначено # Pandas 3.0: subset завжди є lazy view subset = df[df["score"] > 80] # Модифікація subset НЕ впливає на оригінальний df subset["score"] = 100 print(df["score"].tolist()) # [85, 92, 78] — оригінал незмінний ``` Переваги для продуктивності значні: операції фільтрації, зрізу та вибірки стовпців більше не виконують фізичне копіювання пам'яті до моменту запису. На великих DataFrame (10M+ рядків) це зменшує пікове використання RAM на 30-50%. ```python # Приклад: ланцюгові операції без зайвого копіювання result = ( df .query("score > 80") .assign(grade=lambda x: x["score"].apply(classify_grade)) .sort_values("grade") ) # Жодного проміжного копіювання до фінального результату ``` ### Що робити зі старим кодом Якщо існуючий код навмисно мутує view (наприклад, `df.loc[mask, "col"] = value`), він продовжить працювати коректно. Проблеми виникають лише у коді, який покладався на неявну поведінку view через ланцюгове індексування: ```python # Pandas 2.x: могло мутувати df (непередбачувано) df["score"][df["score"] > 80] = 100 # ChainedAssignmentError у Pandas 3.0 # Pandas 3.0: явний та безпечний спосіб df.loc[df["score"] > 80, "score"] = 100 ``` ## PyArrow String Backend: 5-10x Швидші Рядкові Операції Pandas 3.0 використовує `ArrowDtype(pa.string())` як тип за замовчуванням для текстових стовпців замість `object` dtype. Це фундаментальна зміна, яка впливає на продуктивність, споживання пам'яті та сумісність із зовнішніми бібліотеками. ```python import pandas as pd df = pd.read_csv("users.csv") print(df["email"].dtype) # string[pyarrow] (раніше: object) ``` ### Порівняння продуктивності | Операція | Pandas 2.x (object) | Pandas 3.0 (PyArrow) | Прискорення | |----------|---------------------|----------------------|-------------| | `str.contains()` | 4.2s | 0.5s | 8.4x | | `str.lower()` | 2.8s | 0.4s | 7.0x | | `str.split()` | 5.1s | 0.9s | 5.7x | | `value_counts()` | 1.9s | 0.2s | 9.5x | | Пам'ять (1M рядків) | 412 MB | 89 MB | 4.6x менше | *Бенчмарк: 5 мільйонів рядків, середня довжина рядка 47 символів, Apple M3 Pro.* PyArrow strings підтримують відсутні значення (`pd.NA`) нативно, без fallback на `NaN`. Це усуває цілу категорію помилок при порівнянні рядків: ```python import pandas as pd s = pd.Series(["hello", None, "world"], dtype="string[pyarrow]") # Безпечна робота з None — без виключень result = s.str.upper() # ["HELLO", , "WORLD"] # Фільтрація автоматично пропускає NA mask = s.str.startswith("h") # [True, , False] ``` ## pd.col() — Конструктор Виразів Новий API `pd.col()` дозволяє створювати вирази для трансформації стовпців у декларативному стилі, подібному до Polars. Це не заміна існуючого API, а додатковий інструмент для складних ланцюгових операцій. ```python import pandas as pd df = pd.DataFrame({ "revenue": [1000, 2500, 800, 3200], "cost": [400, 1200, 600, 1800], "region": ["EU", "US", "EU", "APAC"] }) # Декларативний стиль через pd.col() result = df.assign( profit=pd.col("revenue") - pd.col("cost"), margin=(pd.col("revenue") - pd.col("cost")) / pd.col("revenue") * 100 ) ``` Головна перевага `pd.col()` — можливість побудови виразів до їх застосування до конкретного DataFrame. Це відкриває шлях для повторного використання трансформацій: ```python # Визначення виразів окремо від даних profit_expr = pd.col("revenue") - pd.col("cost") margin_expr = profit_expr / pd.col("revenue") * 100 high_margin = margin_expr > 30 # Застосування до будь-якого DataFrame з відповідними стовпцями df_q1 = load_quarter("Q1").assign(profit=profit_expr, margin=margin_expr) df_q2 = load_quarter("Q2").assign(profit=profit_expr, margin=margin_expr) ``` ## Breaking Changes: Таблиця Міграції Pandas 3.0 містить кілька зворотно несумісних змін. Нижче наведено повний перелік із рекомендованими замінами: | Видалено / Змінено | Заміна в Pandas 3.0 | Пояснення | |-------------------|---------------------|------------| | `DataFrame.append()` | `pd.concat([df1, df2])` | Видалено після deprecation у 2.0 | | `Series.dt.weekofyear` | `Series.dt.isocalendar().week` | ISO-сумісний тиждень | | `inplace=True` (більшість методів) | Ланцюгування через присвоєння | Несумісно з CoW | | `object` dtype для рядків | `string[pyarrow]` | Автоматична міграція | | `DataFrame.swaplevel()` | `DataFrame.reorder_levels()` | Узагальнений API | | `pd.np` accessor | `import numpy as np` | Видалено | | `pd.datetime` | `from datetime import datetime` | Видалено | | `sort=None` за замовчуванням | `sort=False` явно, якщо потрібно | Передбачуваний порядок | ```python # Міграція: DataFrame.append() -> pd.concat() # Pandas 2.x (deprecated) df = df.append({"name": "Dave", "score": 88}, ignore_index=True) # Pandas 3.0 new_row = pd.DataFrame([{"name": "Dave", "score": 88}]) df = pd.concat([df, new_row], ignore_index=True) ``` ```python # Міграція: inplace=True -> присвоєння # Pandas 2.x df.drop(columns=["temp"], inplace=True) df.reset_index(inplace=True) # Pandas 3.0 df = df.drop(columns=["temp"]).reset_index() ``` ## Нова Політика Застарівання: Pandas4Warning та Pandas5Warning Pandas 3.0 запроваджує нову систему попереджень про майбутні зміни. Замість загального `FutureWarning`, тепер існують конкретні класи: - **`Pandas4Warning`** — функціональність буде видалена в Pandas 4.0 - **`Pandas5Warning`** — функціональність буде видалена в Pandas 5.0 Це дозволяє командам планувати міграцію поетапно: ```python import warnings import pandas as pd # Показати лише критичні попередження для наступної версії warnings.filterwarnings("error", category=pd.Pandas4Warning) warnings.filterwarnings("ignore", category=pd.Pandas5Warning) # Тепер код впаде з помилкою при використанні API, # що буде видалено в Pandas 4.0 ``` Така система спрощує CI/CD пайплайни: можна налаштувати тести на відмову при `Pandas4Warning` (найближча міграція) та ігнорувати `Pandas5Warning` (далека перспектива). ## Питання для Співбесіди з Pandas 3.0 Нижче наведено п'ять типових питань, які з'являються на технічних інтерв'ю з аналітики даних у 2026 році. ### Q1: Поясніть семантику Copy-on-Write у Pandas 3.0. Коли відбувається фактичне копіювання? **Очікувана відповідь:** Copy-on-Write означає, що будь-яка операція вибірки (slicing, filtering, column selection) повертає lazy view — логічне посилання на оригінальні дані без фізичного копіювання. Фактичне копіювання відбувається лише при першій спробі модифікації (write) цього view. Це гарантує, що модифікація похідного DataFrame ніколи не впливає на оригінал, усуваючи `SettingWithCopyWarning`. Для in-place операцій через `.loc[]` копіювання не потрібне — модифікація застосовується безпосередньо. ### Q2: Чому PyArrow strings швидші за NumPy object dtype? **Очікувана відповідь:** NumPy `object` dtype зберігає рядки як масив Python-об'єктів (покажчиків на купу). Кожна операція вимагає розпакування покажчика та виклику Python string method. PyArrow використовує колоноподібне зберігання (columnar format) з бінарними буферами та offset-масивами. Рядкові операції виконуються на рівні C++ без GIL, використовуючи SIMD-інструкції. Додатково, PyArrow підтримує dictionary encoding для стовпців з низькою кардинальністю, що зменшує споживання пам'яті. ### Q3: Напишіть код міграції з inplace=True на CoW-сумісний стиль. **Очікувана відповідь:** ```python # До міграції (Pandas 2.x) def process_data(df): df.dropna(subset=["email"], inplace=True) df.rename(columns={"old_name": "new_name"}, inplace=True) df.sort_values("date", inplace=True) df.reset_index(drop=True, inplace=True) return df # Після міграції (Pandas 3.0) def process_data(df): return ( df .dropna(subset=["email"]) .rename(columns={"old_name": "new_name"}) .sort_values("date") .reset_index(drop=True) ) ``` ### Q4: Як pd.col() відрізняється від lambda у .assign()? **Очікувана відповідь:** Lambda у `.assign()` отримує весь DataFrame та виконується eagerly. `pd.col()` створює вираз (expression object), який може бути оптимізований, повторно використаний та серіалізований. Вирази `pd.col()` дозволяють Pandas аналізувати залежності між стовпцями до виконання, потенційно паралелізуючи незалежні обчислення. Крім того, вирази можна зберігати у змінних та застосовувати до різних DataFrame. ### Q5: Як налаштувати CI для поступової міграції з Pandas 3.0 на 4.0? **Очікувана відповідь:** ```python # conftest.py import warnings import pandas as pd import pytest def pytest_configure(config): # Pandas4Warning -> error (блокує merge) warnings.filterwarnings("error", category=pd.Pandas4Warning) # Pandas5Warning -> log (не блокує) warnings.filterwarnings("default", category=pd.Pandas5Warning) ``` Це дозволяє CI автоматично відхиляти PR, що використовує API, позначені для видалення в наступному мажорному релізі, водночас дозволяючи API з довшим терміном підтримки. ## Порівняння Продуктивності: Pandas 2.x vs 3.0 Нижче наведено результати бенчмарків на реальних робочих навантаженнях: ```python import pandas as pd import numpy as np import time # Генерація тестових даних n_rows = 5_000_000 df = pd.DataFrame({ "user_id": np.random.randint(1, 100000, n_rows), "email": [f"user_{i}@example.com" for i in range(n_rows)], "amount": np.random.uniform(10, 1000, n_rows), "category": np.random.choice(["A", "B", "C", "D"], n_rows), "timestamp": pd.date_range("2024-01-01", periods=n_rows, freq="s") }) # Бенчмарк: GroupBy + Aggregation start = time.perf_counter() result = ( df .groupby("category") .agg( total_amount=pd.NamedAgg(column="amount", aggfunc="sum"), unique_users=pd.NamedAgg(column="user_id", aggfunc="nunique"), avg_amount=pd.NamedAgg(column="amount", aggfunc="mean") ) ) print(f"GroupBy: {time.perf_counter() - start:.3f}s") # Бенчмарк: String operations start = time.perf_counter() mask = df["email"].str.contains("42") filtered = df[mask] print(f"String filter: {time.perf_counter() - start:.3f}s") ``` | Сценарій | Pandas 2.2 | Pandas 3.0 | Різниця | |----------|-----------|-----------|----------| | GroupBy + 3 агрегації (5M рядків) | 1.8s | 1.2s | -33% | | String contains (5M рядків) | 4.2s | 0.5s | -88% | | Read CSV (1GB файл) | 12.4s | 8.1s | -35% | | Memory peak (5M рядків, 5 стовпців) | 1.2 GB | 0.6 GB | -50% | | Chained filter + assign (CoW) | 3.1s | 0.9s | -71% | ## Практична Міграція: Шаблони Коду Для безболісної міграції існуючих проєктів рекомендовано поетапний підхід: ### Крок 1: Аудит сумісності ```bash # Встановлення Pandas 3.0 у ізольованому середовищі pip install pandas==3.0.0 # Запуск тестів з суворими попередженнями python -W error::DeprecationWarning -m pytest tests/ -v ``` ### Крок 2: Автоматичні заміни ```python # scripts/migrate_pandas3.py import ast import sys from pathlib import Path DEPRECATED_PATTERNS = { ".append(": "pd.concat()", "inplace=True": "method chaining", "pd.np.": "import numpy as np", "pd.datetime": "from datetime import datetime", } def scan_file(filepath: Path) -> list[str]: issues = [] content = filepath.read_text() for pattern, replacement in DEPRECATED_PATTERNS.items(): if pattern in content: issues.append(f"{filepath}:{pattern} -> use {replacement}") return issues if __name__ == "__main__": root = Path(sys.argv[1]) all_issues = [] for py_file in root.rglob("*.py"): all_issues.extend(scan_file(py_file)) for issue in all_issues: print(issue) print(f"\nTotal issues: {len(all_issues)}") ``` ### Крок 3: Оновлення типізації ```python # Pandas 3.0 підтримує повну типізацію через pandas-stubs 3.0 from pandas import DataFrame, Series from pandas.api.types import is_string_dtype def process_users(df: DataFrame) -> DataFrame: # Типізація стовпців через .attrs або schema validation assert is_string_dtype(df["email"]), "Expected string column" return df.dropna(subset=["email"]) ``` ### Крок 4: Конфігурація для перехідного періоду ```python import pandas as pd # Увімкнення зворотної сумісності для поступової міграції pd.set_option("future.infer_string", True) # PyArrow strings pd.set_option("mode.copy_on_write", True) # CoW semantics # Вимкнення нових попереджень під час міграції import warnings warnings.filterwarnings("ignore", category=pd.Pandas4Warning) ``` ## Висновок Pandas 3.0 — це не просто інкрементальне оновлення, а переосмислення фундаментальних аспектів бібліотеки. Основні висновки для підготовки до співбесіди: - **Copy-on-Write** усуває цілу категорію помилок, пов'язаних з неявним мутуванням DataFrame, та зменшує споживання пам'яті на 30-50% - **PyArrow strings** прискорюють рядкові операції у 5-10 разів та зменшують використання RAM для текстових даних - **pd.col()** надає декларативний API для побудови виразів, наближаючи Pandas до Polars-стилю - **Breaking changes** вимагають оновлення коду: видалення `inplace=True`, `DataFrame.append()`, та legacy accessors - **Pandas4Warning / Pandas5Warning** дозволяють планувати міграцію поетапно через CI/CD - Питання про CoW, PyArrow та міграційні шаблони стають стандартними на інтерв'ю з аналітики даних у 2026 році Розуміння внутрішньої механіки цих змін — від lazy views у CoW до columnar storage у PyArrow — відрізняє кандидата, який просто використовує Pandas, від того, хто розуміє, як бібліотека працює на рівні пам'яті та CPU. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/uk/blog/data-analytics/pandas-3-new-apis-breaking-changes-interview