Hướng Dẫn 19 phút đọc

Pandas 3.0: Tính Năng Mới, Breaking Changes Và Cách Di Chuyển Từ Pandas 2.x

Tổng hợp tất cả tính năng mới trong Pandas 3.0: kiểu str mặc định giảm 50% bộ nhớ, Copy-on-Write loại bỏ SettingWithCopyWarning, cú pháp pd.col() thay thế lambda, tích hợp Arrow zero-copy, và hướng dẫn di chuyển chi tiết.

Editorial Team

Giới Thiệu Pandas 3.0: Một Bản Cập Nhật Thực Sự Đáng Chờ Đợi

Pandas 3.0 đã chính thức ra mắt vào ngày 21 tháng 1 năm 2026, và thành thật mà nói — đây là bản cập nhật lớn nhất kể từ khi thư viện này xuất hiện. Nếu bạn từng "gồng mình" chịu đựng SettingWithCopyWarning hay thất vọng vì kiểu object chậm chạp, thì pandas 3.0 chính là câu trả lời.

Bản cập nhật này mang đến kiểu dữ liệu chuỗi chuyên dụng, cơ chế Copy-on-Write mặc định, cú pháp biểu thức pd.col() hoàn toàn mới, và tích hợp sâu hơn với Apache Arrow. Bài viết này sẽ đi qua từng tính năng một cách chi tiết, kèm ví dụ mã nguồn thực tế, phân tích các thay đổi có thể phá vỡ code cũ, và cách di chuyển an toàn lên phiên bản mới.

Nếu bạn đang dùng pandas cho khoa học dữ liệu, phân tích dữ liệu, hay xây dựng pipeline ETL — bài viết này dành cho bạn. Nào, cùng bắt đầu thôi.

1. Kiểu Dữ Liệu Chuỗi (String) Chuyên Dụng — Mặc Định Mới

1.1 Vấn Đề Với Kiểu Object Cũ

Trước đây, cột chứa dữ liệu chuỗi trong pandas được gán kiểu object — một kiểu dữ liệu "bao la" có thể chứa bất kỳ đối tượng Python nào. Nghe thì linh hoạt, nhưng thực tế lại gây ra không ít phiền toái:

  • Tốn bộ nhớ: Mỗi chuỗi Python là một đối tượng riêng biệt, kéo theo overhead đáng kể
  • Hiệu suất thấp: Các phép toán chuỗi không thể tối ưu hóa vì kiểu dữ liệu quá chung chung
  • Thiếu kiểm soát: Cột object có thể chứa lẫn lộn số, chuỗi, và các đối tượng khác
  • Giá trị thiếu không nhất quán: None và NaN bị xử lý khác nhau, dễ gây nhầm lẫn

1.2 Kiểu str Mới Trong Pandas 3.0

Pandas 3.0 mang đến kiểu dữ liệu str chuyên dụng, được bật mặc định. Backend của nó là PyArrow (nếu đã cài) hoặc dùng NumPy object dtype làm phương án dự phòng.

# Pandas 2.x — Hành vi cũ
import pandas as pd
ser = pd.Series(["Hà Nội", "Hồ Chí Minh", "Đà Nẵng"])
print(ser.dtype)
# Output: object

# Pandas 3.0 — Hành vi mới
import pandas as pd
ser = pd.Series(["Hà Nội", "Hồ Chí Minh", "Đà Nẵng"])
print(ser.dtype)
# Output: str

Chỉ thay đổi nhỏ thôi, nhưng tác động thì rất lớn.

1.3 Lợi Ích Về Hiệu Suất

Kiểu str mới cải thiện hiệu suất một cách rõ rệt:

  • Giảm ~50% bộ nhớ: Chuỗi được lưu ở định dạng nhị phân compact thay vì từng đối tượng Python riêng lẻ
  • Nhanh hơn 5-10 lần: Các phép toán như .str.contains(), .str.upper() nhanh hơn đáng kể nhờ backend PyArrow
  • Kiểm soát kiểu chặt chẽ: Chỉ chấp nhận chuỗi hoặc giá trị thiếu — gán giá trị khác kiểu sẽ báo lỗi ngay
import pandas as pd
import numpy as np

# Tạo DataFrame lớn để so sánh hiệu suất
n = 1_000_000
df = pd.DataFrame({
    'ten': [f'nguoi_{i}' for i in range(n)],
    'thanh_pho': np.random.choice(['Ha Noi', 'HCM', 'Da Nang', 'Hue', 'Can Tho'], n)
})

# Kiểm tra kiểu dữ liệu — tự động là str trong pandas 3.0
print(df.dtypes)
# ten          str
# thanh_pho    str

# Kiểm tra bộ nhớ sử dụng
print(f"Bộ nhớ: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")

# Phép toán chuỗi nhanh hơn rất nhiều
ket_qua = df['ten'].str.upper()
print(ket_qua.head())
# 0    NGUOI_0
# 1    NGUOI_1
# 2    NGUOI_2
# ...

1.4 Xử Lý Giá Trị Thiếu Với Kiểu str

Một điểm mình thích ở kiểu str mới là cách nó xử lý giá trị thiếu: mọi thứ đều thống nhất thành NaN. Không còn chuyện None khác NaN nữa.

import pandas as pd
import numpy as np

ser = pd.Series(["xin chào", None, "việt nam", np.nan])
print(ser)
# 0    xin chào
# 1         NaN
# 2    việt nam
# 3         NaN
# dtype: str

# Cả None và np.nan đều trở thành NaN nhất quán
print(ser.isna())
# 0    False
# 1     True
# 2    False
# 3     True

1.5 Lưu Ý Về Tương Thích Ngược

Có một điều cần nhớ: kiểu str mới không chấp nhận giá trị không phải chuỗi. Nếu code cũ của bạn trộn nhiều kiểu dữ liệu trong cùng một cột, bạn sẽ cần cập nhật lại:

# Sẽ gây lỗi trong pandas 3.0
try:
    ser = pd.Series(["hello", 42])  # Trộn chuỗi và số
except TypeError as e:
    print(f"Lỗi: {e}")

# Giải pháp: chuyển đổi rõ ràng
ser = pd.Series(["hello", str(42)])  # Chuyển tất cả sang chuỗi
# hoặc
ser = pd.Series(["hello", 42], dtype="object")  # Dùng object dtype

2. Copy-on-Write (CoW) — Cuối Cùng Cũng Thành Mặc Định

2.1 Copy-on-Write Là Gì?

Copy-on-Write (CoW) là cơ chế quản lý bộ nhớ mà trong đó dữ liệu chỉ thực sự được sao chép khi bạn ghi (write) vào nó. Trước thời điểm đó, dữ liệu được chia sẻ dưới dạng view — tiết kiệm bộ nhớ và tăng tốc.

Trong pandas 3.0, CoW là cơ chế mặc định và duy nhất. Tùy chọn mode.copy_on_write đã bị deprecated — vì CoW luôn bật rồi, không cần bật nữa.

2.2 Tại Sao CoW Quan Trọng?

Nếu bạn đã dùng pandas đủ lâu, chắc hẳn bạn từng gặp tình huống "tôi đã sửa dữ liệu... nhưng sao DataFrame gốc lại thay đổi theo?". Hoặc ngược lại: "tôi đã sửa rồi mà sao nó không thay đổi gì?". Hành vi view/copy trước pandas 3.0 thực sự rất khó đoán:

# Pandas 2.x — Hành vi không nhất quán
import pandas as pd

df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})

# Trường hợp 1: Trả về view (thay đổi ảnh hưởng df gốc)
subset = df['a']
subset.iloc[0] = 100
# df['a'][0] có thể là 100 hoặc 1 — tùy thuộc vào ngữ cảnh!

# Trường hợp 2: Trả về bản sao (thay đổi KHÔNG ảnh hưởng df gốc)
subset2 = df[['a', 'b']]
subset2.iloc[0, 0] = 200
# df['a'][0] vẫn giữ nguyên

Cái cảnh báo SettingWithCopyWarning khét tiếng mà ai cũng từng gặp? Nó bắt nguồn từ đây.

2.3 Hành Vi Mới Trong Pandas 3.0

Với CoW, quy tắc trở nên đơn giản: mọi phép truy cập chỉ mục và kết quả trả về từ phương thức đều hoạt động như bản sao. Pandas vẫn dùng view nội bộ để tối ưu, nhưng chỉ thực sự sao chép khi bạn ghi dữ liệu:

import pandas as pd

df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})

# Lấy một cột — hành vi nhất quán trong pandas 3.0
subset = df['a']
subset.iloc[0] = 100

# df KHÔNG bị thay đổi — subset hoạt động như bản sao
print(df)
#    a  b
# 0  1  4
# 1  2  5
# 2  3  6

# Sửa đổi trực tiếp vẫn hoạt động bình thường
df.loc[0, 'a'] = 100
print(df)
#      a  b
# 0  100  4
# 1    2  5
# 2    3  6

Rõ ràng và dễ hiểu hơn rất nhiều, đúng không?

2.4 Gán Chuỗi (Chained Assignment) Không Còn Hoạt Động

Đây là thay đổi quan trọng mà bạn cần biết: gán chuỗi không còn hoạt động nữa.

import pandas as pd

df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})

# KHÔNG hoạt động trong pandas 3.0
# df['a'][0] = 100  # Chained assignment — sẽ không thay đổi df

# Cách đúng — dùng .loc hoặc .iloc
df.loc[0, 'a'] = 100      # Gán trực tiếp bằng loc
df.iloc[0, 0] = 100       # Gán trực tiếp bằng iloc

Nếu bạn có thói quen viết df['col'][idx] = value, giờ là lúc chuyển sang df.loc[idx, 'col'] = value.

2.5 Tối Ưu Hiệu Suất Với CoW

CoW giúp loại bỏ nhiều bản sao "phòng thủ" (defensive copies) không cần thiết. Kết quả? Hiệu suất cải thiện đáng kể:

import pandas as pd
import time

df = pd.DataFrame({'a': range(10_000_000), 'b': range(10_000_000)})

# Trước đây cần .copy() rõ ràng — bây giờ tự động tối ưu
start = time.time()
df2 = df[['a']]           # Không sao chép thực sự (lazy copy)
df3 = df.rename(columns={'a': 'x'})  # Không sao chép thực sự
df4 = df.reset_index()    # Không sao chép thực sự
elapsed = time.time() - start

print(f"Thời gian: {elapsed:.4f} giây")
# Nhanh hơn đáng kể vì không có sao chép dữ liệu thực sự

3. Cú Pháp Biểu Thức pd.col() — Viết Code Gọn Hơn Hẳn

3.1 Vấn Đề Với Lambda

Trước pandas 3.0, mỗi lần cần tham chiếu cột trong các phương thức như assign(), bạn phải viết hàm lambda lặp đi lặp lại. Nói thật là khá rườm rà:

# Cách cũ — dài dòng và khó đọc
df = pd.DataFrame({'gia': [100, 200, 300], 'so_luong': [2, 3, 1]})

df = df.assign(
    tong_tien=lambda x: x['gia'] * x['so_luong'],
    thue=lambda x: x['gia'] * x['so_luong'] * 0.1,
    thanh_toan=lambda x: x['gia'] * x['so_luong'] * 1.1
)

Ba cái lambda gần như giống nhau — nhìn mà mệt.

3.2 Cú Pháp pd.col() Mới

Với pd.col(), mọi thứ sạch hơn nhiều:

import pandas as pd

df = pd.DataFrame({'gia': [100, 200, 300], 'so_luong': [2, 3, 1]})

# Cách mới — sạch và dễ đọc
df = df.assign(
    tong_tien=pd.col('gia') * pd.col('so_luong'),
    thue=pd.col('gia') * pd.col('so_luong') * 0.1,
    thanh_toan=pd.col('gia') * pd.col('so_luong') * 1.1
)

print(df)
#    gia  so_luong  tong_tien  thue  thanh_toan
# 0  100         2      200.0  20.0       220.0
# 1  200         3      600.0  60.0       660.0
# 2  300         1      300.0  30.0       330.0

Cú pháp này lấy cảm hứng từ Polars (pl.col()), và cá nhân mình nghĩ đây là một trong những cải tiến "sướng" nhất của phiên bản mới.

3.3 Sử Dụng pd.col() Với Phương Thức Series

pd.col() hỗ trợ tất cả toán tử và phương thức Series, kể cả accessor .str:

import pandas as pd

df = pd.DataFrame({
    'ho_ten': ['nguyen van a', 'tran thi b', 'le van c'],
    'diem': [85, 92, 78],
    'lop': ['10A', '10B', '10A']
})

# Dùng pd.col() với phương thức chuỗi và tính toán
ket_qua = df.assign(
    ho_ten_in_hoa=pd.col('ho_ten').str.upper(),
    ho_ten_title=pd.col('ho_ten').str.title(),
    xep_loai=pd.col('diem').apply(
        lambda d: 'Giỏi' if d >= 90 else ('Khá' if d >= 70 else 'Trung bình')
    ),
    diem_chuan_hoa=pd.col('diem') / pd.col('diem').max() * 100
)

print(ket_qua)

3.4 pd.col() Trong Aggregation Và Groupby

import pandas as pd

df = pd.DataFrame({
    'san_pham': ['Laptop', 'Chuot', 'Ban phim', 'Laptop', 'Chuot'],
    'gia': [15000000, 250000, 500000, 18000000, 300000],
    'so_luong': [2, 10, 5, 1, 8]
})

# Tính tổng doanh thu theo sản phẩm
doanh_thu = df.assign(
    doanh_thu=pd.col('gia') * pd.col('so_luong')
).groupby('san_pham').agg(
    tong_doanh_thu=('doanh_thu', 'sum'),
    trung_binh_gia=('gia', 'mean'),
    tong_so_luong=('so_luong', 'sum')
).reset_index()

print(doanh_thu)

4. Tích Hợp Apache Arrow Sâu Hơn

4.1 Arrow PyCapsule Protocol

Đây là tính năng mà dân data engineering sẽ rất thích. Pandas 3.0 hỗ trợ Arrow PyCapsule Protocol, cho phép trao đổi dữ liệu zero-copy giữa pandas và các thư viện Arrow khác như Polars, DuckDB, và PyArrow:

import pandas as pd
import pyarrow as pa

# Tạo bảng Arrow
arrow_table = pa.table({
    'ten': ['An', 'Binh', 'Cuong'],
    'tuoi': [25, 30, 28],
    'luong': [15000000, 20000000, 18000000]
})

# Sử dụng from_arrow() mới — zero-copy import
df = pd.DataFrame.from_arrow(arrow_table)
print(df)
print(df.dtypes)

# Export ngược lại Arrow cũng zero-copy
arrow_table_2 = pa.RecordBatch.from_pandas(df)

4.2 Kết Hợp Pandas Với Polars Và DuckDB

Nhờ tích hợp Arrow sâu hơn, giờ bạn có thể kết hợp pandas, Polars, và DuckDB trong cùng một pipeline mà không bị "nghẽn cổ chai" ở bước chuyển đổi dữ liệu:

import pandas as pd
import polars as pl
import duckdb

# Bắt đầu với pandas DataFrame
df_pandas = pd.DataFrame({
    'ma_sv': range(1, 1001),
    'diem_toan': [round(5 + 5 * i / 1000, 2) for i in range(1000)],
    'diem_ly': [round(4 + 6 * i / 1000, 2) for i in range(1000)]
})

# Chuyển sang Polars — zero-copy nhờ Arrow
df_polars = pl.from_pandas(df_pandas)

# Xử lý nặng bằng Polars (nhanh hơn cho dữ liệu lớn)
ket_qua_polars = df_polars.with_columns(
    diem_tb=((pl.col('diem_toan') + pl.col('diem_ly')) / 2).round(2)
).filter(
    pl.col('diem_tb') >= 7.0
)

# Hoặc dùng DuckDB cho truy vấn SQL
con = duckdb.connect()
ket_qua_sql = con.sql("""
    SELECT *,
           (diem_toan + diem_ly) / 2 AS diem_tb
    FROM df_pandas
    WHERE (diem_toan + diem_ly) / 2 >= 7.0
    ORDER BY diem_tb DESC
""").df()

print(f"Kết quả từ Polars: {len(ket_qua_polars)} sinh viên")
print(f"Kết quả từ DuckDB: {len(ket_qua_sql)} sinh viên")

5. Thay Đổi Độ Phân Giải Datetime — Từ Nanosecond Sang Microsecond

5.1 Tại Sao Thay Đổi?

Trước pandas 3.0, kiểu datetime luôn dùng nanosecond (datetime64[ns]), dẫn đến phạm vi ngày bị giới hạn từ năm 1678 đến 2262. Nghe thì đủ dùng, nhưng nếu bạn làm việc với dữ liệu lịch sử hoặc dự đoán xa thì sẽ gặp lỗi ngay.

5.2 Hành Vi Mới

Pandas 3.0 tự suy luận độ phân giải phù hợp từ dữ liệu đầu vào, mặc định là microsecond:

import pandas as pd

# Pandas 3.0 — suy luận microsecond
ts = pd.to_datetime(["2024-03-22 11:36"])
print(ts.dtype)
# dtype: datetime64[us]

# Dữ liệu nanosecond vẫn giữ nguyên
ts_ns = pd.to_datetime(["2024-03-22 11:43:01.123456789"])
print(ts_ns.dtype)
# dtype: datetime64[ns]

# Giờ có thể làm việc với ngày lịch sử!
ngay_lich_su = pd.to_datetime(["1000-01-01", "1500-06-15", "1600-12-25"])
print(ngay_lich_su)
# DatetimeIndex(['1000-01-01', '1500-06-15', '1600-12-25'], dtype='datetime64[s]')

Cuối cùng cũng hết lỗi "OutOfBoundsDatetime" khi làm việc với dữ liệu trước năm 1678!

5.3 Cảnh Báo Khi Chuyển Đổi Sang Số Nguyên

Nếu code của bạn chuyển datetime sang số nguyên (qua thuộc tính .value), hãy cẩn thận — kết quả sẽ khác vì đơn vị giờ là microsecond thay vì nanosecond:

import pandas as pd

ts = pd.Timestamp("2024-01-01 12:00:00")

# Pandas 3.0: giá trị tính bằng microseconds
print(ts.value)
# 1704110400000000 (microseconds — nhỏ hơn 1000 lần so với trước)

# Nếu cần nanoseconds, chuyển đổi rõ ràng
ts_ns = ts.as_unit('ns')
print(ts_ns.value)
# 1704110400000000000 (nanoseconds)

6. Các Thay Đổi Quan Trọng Khác

6.1 Day Offset Theo Ngày Lịch

Trong pandas 3.0, pd.offsets.Day giờ đại diện cho ngày lịch (calendar day) thay vì đúng 24 giờ. Sự khác biệt này chỉ rõ ràng khi bạn làm việc với múi giờ có DST:

import pandas as pd

# Thời điểm trước DST chuyển đổi
ts = pd.Timestamp("2025-03-08 08:00", tz="US/Eastern")

# Pandas 3.0: giữ nguyên giờ trong ngày
ket_qua = ts + pd.offsets.Day(1)
print(ket_qua)
# 2025-03-09 08:00:00-04:00 (vẫn là 8 giờ sáng)

# Nếu muốn cộng chính xác 24 giờ:
ket_qua_24h = ts + pd.Timedelta(hours=24)
print(ket_qua_24h)
# 2025-03-09 09:00:00-04:00 (9 giờ sáng do DST)

6.2 Anti Join Trong Merge

Tính năng mà nhiều người chờ đợi: anti join. Nó giúp tìm các hàng chỉ tồn tại trong bảng bên trái — rất hữu ích trong thực tế:

import pandas as pd

# Danh sách tất cả sinh viên
tat_ca_sv = pd.DataFrame({
    'ma_sv': [1, 2, 3, 4, 5],
    'ten': ['An', 'Binh', 'Cuong', 'Dung', 'Em']
})

# Sinh viên đã nộp bài
da_nop = pd.DataFrame({
    'ma_sv': [1, 3, 5],
    'ngay_nop': ['2026-01-15', '2026-01-16', '2026-01-14']
})

# Tìm sinh viên CHƯA nộp bài — anti join
chua_nop = pd.merge(tat_ca_sv, da_nop, on='ma_sv', how='left_anti')
print(chua_nop)
#    ma_sv   ten
# 1      2  Binh
# 3      4  Dung

Không cần dùng workaround với indicator=True rồi lọc nữa!

6.3 Phương Thức inplace Trả Về self

Một cải tiến nhỏ nhưng tiện: các phương thức có inplace=True giờ trả về self thay vì None, cho phép method chaining:

import pandas as pd

df = pd.DataFrame({'b': [3, 1, 2], 'a': [6, 4, 5]})

# Pandas 3.0: inplace trả về self — hỗ trợ method chaining
ket_qua = df.sort_values('b', inplace=True).reset_index(drop=True, inplace=True)
print(df)
#    b  a
# 0  1  4
# 1  2  5
# 2  3  6

6.4 pytz Không Còn Bắt Buộc

Pandas 3.0 chuyển sang dùng module zoneinfo từ thư viện chuẩn Python, bỏ phụ thuộc vào pytz:

import pandas as pd

ts = pd.Timestamp(2026, 1, 1).tz_localize("Asia/Ho_Chi_Minh")
print(ts.tz)
# zoneinfo.ZoneInfo(key='Asia/Ho_Chi_Minh')

# Nếu cần pytz cho tương thích ngược:
# pip install pandas[timezone]

6.5 Hỗ Trợ Apache Iceberg

Nếu bạn làm data engineering, đây là tin vui: pandas 3.0 thêm phương thức read_iceberg() và DataFrame.to_iceberg() để đọc/ghi trực tiếp bảng Apache Iceberg:

import pandas as pd

# Đọc từ bảng Iceberg
# df = pd.read_iceberg("s3://my-bucket/my-iceberg-table")

# Ghi vào bảng Iceberg
# df.to_iceberg("s3://my-bucket/my-iceberg-table")

6.6 Xử Lý NaN Nhất Quán Với Nullable Dtypes

NaN giờ được xử lý nhất quán với NA trong các kiểu dữ liệu nullable. Đây là thay đổi nhỏ nhưng ảnh hưởng lớn nếu bạn hay làm việc với phép chia cho 0:

import pandas as pd
import numpy as np

ser = pd.Series([0, np.nan], dtype=pd.Float64Dtype())

# Pandas 3.0: 0/0 = NA (được coi là missing)
ket_qua = ser / 0
print(ket_qua)
# 0    <NA>
# 1    <NA>

print(ket_qua.isna())
# 0    True
# 1    True

7. Tính Năng I/O Mới

7.1 Cải Thiện read_parquet()

import pandas as pd

# Tham số mới to_pandas_kwargs cho phép tùy chỉnh chuyển đổi
df = pd.read_parquet(
    'du_lieu.parquet',
    to_pandas_kwargs={'types_mapper': pd.ArrowDtype}  # Giữ nguyên kiểu Arrow
)

7.2 Cải Thiện to_excel()

import pandas as pd

df = pd.DataFrame({
    'San_pham': ['Laptop', 'Chuot', 'Ban phim'],
    'Gia': [15000000, 250000, 500000],
    'Ton_kho': [50, 200, 100]
})

# Tham số mới: autofilter — tự động thêm bộ lọc Excel
df.to_excel('bao_cao.xlsx', autofilter=True, index=False)

# Hỗ trợ f-string trong float_format của to_csv()
df.to_csv('bao_cao.csv', float_format='{:.2f}'.format)

8. Chiến Lược Di Chuyển Lên Pandas 3.0

8.1 Lộ Trình Nâng Cấp

Đội ngũ pandas khuyến nghị quy trình di chuyển 3 bước (và theo kinh nghiệm mình, cách này thực sự hiệu quả):

  1. Bước 1 — Nâng cấp lên pandas 2.3: Đây là phiên bản cầu nối, sẽ hiển thị tất cả cảnh báo deprecation liên quan đến pandas 3.0
  2. Bước 2 — Sửa hết cảnh báo: Chạy test suite với -W error::DeprecationWarning để đảm bảo không sót cảnh báo nào
  3. Bước 3 — Nâng cấp lên pandas 3.0: Sau khi sửa hết, việc nâng cấp sẽ suôn sẻ hơn rất nhiều

Đừng cố nhảy thẳng từ pandas 1.x hay 2.0 lên 3.0 — bạn sẽ gặp rất nhiều lỗi khó debug.

8.2 Checklist Di Chuyển

Dưới đây là danh sách kiểm tra mà bạn nên chạy qua trước khi deploy code lên production với pandas 3.0:

# 1. Kiểm tra phiên bản Python (cần 3.11+)
import sys
print(f"Python: {sys.version}")
assert sys.version_info >= (3, 11), "Cần Python 3.11+"

# 2. Cài đặt pandas 3.0
# pip install pandas==3.0.0

# 3. Kiểm tra kiểu dữ liệu chuỗi
import pandas as pd
df = pd.read_csv('du_lieu.csv')
print(df.dtypes)
# Cột chuỗi nên hiển thị 'str' thay vì 'object'

# 4. Kiểm tra chained assignment
# Tìm và thay thế tất cả:
#   df['col'][idx] = value  →  df.loc[idx, 'col'] = value

# 5. Kiểm tra datetime
# Nếu code dùng .value trên Timestamp, kết quả sẽ khác
# Thêm .as_unit('ns') nếu cần nanoseconds

# 6. Kiểm tra xử lý timezone
# Nếu code kiểm tra isinstance(tz, pytz.tzinfo), cần cập nhật
# import zoneinfo
# isinstance(tz, zoneinfo.ZoneInfo)

8.3 Xử Lý Các Thay Đổi Phá Vỡ Phổ Biến

import pandas as pd

# --- concat với sort=False: giờ được tôn trọng ---
# Giải pháp: Dùng sort=True nếu cần sắp xếp

# --- value_counts(sort=False): giữ nguyên thứ tự đầu vào ---
# Giải pháp: Dùng .sort_index() nếu cần sắp xếp theo nhãn

# --- Tham số copy= bị deprecated (CoW quản lý tự động) ---
# Giải pháp: Xóa tham số copy= khỏi tất cả lời gọi

# --- Chuỗi tần suất: yêu cầu viết hoa ---
# Giải pháp: Cập nhật frequency strings ('d' → 'D', 'w' → 'W')

# Ví dụ cụ thể
df = pd.DataFrame(
    {'gia': [100, 200, 150, 300]},
    index=pd.date_range('2026-01-01', periods=4, freq='D')
)
print(df.resample('D').mean())

9. Chính Sách Deprecation Mới (PDEP 17)

Pandas 3.0 có chính sách deprecation 3 giai đoạn rõ ràng hơn, giúp bạn chuẩn bị tốt hơn cho các bản cập nhật tương lai:

  1. DeprecationWarning: Cảnh báo ban đầu, chỉ hiện trong môi trường dev
  2. FutureWarning: Cảnh báo mạnh hơn, hiện cho tất cả người dùng
  3. Removal: Tính năng bị xóa hoàn toàn

Ngoài ra, pandas 3.0 giới thiệu các lớp cảnh báo mới cho biết chính xác tính năng sẽ bị xóa ở phiên bản nào:

# Các lớp cảnh báo mới
import pandas as pd

# pandas.errors.Pandas4Warning — sẽ bị xóa trong pandas 4.0
# pandas.errors.Pandas5Warning — sẽ bị xóa trong pandas 5.0
# pandas.errors.PandasChangeWarning — lớp cơ sở

# Lọc cảnh báo cụ thể
import warnings
warnings.filterwarnings('error', category=pd.errors.Pandas4Warning)

# Chạy code để phát hiện tất cả tính năng sắp bị xóa

Mình thấy đây là một cải tiến rất hay — giúp bạn biết chính xác mình còn bao lâu để cập nhật code, thay vì chỉ nhận một cảnh báo chung chung.

10. Yêu Cầu Hệ Thống Tối Thiểu

Trước khi nâng cấp, hãy kiểm tra xem môi trường của bạn đáp ứng các yêu cầu tối thiểu:

  • Python: 3.11 trở lên (bỏ hỗ trợ Python 3.9, 3.10)
  • NumPy: 1.26.0 trở lên
  • PyArrow: 13.0.0 trở lên (tùy chọn nhưng rất nên cài)
# Kiểm tra môi trường
import sys
print(f"Python: {sys.version}")

import numpy as np
print(f"NumPy: {np.__version__}")

import pandas as pd
print(f"Pandas: {pd.__version__}")

try:
    import pyarrow as pa
    print(f"PyArrow: {pa.__version__}")
except ImportError:
    print("PyArrow: Chưa cài đặt (khuyến nghị cài đặt)")

# Cài đặt đầy đủ
# pip install pandas[all]==3.0.0
# hoặc
# pip install pandas==3.0.0 pyarrow>=13.0.0

Kết Luận

Pandas 3.0 thực sự là bản cập nhật đáng mong đợi nhất trong lịch sử của thư viện. Nó giải quyết nhiều vấn đề "kinh điển" mà cộng đồng phàn nàn từ lâu, đồng thời đưa pandas vào kỷ nguyên mới với hiệu suất cao hơn và API nhất quán hơn.

Tóm tắt nhanh những điểm chính:

  • Kiểu str mặc định: Giảm ~50% bộ nhớ, nhanh hơn 5-10x cho phép toán chuỗi
  • Copy-on-Write: Vĩnh biệt SettingWithCopyWarning, hành vi nhất quán và dễ đoán
  • pd.col(): Cú pháp biểu thức mới, tạm biệt lambda rườm rà
  • Arrow tích hợp: Zero-copy data exchange với Polars, DuckDB, PyArrow
  • Datetime linh hoạt: Hết giới hạn phạm vi nanosecond
  • Anti join: Cuối cùng cũng có left_anti trong merge
  • Apache Iceberg: Đọc/ghi trực tiếp bảng Iceberg

Lời khuyên của mình: hãy bắt đầu từ pandas 2.3, sửa hết cảnh báo deprecation, rồi mới nâng lên 3.0. Đừng vội — chuẩn bị kỹ thì chuyển đổi sẽ mượt mà hơn nhiều, và bạn sẽ ngay lập tức cảm nhận được sự khác biệt mà phiên bản mới mang lại.