Polars vs Pandas ในปี 2026: ประสิทธิภาพ ไวยากรณ์ และคำถามสัมภาษณ์ Data Analyst

# benchmark_comparison.py
import polars as pl
import pandas as pd
import time

# Polars: lazy evaluation พร้อม predicate pushdown
start = time.perf_counter()
result_polars = (
    pl.scan_parquet("sales_data_14gb.parquet")  # Lazy: ยังไม่โหลดข้อมูล
    .filter(pl.col("region") == "EMEA")         # Predicate ถูกส่งไปที่ file reader
    .group_by("product_category")
    .agg(pl.col("revenue").sum())
    .collect()                                   # การประมวลผลเกิดขึ้นที่นี่
)
polars_time = time.perf_counter() - start

# Pandas: eager evaluation โหลดไฟล์ทั้งหมด
start = time.perf_counter()
df = pd.read_parquet("sales_data_14gb.parquet")  # ทั้ง 14 GB ถูกโหลดเข้าหน่วยความจำ
result_pandas = (
    df[df["region"] == "EMEA"]                   # Filter ถูกใช้หลังจากโหลด
    .groupby("product_category")["revenue"]
    .sum()
)
pandas_time = time.perf_counter() - start

print(f"Polars: {polars_time:.2f}s | Pandas: {pandas_time:.2f}s")
# ผลลัพธ์ทั่วไป: Polars: 1.2s | Pandas: 13.2s

# lazy_evaluation_example.py
import polars as pl

# กำหนด lazy query (ยังไม่ประมวลผล)
lazy_query = (
    pl.scan_csv("transactions_50gb.csv")   # LazyFrame: มีแค่ schema ไม่มีข้อมูล
    .filter(pl.col("amount") > 1000)       # เพิ่มใน query plan
    .filter(pl.col("status") == "completed")  # รวมกับ filter ด้านบน
    .select(["transaction_id", "amount", "customer_id"])  # Projection pushdown
    .group_by("customer_id")
    .agg([
        pl.col("amount").sum().alias("total_spent"),
        pl.col("transaction_id").count().alias("transaction_count")
    ])
)

# ดู query plan ที่ปรับแต่งแล้ว
print(lazy_query.explain())
# แสดง: predicate pushdown, projection pushdown, filter combination

# ประมวลผลเมื่อพร้อม
result = lazy_query.collect()

# pandas_3_new_features.py
import pandas as pd

# Backend string PyArrow ตอนนี้เป็นค่าเริ่มต้น (การดำเนินการ string เร็วขึ้น 5-10x)
df = pd.read_csv("users.csv")  # String ตอนนี้เป็น string[pyarrow] ตามค่าเริ่มต้น

# Expression builder ใหม่ (ไวยากรณ์คล้าย Polars)
result = df.select(
    pd.col("name").str.upper(),
    pd.col("age") * 2,
    (pd.col("salary") > 100000).alias("high_earner")
)

# Copy-on-Write ขจัด SettingWithCopyWarning
subset = df[df["age"] > 30]  # คืนค่า view ไม่ใช่ copy
subset = subset.copy()        # ต้องการ copy อย่างชัดเจนสำหรับ mutation

# วิธี Arrow interop ใหม่
import pyarrow as pa
arrow_table = pa.table({"x": [1, 2, 3]})
df = pd.DataFrame.from_arrow(arrow_table)  # Import แบบ zero-copy

# filtering_comparison.py
import polars as pl
import pandas as pd

# ข้อมูลตัวอย่าง
data = {
    "name": ["Alice", "Bob", "Charlie", "Diana"],
    "department": ["Engineering", "Sales", "Engineering", "HR"],
    "salary": [95000, 72000, 88000, 65000],
    "years": [5, 3, 7, 2]
}

# POLARS: การอ้างอิงคอลัมน์อย่างชัดเจนด้วย pl.col()
df_pl = pl.DataFrame(data)
result_pl = (
    df_pl
    .filter(pl.col("department") == "Engineering")  # Filter ด้วย pl.col()
    .filter(pl.col("salary") > 80000)               # Chain filters
    .select(["name", "salary"])                     # เลือกคอลัมน์
)

# PANDAS: สัญกรณ์ bracket
df_pd = pd.DataFrame(data)
result_pd = (
    df_pd
    .loc[df_pd["department"] == "Engineering"]  # loc สำหรับ filtering
    .loc[lambda x: x["salary"] > 80000]         # Lambda สำหรับ chaining
    [["name", "salary"]]                        # Bracket สำหรับ selection
)

# aggregation_comparison.py

# POLARS: ไวยากรณ์ aggregation ที่แสดงออก
result_pl = (
    df_pl
    .group_by("department")
    .agg([
        pl.col("salary").mean().alias("avg_salary"),
        pl.col("salary").max().alias("max_salary"),
        pl.col("name").count().alias("headcount"),
        (pl.col("salary") * pl.col("years")).sum().alias("total_compensation_years")
    ])
)

# PANDAS: ไวยากรณ์ named aggregation
result_pd = (
    df_pd
    .groupby("department")
    .agg(
        avg_salary=("salary", "mean"),
        max_salary=("salary", "max"),
        headcount=("name", "count"),
        total_compensation_years=("salary", lambda x: (df_pd.loc[x.index, "salary"] * df_pd.loc[x.index, "years"]).sum())
    )
)

# joins_comparison.py

employees = pl.DataFrame({
    "emp_id": [1, 2, 3],
    "name": ["Alice", "Bob", "Charlie"],
    "dept_id": [10, 20, 10]
})

departments = pl.DataFrame({
    "dept_id": [10, 20, 30],
    "dept_name": ["Engineering", "Sales", "HR"]
})

# POLARS: ไวยากรณ์ join อย่างชัดเจน
result_pl = employees.join(
    departments,
    on="dept_id",      # คอลัมน์ join
    how="left"         # ประเภท join: left, inner, outer, cross, semi, anti
)

# PANDAS: ฟังก์ชัน merge
result_pd = pd.merge(
    employees.to_pandas(),
    departments.to_pandas(),
    on="dept_id",
    how="left"
)

# hybrid_workflow.py
import polars as pl
from sklearn.ensemble import RandomForestClassifier
import matplotlib.pyplot as plt

# การประมวลผลข้อมูลหนักด้วย Polars (เร็วกว่า 10x)
df = (
    pl.scan_parquet("raw_data/*.parquet")
    .filter(pl.col("valid") == True)
    .with_columns([
        (pl.col("revenue") / pl.col("quantity")).alias("unit_price"),
        pl.col("timestamp").dt.month().alias("month")
    ])
    .group_by(["customer_id", "month"])
    .agg([
        pl.col("revenue").sum(),
        pl.col("quantity").mean()
    ])
    .collect()
)

# แปลงเป็น Pandas สำหรับ ML (zero-copy สำหรับคอลัมน์ตัวเลข)
X = df.select(["revenue", "quantity"]).to_pandas()
y = df.select("churn").to_pandas().values.ravel()

# scikit-learn คาดหวัง Pandas/NumPy
model = RandomForestClassifier()
model.fit(X, y)

# การ plot ด้วยการรวม Pandas
df.to_pandas().plot(kind="bar", x="month", y="revenue")
plt.savefig("monthly_revenue.png")

# interview_answer_large_file.py
import polars as pl

# ตัวเลือก 1: Lazy evaluation พร้อม streaming (Polars)
result = (
    pl.scan_csv("large_file.csv")  # อ่านเฉพาะ schema
    .filter(pl.col("status") == "active")
    .group_by("region")
    .agg(pl.col("revenue").sum())
    .collect(streaming=True)  # ประมวลผลเป็น batch
)

# ตัวเลือก 2: Chunked processing (fallback Pandas)
import pandas as pd

results = []
for chunk in pd.read_csv("large_file.csv", chunksize=1_000_000):
    filtered = chunk[chunk["status"] == "active"]
    agg = filtered.groupby("region")["revenue"].sum()
    results.append(agg)

final = pd.concat(results).groupby(level=0).sum()

# interview_conversion.py

# โค้ด Pandas ที่ให้มา
df = pd.read_csv("sales.csv")
df["year"] = pd.to_datetime(df["date"]).dt.year
result = (
    df[df["amount"] > 1000]
    .groupby(["region", "year"])
    .agg({"amount": ["sum", "mean"], "customer_id": "nunique"})
)

# เทียบเท่า Polars
result = (
    pl.scan_csv("sales.csv")  # Lazy สำหรับการปรับแต่ง
    .with_columns(
        pl.col("date").str.to_datetime().dt.year().alias("year")
    )
    .filter(pl.col("amount") > 1000)
    .group_by(["region", "year"])
    .agg([
        pl.col("amount").sum().alias("amount_sum"),
        pl.col("amount").mean().alias("amount_mean"),
        pl.col("customer_id").n_unique().alias("unique_customers")
    ])
    .collect()
)

# migration_strategy.py
import polars as pl
import pandas as pd

# ขั้นตอนที่ 1: ใช้ Pandas ต่อสำหรับการสำรวจอย่างรวดเร็ว
def explore_data(path: str) -> pd.DataFrame:
    return pd.read_csv(path).head(1000)

# ขั้นตอนที่ 2: แนะนำ Polars สำหรับการแปลงหนัก
def process_data(path: str) -> pl.DataFrame:
    return (
        pl.scan_csv(path)
        .filter(pl.col("valid") == True)
        .with_columns([
            (pl.col("price") * pl.col("quantity")).alias("total")
        ])
        .collect()
    )

# ขั้นตอนที่ 3: แปลงที่ขอบเขตเมื่อต้องการ
def train_model(df_polars: pl.DataFrame):
    df_pandas = df_polars.to_pandas()  # Zero-copy สำหรับตัวเลข
    # โค้ด scikit-learn ที่นี่

# ขั้นตอนที่ 4: แทนที่ hot paths ทีละขั้น
# ระบุการดำเนินการ Pandas ที่ช้าด้วย profiling
# แทนที่ด้วยเทียบเท่า Polars ทีละฟังก์ชัน