# Pandas 3.0 di Tahun 2026: API Baru, Breaking Changes, dan Pertanyaan Wawancara > Panduan lengkap Pandas 3.0 yang membahas Copy-on-Write, PyArrow string backend, pd.col() expressions, breaking changes, dan pertanyaan wawancara data analytics. - Published: 2026-05-05 - Updated: 2026-05-05 - Author: Anthony Fillion-Maillet - Tags: pandas, data-analytics, python, interview - Reading time: 12 min --- Pandas 3.0, dirilis pada 21 Januari 2026, memperkenalkan perubahan arsitektur paling signifikan sejak era library versi 1.x. Copy-on-Write kini menjadi perilaku default, kolom string beralih ke dtype berbasis PyArrow, dan expression builder `pd.col()` yang baru menawarkan alternatif yang lebih bersih dibandingkan fungsi lambda. Perubahan-perubahan ini memengaruhi setiap codebase yang ada dan semakin sering diujikan dalam wawancara data engineering. > **Poin Utama** > > Pandas 3.0 membutuhkan Python 3.11+, menerapkan semantik Copy-on-Write secara default, dan menyimpulkan kolom string sebagai dtype `str` yang didukung PyArrow. Chained assignment kini memunculkan error alih-alih warning. ## Copy-on-Write: Berakhirnya SettingWithCopyWarning Copy-on-Write (CoW) secara fundamental mengubah cara pandas menangani berbagi memori antar DataFrame. Setiap operasi indexing kini mengembalikan apa yang berperilaku sebagai salinan, tetapi secara internal pandas tetap berbagi memori hingga mutasi benar-benar terjadi. Dampak praktisnya: `SettingWithCopyWarning` tidak lagi ada. Pola chained assignment seperti `df[df['A'] > 0]['B'] = 1` kini memunculkan `ChainedAssignmentError` karena hasil indexing perantara adalah salinan. ```python # migration_cow.py import pandas as pd df = pd.DataFrame({"price": [100, 200, 300], "category": ["A", "B", "A"]}) # Pola Pandas 2.x (sekarang memunculkan ChainedAssignmentError) # df[df["category"] == "A"]["price"] = 150 # RUSAK di 3.0 # Pola benar Pandas 3.0: gunakan .loc[] df.loc[df["category"] == "A", "price"] = 150 # Berbagi memori CoW dalam aksi df2 = df[["price"]] # berbagi memori dengan df df2["price"] = df2["price"] * 2 # salinan dipicu hanya di sini # df tetap tidak berubah - tanpa efek samping ``` Argumen keyword `copy` di seluruh method tidak lagi memiliki efek dan dapat dihapus dengan aman dari kode yang ada. Method yang mendukung `inplace=True` (`replace()`, `fillna()`, `ffill()`, `bfill()`, `clip()`) kini mengembalikan `self` alih-alih `None`, memungkinkan method chaining bahkan dengan operasi in-place. ## PyArrow String Backend: Operasi String 5-10x Lebih Cepat Pandas 3.0 menyimpulkan kolom string sebagai dtype `str` khusus yang didukung oleh Apache Arrow, menggantikan dtype `object` lawas. Jika PyArrow tidak terinstal, fallback menggunakan array objek NumPy. Peningkatan performa sangat substansial: `.str.contains()`, `.str.lower()`, dan method string lainnya berjalan 5-10x lebih cepat. Konsumsi memori untuk kolom berteks banyak menurun hingga 50%. Format kolumnar Arrow juga memungkinkan pertukaran data zero-copy dengan Polars, DuckDB, dan tools berbasis Arrow lainnya. ```python # string_dtype_comparison.py import pandas as pd import numpy as np # Pandas 3.0: kolom string otomatis menjadi str[pyarrow] df = pd.DataFrame({"name": ["Alice", "Bob", "Charlie", None]}) print(df.dtypes) # name string[pyarrow] # dtype: object # Nilai missing menggunakan NaN (bukan pd.NA), sesuai dtype default lainnya print(df["name"].isna()) # True untuk entri None # Interoperabilitas langsung dengan DuckDB (zero-copy) import duckdb result = duckdb.sql("SELECT name FROM df WHERE name LIKE '%li%'").df() ``` Satu batasan penting: array PyArrow bersifat immutable. Mengonversi kolom berbasis PyArrow ke array NumPy yang writable memerlukan salinan eksplisit melalui `.to_numpy(copy=True)`. > **Peringatan Migrasi** > > Kode yang memeriksa `df['col'].dtype == object` untuk deteksi string akan rusak. Ganti dengan `pd.api.types.is_string_dtype(df['col'])` atau periksa `pd.StringDtype()`. ## Expression Builder pd.col() Pandas 3.0 memperkenalkan `pd.col()` sebagai cara deklaratif untuk mereferensikan kolom DataFrame dan membangun ekspresi. Sintaksnya terinspirasi dari PySpark dan Polars, mengatasi masalah yang sudah dikenal dengan lambda scoping dan opaqueness. ```python # col_expressions.py import pandas as pd df = pd.DataFrame({ "revenue": [1000, 2500, 800, 3200], "cost": [400, 1200, 600, 1500], "region": ["US", "EU", "US", "APAC"] }) # Sebelumnya: berbasis lambda (opaque, masalah scoping dalam loop) df = df.assign(profit=lambda x: x["revenue"] - x["cost"]) # Sesudahnya: pd.col() (deklaratif, dapat diintrospeksi) df = df.assign( profit=pd.col("revenue") - pd.col("cost"), margin=((pd.col("revenue") - pd.col("cost")) / pd.col("revenue") * 100) ) # Filtering dengan pd.col() high_margin = df.loc[pd.col("margin") > 50] ``` Keunggulan utama dibanding lambda terlihat dalam loop, di mana closure lambda menangkap variabel berdasarkan referensi dan menghasilkan hasil yang salah: ```python # loop_scoping_fix.py import pandas as pd df = pd.DataFrame({"base": [10, 20, 30]}) # Bug lambda: semua kolom menggunakan factor=30 (nilai loop terakhir) # cols = {} # for factor in [2, 5, 10]: # cols[f"x{factor}"] = lambda x: x["base"] * factor # BUG # Fix pd.col(): setiap ekspresi menangkap nilai yang benar cols = {} for factor in [2, 5, 10]: cols[f"x{factor}"] = pd.col("base") * factor # Benar df = df.assign(**cols) ``` Per pandas 3.0.2, `pd.col()` juga berfungsi di `Series.case_when()`. Aggregasi groupby belum didukung. ## Breaking Changes: Checklist Migrasi Lengkap Tabel berikut merangkum breaking changes yang paling mungkin muncul selama migrasi dari pandas 2.x: | Perubahan | Perilaku Pandas 2.x | Perilaku Pandas 3.0 | Perbaikan | |-----------|---------------------|---------------------|-----------|| | Chained assignment | `SettingWithCopyWarning` | `ChainedAssignmentError` | Gunakan `.loc[]` | | String dtype | `object` | `string[pyarrow]` | Perbarui pengecekan dtype | | Keyword `copy=` | Membuat salinan | Tidak berpengaruh (deprecated) | Hapus argumen | | `groupby(observed=)` | Default `False` | Default `True` | Atur secara eksplisit | | `Index.sort_values()` | Args posisional diizinkan | Args keyword-only | Beri nama semua argumen | | `offsets.Day` | Span 24j tetap | Calendar-day (DST-aware) | Tinjau logika timezone | | `Categorical.map(na_action=)` | Default `None` | Default berubah | Atur secara eksplisit | | `str.contains(na=)` | Non-bool diizinkan | Hanya bool atau `None` | Bersihkan parameter na | Jalur upgrade yang disarankan: pertama upgrade ke pandas 2.3, selesaikan semua deprecation warning, kemudian pindah ke 3.0. ## Kebijakan Deprecation Baru: Pandas4Warning dan Pandas5Warning Pandas 3.0 memperkenalkan siklus deprecation 3-tahap yang terstruktur. Fitur pertama-tama mengeluarkan `DeprecationWarning` standar, kemudian beralih ke `FutureWarning` di rilis minor terakhir sebelum major berikutnya, dan akhirnya dihapus di rilis major tersebut. Dua kelas warning baru mempermudah penyaringan warning berdasarkan versi target: ```python # filter_warnings.py import warnings import pandas as pd # Tangkap hanya perubahan yang datang di pandas 4.0 warnings.filterwarnings("error", category=pd.errors.Pandas4Warning) # Tangkap perubahan yang datang di pandas 5.0 warnings.filterwarnings("default", category=pd.errors.Pandas5Warning) ``` Kebijakan ini memberikan maintainer library setidaknya dua siklus rilis minor untuk beradaptasi sebelum breaking changes diterapkan. > **Versi Python** > > Pandas 3.0 membutuhkan Python 3.11 atau lebih tinggi. Proyek yang masih menggunakan Python 3.9 atau 3.10 harus upgrade terlebih dahulu sebelum melakukan migrasi. ## Pertanyaan Wawancara: Deep Dive Pandas 3.0 Pertanyaan-pertanyaan berikut muncul dalam wawancara data engineering dan analytics di tahun 2026, menguji baik pemahaman teoretis maupun pengalaman migrasi praktis. **Q1: Jelaskan Copy-on-Write di pandas 3.0. Mengapa fitur ini diperkenalkan?** CoW memastikan bahwa setiap DataFrame atau Series yang dikembalikan dari operasi indexing berperilaku sebagai salinan independen. Secara internal, pandas berbagi memori antara aslinya dan hasilnya hingga salah satunya dimutasi, saat itulah salinan fisik terjadi. Ini menghilangkan ambiguitas antara view dan copy yang menyebabkan `SettingWithCopyWarning`, mencegah korupsi data yang tidak disengaja melalui efek samping, dan mengurangi penggunaan memori untuk beban kerja read-heavy. **Q2: Apa yang terjadi pada `df[condition]['col'] = value` di pandas 3.0?** Pola tersebut memunculkan `ChainedAssignmentError`. `df[condition]` perantara kini selalu menjadi salinan (karena CoW), sehingga assignment ke kolom pada salinan tersebut tidak berpengaruh pada DataFrame asli. Pola yang benar adalah `df.loc[condition, 'col'] = value`. **Q3: Bagaimana dtype string baru memengaruhi interoperabilitas dengan tools lain?** Dtype string berbasis PyArrow menyimpan data dalam format kolumnar Apache Arrow. Ini memungkinkan transfer data zero-copy ke tools berbasis Arrow lainnya (Polars, DuckDB, Spark via PyArrow) tanpa overhead serialisasi. Ini juga mengurangi jejak memori dibandingkan array objek Python, karena Arrow menggunakan buffer biner kompak alih-alih objek string Python individual. **Q4: Masalah apa yang diselesaikan pd.col() yang tidak bisa diatasi lambda?** `pd.col()` menangkap referensi kolom dan nilai pada saat pembuatan ekspresi, bukan pada saat eksekusi. Lambda di Python menangkap variabel berdasarkan referensi, yang menyebabkan bug dalam loop di mana semua lambda akhirnya mereferensikan variabel loop terakhir. Selain itu, ekspresi `pd.col()` dapat diintrospeksi (pandas dapat mengoptimalkannya), sementara lambda adalah callable yang opaque. **Q5: Bagaimana cara memigrasi codebase dari pandas 2.x ke 3.0?** Langkah 1: Upgrade ke pandas 2.3 dan perbaiki semua deprecation warning. Langkah 2: Aktifkan CoW opt-in melalui `pd.options.mode.copy_on_write = True` (tersedia sejak 2.0) dan perbaiki pola chained assignment. Langkah 3: Instal PyArrow dan tes bahwa inferensi dtype string tidak merusak logika downstream (terutama pengecekan `dtype == object`). Langkah 4: Upgrade ke 3.0 dan jalankan seluruh test suite. Langkah 5: Hapus argumen `copy=` yang sudah mati dan perbarui panggilan `groupby(observed=)`. ## Benchmark Performa: Sebelum dan Sesudah Efek gabungan dari CoW dan PyArrow string memberikan peningkatan yang terukur pada beban kerja nyata: ```python # benchmark_example.py import pandas as pd import numpy as np # Generate DataFrame dengan 1 juta baris data campuran rng = np.random.default_rng(42) df = pd.DataFrame({ "user_id": rng.integers(0, 100_000, size=1_000_000), "event": rng.choice(["click", "view", "purchase", "scroll"], size=1_000_000), "value": rng.exponential(50, size=1_000_000) }) # Filtering string: ~6x lebih cepat dengan backend PyArrow clicks = df.loc[pd.col("event").str.contains("click")] # Memori: kolom string menggunakan ~50% lebih sedikit RAM print(df["event"].memory_usage(deep=True)) # ~8MB vs ~16MB dengan dtype object # Subsetting: CoW menghindari penyalinan hingga mutasi subset = df[["user_id", "value"]] # zero-copy (memori berbagi) subset["value"] = subset["value"].clip(upper=500) # salinan dipicu hanya di sini ``` Dalam pipeline ETL produksi yang memproses CSV berteks banyak, backend string PyArrow saja mengurangi memori puncak sebesar 30-40% dan memangkas total runtime sebesar 20-30% pada transformasi string-intensive. ## Pola Migrasi Praktis: Perbaikan Dunia Nyata Codebase pandas 2.x yang khas membutuhkan refactor-refactor spesifik berikut: ```python # migration_patterns.py import pandas as pd # Pola 1: Ganti chained assignment # Sebelum (pandas 2.x) # df[df["status"] == "active"]["score"] = 100 # Sesudah (pandas 3.0) df.loc[df["status"] == "active", "score"] = 100 # Pola 2: Hapus argumen copy= # Sebelum # subset = df[["a", "b"]].copy() # tidak perlu dengan CoW # Sesudah subset = df[["a", "b"]] # CoW menangani isolasi secara otomatis # Pola 3: Perbarui pengecekan dtype untuk string # Sebelum # if df["name"].dtype == object: # Sesudah if pd.api.types.is_string_dtype(df["name"]): pass # Pola 4: Eksplisit observed= di groupby # Sebelum (mengandalkan default observed=False) # df.groupby("category")["value"].sum() # Sesudah (eksplisit untuk kejelasan) df.groupby("category", observed=True)["value"].sum() # Pola 5: Keyword-only Index.sort_values() # Sebelum # idx.sort_values(True, "first") # Sesudah idx.sort_values(ascending=True, na_position="first") ``` Untuk mempelajari lebih lanjut tentang keterampilan dasar [pandas dan Python data analytics](https://sharpskill.dev/id/technologies/data-analytics/pertanyaan-wawancara/python-pandas-basics), modul pertanyaan wawancara membahas pola-pola ini secara mendalam. Modul [SQL window functions](https://sharpskill.dev/id/technologies/data-analytics/pertanyaan-wawancara/sql-window-functions) melengkapi pengetahuan pandas untuk pipeline analitik hybrid. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/id/blog/data-analytics/pandas-3-new-apis-breaking-changes-interview