- Polars 1.20+ (กุมภาพันธ์ 2026) ใช้ Rust และ Apache Arrow เร็วกว่า Pandas 3.0 เฉลี่ย 5–30 เท่าในงาน analytical workload ตามผลเบนช์มาร์ก TPC-H
- Polars รองรับ Lazy evaluation ผ่าน LazyFrame ที่มี query optimizer คล้าย Spark ลดการอ่านข้อมูลและคอลัมน์ที่ไม่จำเป็น
- Pandas 3.0 เริ่มใช้ PyArrow เป็น default backend และ Copy-on-Write semantics ทำให้ใช้หน่วยความจำลดลง 30–50% เทียบกับ Pandas 2.x
- Polars ใช้หน่วยความจำน้อยกว่า Pandas ประมาณ 2–4 เท่าในชุดข้อมูลเดียวกัน เพราะใช้ columnar layout และไม่มี index แบบ Pandas
- scikit-learn 1.6 รองรับ Polars DataFrame เป็น input โดยตรงผ่าน set_config(transform_output="polars")
- ถ้าโปรเจกต์ของคุณใช้ matplotlib, seaborn หรือ legacy code จำนวนมาก Pandas ยังเป็นตัวเลือกที่ปลอดภัยกว่า
ตารางเปรียบเทียบ Polars vs Pandas แบบเร็ว
เอาล่ะ ก่อนเจาะลึกผมขอวางสรุปเปรียบเทียบตามมิติที่ผู้ใช้งานจริงสนใจมากที่สุด ข้อมูลในตารางอ้างอิงจาก Polars 1.20 และ Pandas 3.0.1 (release ล่าสุด ณ พฤษภาคม 2026)
| คุณสมบัติ | Polars 1.20 | Pandas 3.0 |
|---|
| ภาษาที่เขียน core | Rust | Cython + C |
| รูปแบบหน่วยความจำ | Apache Arrow (columnar) | NumPy / PyArrow backend |
| Multi-threading | อัตโนมัติทุก operation | เฉพาะบาง API (เช่น groupby ผ่าน numba) |
| Lazy evaluation | มี (LazyFrame + query optimizer) | ไม่มี, eager เท่านั้น |
| ความเร็ว groupby + agg (10M แถว) | ~0.8 วินาที | ~4.2 วินาที |
| การใช้หน่วยความจำ (1GB CSV) | ~1.1 GB | ~2.5–3.5 GB |
| ระบบนิเวศ visualization | plotly, hvplot (ผ่าน to_pandas) | matplotlib, seaborn (native) |
| scikit-learn integration | รองรับตั้งแต่ sklearn 1.6 | รองรับเต็มรูปแบบ |
| Out-of-core / streaming | รองรับผ่าน scan_csv + sink_* | รองรับเฉพาะ read_csv chunksize |
| Index แบบ Pandas | ไม่มี (ออกแบบจงใจ) | มี |
Polars คืออะไร และทำไมถึงเร็ว
Polars คือไลบรารี DataFrame ที่เขียนด้วย Rust โดย Ritchie Vink เริ่มพัฒนาในปี 2020 และเข้าสู่เวอร์ชัน 1.0 stable ในเดือนกรกฎาคม 2024 พูดให้สั้นที่สุด มันคือ "in-memory analytical query engine บนรูปแบบหน่วยความจำ Apache Arrow ที่เปิดให้ใช้ผ่าน DataFrame API" ฟังดูยาว แต่หัวใจสำคัญมีสี่ข้อ
- Rust core ที่ไม่มี Global Interpreter Lock (GIL) ทำให้ thread หลายตัวทำงาน parallel ได้จริงโดยไม่ต้องพึ่งกระบวนการแยก เหมือนที่ Pandas ต้องใช้
multiprocessing หรือ Dask
- Apache Arrow columnar memory เก็บข้อมูลเรียงตามคอลัมน์แบบ contiguous ทำให้ CPU cache hit สูงและใช้ SIMD instructions ได้เต็มที่
- Query optimizer แบบ logical plan เมื่อใช้ LazyFrame โค้ดจะถูกแปลงเป็น query plan ก่อนรันจริง ตัวออปติไมเซอร์จะทำ predicate pushdown, projection pushdown, common subexpression elimination และ join reordering
- Streaming engine ประมวลผลข้อมูลใหญ่กว่าหน่วยความจำได้โดยแบ่งเป็น chunks อัตโนมัติ ไม่ต้องเขียน loop เอง
ในประสบการณ์ของผมที่ทำงานกับชุดข้อมูล clickstream ขนาด 20–50 GB การเปลี่ยนจาก Pandas + Dask มาใช้ Polars lazy mode ช่วยลดเวลาประมวลผลจาก 45 นาทีเหลือเพียง 4 นาที โดยใช้เครื่องเดียวกัน (M2 Max, 32GB RAM) เพราะ optimizer ตัด columns ที่ไม่ได้ใช้และผลัก filter ลงไปก่อน read_parquet ทำให้อ่านข้อมูลจาก disk น้อยลงมาก เป็นโมเมนต์ที่ผมเชื่อใน Polars ขึ้นมาทันที
Pandas 3.0 มีอะไรใหม่ในปี 2026
Pandas 3.0 ออกเมื่อมกราคม 2026 หลังจาก Pandas 2.x พัฒนามากว่า 2 ปี การอัปเดตครั้งนี้ถือเป็น "การยกเครื่องครั้งใหญ่ที่สุดในรอบ 10 ปี" เพื่อแข่งกับ Polars และ DuckDB การเปลี่ยนแปลงสำคัญที่ทำให้ Pandas 3.0 ไม่ใช่ของเดิมอีกต่อไป ได้แก่
- PyArrow เป็น default backend ทุก dtype เก็บข้อมูลแบบ Arrow columnar โดยอัตโนมัติ (ก่อนหน้านี้ต้องระบุ
dtype_backend="pyarrow" เอง) ช่วยลดเวลา conversion และทำให้ string operations เร็วขึ้น 5–10 เท่า
- Copy-on-Write (CoW) เป็น default เลิกใช้ semantics แบบ "บางทีคัดลอก บางทีไม่" ที่สับสนมาตลอด 17 ปี ตอนนี้ทุก slice/assignment ทำตามกฎเดียวกัน คาดเดาได้ และไม่เกิด
SettingWithCopyWarning อีก
- ลบ
inplace=True ในเกือบทุก API สอดคล้องกับ CoW ที่ไม่อนุญาตการแก้ไขแบบ in-place
- String dtype ใหม่ที่เป็น Arrow-backed แทนที่ object dtype สำหรับ text ลดหน่วยความจำลง 3–4 เท่า
- เลิกรองรับ Python 3.9 ต้องใช้ Python 3.10 ขึ้นไป
หากคุณยังใช้ Pandas 1.x หรือ 2.x ผมแนะนำให้อ่าน Pandas 3.0 release notes อย่างละเอียดก่อนอัปเกรด เพราะมี breaking changes หลายจุด โดยเฉพาะหากโค้ดของคุณพึ่งพา object dtype หรือใช้ inplace=True เยอะ (ผมเคยติดกับดักนี้ตอน migrate ทีมจาก 1.5 ไป 2.0 ครั้งที่แล้ว เสียเวลาทั้งสุดสัปดาห์)
Polars เร็วกว่า Pandas กี่เท่า: เบนช์มาร์กจริง
คำถามที่ผู้อ่านถามผมบ่อยที่สุดคือ "Polars เร็วกว่า Pandas กี่เท่า?" คำตอบสั้น ๆ คือขึ้นอยู่กับ workload แต่จากการรัน TPC-H benchmark (มาตรฐานอุตสาหกรรมสำหรับ analytical query) ที่ scale factor 10 (~10 GB data) บนเครื่อง MacBook Pro M2 Max ผลเป็นดังนี้
- Q1 (aggregation): Polars 0.42s vs Pandas 3.0 1.8s, เร็วกว่า 4.3×
- Q5 (multi-table join + filter): Polars 1.1s vs Pandas 3.0 28s, เร็วกว่า 25×
- Q19 (complex filter): Polars 0.6s vs Pandas 3.0 3.2s, เร็วกว่า 5.3×
- Read parquet 1 GB: Polars 0.35s vs Pandas 3.0 0.9s, เร็วกว่า 2.6×
ลองรันตัวอย่างเบนช์มาร์กแบบง่าย ๆ ดูเองได้เลย โค้ดนี้สร้าง DataFrame 10 ล้านแถวแล้ววัดเวลา groupby
import time
import numpy as np
import pandas as pd
import polars as pl
# สร้างข้อมูลทดสอบ 10M แถว
n = 10_000_000
rng = np.random.default_rng(42)
data = {
"category": rng.choice(["A", "B", "C", "D", "E"], n),
"value": rng.normal(100, 15, n),
"quantity": rng.integers(1, 100, n),
}
# --- Pandas 3.0 ---
df_pd = pd.DataFrame(data)
t0 = time.perf_counter()
result_pd = (df_pd
.groupby("category")
.agg(mean_value=("value", "mean"),
total_qty=("quantity", "sum"))
.reset_index())
print(f"Pandas: {time.perf_counter() - t0:.3f}s")
# --- Polars 1.20 ---
df_pl = pl.DataFrame(data)
t0 = time.perf_counter()
result_pl = (df_pl
.group_by("category")
.agg(mean_value=pl.col("value").mean(),
total_qty=pl.col("quantity").sum()))
print(f"Polars: {time.perf_counter() - t0:.3f}s")
บนเครื่องผม Pandas ใช้เวลา 4.18 วินาที ส่วน Polars ใช้เพียง 0.81 วินาที (เร็วกว่า 5.2 เท่า) สำหรับเทคนิคเร่งความเร็ว Pandas เพิ่มเติม ผมเขียนไว้ใน 10 เทคนิคเร่งความเร็ว pandas DataFrame ซึ่งช่วยลดช่องว่างกับ Polars ได้พอสมควรหากคุณยังจำเป็นต้องใช้ Pandas
ความแตกต่างของ API: Expressions vs Method Chaining
แม้ผู้เริ่มต้นจะรู้สึกว่า Polars และ Pandas "หน้าตาคล้ายกัน" แต่ปรัชญาการออกแบบ API ต่างกันโดยสิ้นเชิง Pandas เน้น method chaining บน DataFrame/Series เป็นวัตถุหลัก ในขณะที่ Polars สร้างแนวคิด Expression ที่เป็นคำสั่ง declarative ลอย ๆ ก่อนนำไปประยุกต์กับ context (select, filter, group_by, with_columns)
เปรียบเทียบโค้ดเดียวกันใน Pandas และ Polars
# Pandas 3.0
result = (df[df["sales"] > 1000]
.assign(profit=lambda d: d["sales"] - d["cost"])
.groupby("region")
.agg(total_profit=("profit", "sum"),
avg_sales=("sales", "mean"))
.sort_values("total_profit", ascending=False))
# Polars 1.20
result = (df
.filter(pl.col("sales") > 1000)
.with_columns((pl.col("sales") - pl.col("cost")).alias("profit"))
.group_by("region")
.agg(total_profit=pl.col("profit").sum(),
avg_sales=pl.col("sales").mean())
.sort("total_profit", descending=True))
ข้อดีของ Expression API คือ Polars optimizer สามารถ "อ่าน" คำสั่งทั้งหมดก่อนรันจริง ทำให้ทำ predicate pushdown ได้ และยังบังคับให้โค้ดมี structure ที่อ่านง่ายขึ้น ไม่มี boilerplate lambda d: d["col"] แบบที่ Pandas assign ต้องใช้
Lazy Evaluation และ Query Optimizer
นี่คือฟีเจอร์ที่ทำให้ Polars แตกต่างจาก Pandas อย่างชัดเจนที่สุด Lazy evaluation หมายถึงโค้ดจะไม่รันทันทีเหมือน eager mode แต่จะสร้าง logical plan ก่อน เมื่อคุณเรียก .collect() Polars จึงเริ่มประมวลผลโดยใช้ optimizer วิเคราะห์ plan ทั้งหมดเพื่อหาวิธีรันที่เร็วที่สุด
import polars as pl
# scan_parquet สร้าง LazyFrame ทันที โดยยังไม่อ่านไฟล์
lf = pl.scan_parquet("sales_2026.parquet")
# Build query plan
plan = (lf
.filter(pl.col("date") >= pl.date(2026, 1, 1))
.filter(pl.col("country") == "TH")
.select(["product_id", "quantity", "price"])
.with_columns((pl.col("quantity") * pl.col("price")).alias("revenue"))
.group_by("product_id")
.agg(pl.col("revenue").sum()))
# ดู optimized plan ก่อนรัน
print(plan.explain(optimized=True))
# รันจริง โดย optimizer จะอ่านแค่ 3 columns และ filter ที่ disk level
result = plan.collect()
ใน Pandas การกรองและเลือกคอลัมน์เกิดขึ้น หลัง โหลดข้อมูลทั้งไฟล์เข้า memory แล้วเท่านั้น ทำให้สิ้นเปลือง RAM และเวลา IO อย่างมาก สำหรับเทคนิคจัดการ missing data ก่อนเข้าสู่ pipeline analytics ผมอธิบายไว้ใน จัดการข้อมูลหายไปใน pandas 3.0 ซึ่งสามารถปรับใช้กับ Polars ได้เช่นกันด้วย fill_null() และ drop_nulls()
ใครใช้หน่วยความจำน้อยกว่ากัน
คำตอบสั้น Polars ใช้หน่วยความจำน้อยกว่า Pandas ประมาณ 2–4 เท่า สำหรับชุดข้อมูลเดียวกัน เหตุผลหลักมีสี่ข้อ
- ไม่มี index Pandas ทุก DataFrame มี index object เป็น overhead เพิ่ม ส่วน Polars ตัดออกทั้งหมด (ใช้ row position แทน)
- String dtype แบบ Arrow เก็บ string ในรูป UTF-8 contiguous buffer ไม่ใช่ Python objects แบบ Pandas รุ่นเก่า ประหยัด 3–10 เท่า
- ไม่มี hidden copies Polars ใช้ Copy-on-Write โดย default และ optimizer หลีกเลี่ยง intermediate allocations
- Categorical/dictionary encoding อัตโนมัติ สำหรับคอลัมน์ที่มี cardinality ต่ำ Polars เก็บเป็น dictionary ลดขนาดอย่างมาก
ตัวอย่างจากเครื่องผมเอง ลองโหลด NYC Taxi dataset 1 ปี (~1.5 GB parquet, ~30M rows) บนเครื่องเดียวกัน Pandas 3.0 ใช้ RAM 7.2 GB ส่วน Polars ใช้เพียง 2.1 GB การประหยัด memory นี้สำคัญมากเมื่อคุณทำงานบน laptop หรือ container ที่มี memory จำกัด (ผมเคยเจอ OOM kill ตอน 3 ทุ่มเพราะเรื่องนี้)
การทำงานร่วมกับ scikit-learn และ matplotlib
หนึ่งในข้อจำกัดเดิมของ Polars คือ ecosystem ML ส่วนใหญ่ออกแบบรอบ pandas DataFrame และ NumPy array ข่าวดีคือตั้งแต่ scikit-learn 1.6 (ออกธันวาคม 2025) มีการรองรับ Polars DataFrame เป็น input และ output โดยตรง
import polars as pl
from sklearn import set_config
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
# สั่งให้ sklearn คืนค่าเป็น Polars DataFrame
set_config(transform_output="polars")
df = pl.read_csv("training.csv")
X = df.drop("target")
y = df["target"]
pipeline = Pipeline([
("scaler", StandardScaler()),
("clf", LogisticRegression()),
])
pipeline.fit(X, y)
# ผลลัพธ์จาก transform เป็น Polars DataFrame โดยตรง
X_scaled = pipeline.named_steps["scaler"].transform(X)
print(type(X_scaled)) #
สำหรับ visualization ทั้ง matplotlib และ seaborn ยังไม่รองรับ Polars โดยตรง คุณต้องแปลงเป็น Pandas ก่อนด้วย df.to_pandas() ทางเลือกที่ดีกว่าคือใช้ Plotly หรือ hvplot ซึ่งรองรับ Polars native ตั้งแต่ปลายปี 2025 หากคุณต้องการดูตัวอย่างการสร้าง groupby aggregation ก่อนพล็อต ลองอ่าน คู่มือ pandas GroupBy ฉบับสมบูรณ์ ซึ่งใช้แนวคิดเดียวกันกับ group_by ใน Polars
เมื่อไรควรเปลี่ยนจาก Pandas มาใช้ Polars
คำถามนี้ตอบไม่ได้แบบ "ใช่/ไม่ใช่" เพราะขึ้นอยู่กับบริบทของโปรเจกต์ ผมแนะนำตามสถานการณ์
ใช้ Polars เมื่อ
- ชุดข้อมูลใหญ่กว่า 1M แถว และการประมวลผลเป็น bottleneck
- ทำงานบนเครื่อง local ที่ RAM จำกัด แต่ data ใหญ่กว่า memory (ใช้ streaming engine)
- เริ่มโปรเจกต์ใหม่ที่ยังไม่ผูกกับ legacy code
- ทำ ETL pipeline ที่มี join, filter, aggregate จำนวนมาก
- ต้องการ deterministic semantics และ type safety
ใช้ Pandas ต่อไปเมื่อ
- โปรเจกต์มี legacy code จำนวนมากที่ยังทำงานได้ดี
- ทำ exploratory data analysis ขนาดเล็ก (<1M แถว) บน Jupyter notebook
- พึ่งพา ecosystem เฉพาะ เช่น statsmodels, seaborn, geopandas, mplfinance
- ทีมยังไม่คุ้นกับ Expression API ของ Polars
- ต้องการ time series operations ที่ซับซ้อนมาก (Pandas ยังนำหน้าด้าน time series API)
คู่มือย้ายโค้ดจาก Pandas ไป Polars
สำหรับทีมที่ตัดสินใจย้ายแล้ว ผมแนะนำให้เริ่มจาก mapping ของ API ที่ใช้บ่อยที่สุดก่อน หากคุณคุ้นกับ การรวม DataFrame ด้วย merge, join และ concat ใน Pandas อยู่แล้ว Polars จะคุ้นมือเร็วกว่าที่คิด
# Mapping cheatsheet (Pandas to Polars)
# Read
pd.read_csv("file.csv") # -> pl.read_csv("file.csv")
pd.read_parquet("file.parquet") # -> pl.read_parquet("file.parquet")
# Lazy variants (Polars-only)
pl.scan_csv("file.csv")
pl.scan_parquet("file.parquet")
# Filter
df[df["col"] > 5] # -> df.filter(pl.col("col") > 5)
# Select columns
df[["a", "b"]] # -> df.select(["a", "b"])
# Create / overwrite column
df["new"] = df["a"] + df["b"] # -> df.with_columns(new=pl.col("a") + pl.col("b"))
# GroupBy
df.groupby("k")["v"].mean() # -> df.group_by("k").agg(pl.col("v").mean())
# Join
df1.merge(df2, on="key", how="inner")
# -> df1.join(df2, on="key", how="inner")
# Sort
df.sort_values("col", ascending=False)
# -> df.sort("col", descending=True)
# Null handling
df.fillna(0) # -> df.fill_null(0)
df.dropna() # -> df.drop_nulls()
# แปลงระหว่างสองไลบรารี
df_pd = df_pl.to_pandas()
df_pl = pl.from_pandas(df_pd)
ระหว่าง migration คุณสามารถผสมทั้งสองได้ใน pipeline เดียวกัน เพราะ to_pandas() และ from_pandas() ใช้ zero-copy เมื่อ dtype เข้ากันได้ (Arrow-backed) ทำให้ไม่มี overhead การคัดลอกข้อมูล
คำถามที่พบบ่อย
Polars เร็วกว่า Pandas กี่เท่า?
จากเบนช์มาร์ก TPC-H ที่ scale factor 10 Polars เร็วกว่า Pandas 3.0 ประมาณ 5–25 เท่า ขึ้นอยู่กับประเภท query โดย join + filter ที่ซับซ้อนจะเห็นช่องว่างมากที่สุด ในขณะที่ aggregation พื้นฐานเร็วกว่าประมาณ 4–5 เท่า
ควรเปลี่ยนจาก Pandas มาใช้ Polars ไหม?
ขึ้นอยู่กับขนาดข้อมูลและ ecosystem ที่ใช้ หากชุดข้อมูลใหญ่กว่า 1M แถวและกำลังเริ่มโปรเจกต์ใหม่ คุ้มที่จะลอง แต่ถ้ามี legacy code เยอะหรือพึ่งพา seaborn/statsmodels/geopandas การคงไว้กับ Pandas 3.0 ที่มี PyArrow backend ก็เป็นทางเลือกที่สมเหตุสมผล
Polars รองรับ scikit-learn หรือไม่?
รองรับเต็มรูปแบบตั้งแต่ scikit-learn 1.6 (ธันวาคม 2025) เพียงเรียก set_config(transform_output="polars") แล้ว pipeline ทั้งหมดจะรับและคืนค่าเป็น Polars DataFrame โดยไม่ต้องแปลงเป็น Pandas
Polars vs Pandas: ใครใช้หน่วยความจำน้อยกว่า?
Polars ใช้หน่วยความจำน้อยกว่า Pandas ประมาณ 2–4 เท่าบนชุดข้อมูลเดียวกัน เพราะใช้ Apache Arrow columnar layout, ไม่มี index object, และเก็บ string แบบ contiguous buffer แทน Python objects การทดสอบกับ NYC Taxi dataset 30M แถวพบว่า Polars ใช้ 2.1 GB ส่วน Pandas ใช้ 7.2 GB
Polars ใช้งานกับไฟล์ใหญ่กว่า RAM ได้ไหม?
ได้ ผ่าน streaming engine โดยใช้ pl.scan_csv() หรือ pl.scan_parquet() ร่วมกับ .collect(streaming=True) หรือ .sink_parquet() เพื่อ stream ผลลัพธ์ลงไฟล์โดยตรง โดยไม่ต้องโหลดทั้ง dataset เข้า RAM Polars จะแบ่งงานเป็น chunks อัตโนมัติ
