Polars và Pandas: So sánh hiệu năng và bộ nhớ

Trong nhiều năm, Pandas là "ông vua" không thể tranh cãi trong xử lý dữ liệu Python. Nó đã cung cấp API DataFrame mà tất cả chúng ta đều biết và yêu thích, hỗ trợ các quy trình khoa học dữ liệu trong hơn một thập kỷ. Nhưng hãy thực tế: khi tập dữ liệu của chúng ta tăng từ megabyte lên gigabyte (và terabyte), Pandas bắt đầu bộc lộ những hạn chế. Bản chất đơn luồng và chi phí bộ nhớ khổng lồ của nó đã trở thành một vấn đề lớn. Thực hiện các thao tác đơn giản trong Pandas có thể dễ dàng ngốn gấp 3 đến 5 lần kích thước tập dữ liệu trong RAM, chủ yếu là do đánh giá tức thì (eager evaluation) và các bản sao trung gian vô tận. Polars xuất hiện. Được viết bằng Rust, nó là một công cụ DataFrame được xây dựng từ đầu cho việc xử lý hiện đại, đa luồng, hiệu quả bộ nhớ. Chọn Polars thay vì Pandas không chỉ là về tốc độ nữa; nó ảnh hưởng trực tiếp đến hóa đơn AWS của bạn. Nếu bạn đã từng phải đối mặt với các sự cố OOM trên các container ETL của mình, bạn sẽ hiểu chính xác những gì tôi đang nói.

Tại sao Polars vượt trội hơn Pandas trong các thao tác tốn nhiều bộ nhớ?

Polars vượt trội hơn Pandas trong các thao tác tốn nhiều bộ nhớ vì Polars sử dụng biểu diễn bộ nhớ cột Apache Arrow và các nhân thực thi Rust song song để loại bỏ các bản sao dữ liệu trung gian.

Pandas truyền thống dựa vào các trình quản lý bộ nhớ NumPy dựa trên khối, nơi các cột chuỗi, kiểu đối tượng và giá trị thiếu yêu cầu các trình bao bọc đối tượng Python nặng nề. Khi thực hiện các thao tác lọc hoặc tổng hợp trong Pandas, công cụ tạo bản sao của các mảng cơ bản cho mỗi bước chuyển đổi trung gian. Polars thay thế bố cục bộ nhớ cũ này bằng đặc tả định dạng bộ nhớ Apache Arrow. Apache Arrow lưu trữ dữ liệu trong các khối bộ nhớ cột liền kề với các bitmap hợp lệ giá trị thiếu được tiêu chuẩn hóa, cho phép tính toán vector SIMD CPU thân thiện với bộ nhớ cache. Ngoài ra, Polars tránh sao chép bộ nhớ trong quá trình chuyển đổi bất cứ khi nào có thể, sử dụng các chế độ xem cắt không sao chép và con trỏ bộ nhớ Arrow. Các kiến trúc sư dữ liệu xây dựng các công cụ phân tích khối lượng lớn dựa vào biểu diễn bộ nhớ Arrow để duy trì mức sử dụng RAM thấp. Bạn sẽ thấy rằng chi phí bộ nhớ xử lý chuỗi giảm đáng kể khi chuyển sang bố cục bộ nhớ cột Arrow.

Các ví dụ mã dưới đây minh họa cách mức sử dụng bộ nhớ chuyển đổi dữ liệu khác nhau giữa Pandas và Polars:

# Pandas Eager Transformation Pattern (High Memory Overhead)
import pandas as pd
import numpy as np

def process_pandas_dataframe(filepath: str) -> pd.DataFrame:
    # Eager load: Reads entire CSV into memory using Python object types
    df = pd.read_csv(filepath)
    
    # Intermediate copy 1: Filtering creates an entirely new DataFrame allocation
    filtered = df[df["transaction_amount"] > 100.0]
    
    # Intermediate copy 2: Column assignment allocates additional memory block
    filtered["tax_amount"] = filtered["transaction_amount"] * 0.08
    
    # Intermediate copy 3: GroupBy aggregation allocates separate result table
    result = filtered.groupby("category_id")[["transaction_amount", "tax_amount"]].sum().reset_index()
    return result

Ngược lại, Polars sử dụng một công cụ Rust giúp vector hóa truy cập bộ nhớ và song song hóa các tính toán trên các lõi CPU có sẵn:

# Polars High-Performance Processing Pattern (Zero-Copy Architecture)
import polars as pl

def process_polars_dataframe(filepath: str) -> pl.DataFrame:
    # Polars uses Apache Arrow memory layout and parallel multi-threaded scanning
    df = pl.read_csv(filepath)
    
    # Expressions are evaluated concurrently across CPU threads without intermediate copies
    result = (
        df.filter(pl.col("transaction_amount") > 100.0)
        .with_columns((pl.col("transaction_amount") * 0.08).alias("tax_amount"))
        .group_by("category_id")
        .agg([
            pl.col("transaction_amount").sum(),
            pl.col("tax_amount").sum()
        ])
    )
    return result

Bằng cách tận dụng bố cục bộ nhớ của Apache Arrow và các đảm bảo an toàn bộ nhớ của Rust, Polars xử lý các chuyển đổi DataFrame phức tạp với mức tiêu thụ bộ nhớ tối thiểu. Nếu bạn không áp dụng cấu trúc cột Arrow, việc xử lý các tập dữ liệu chuỗi lớn sẽ tiêu tốn quá nhiều RAM. Chúng tôi đang thấy các đường ống ETL đám mây lớn chuyển sang Polars để cắt giảm chi phí nút tính toán.

Ngoài ra, Polars sử dụng các bảng bộ nhớ đệm chuỗi để tối ưu hóa việc xử lý dữ liệu phân loại. Trong Pandas, các cột phân loại thường yêu cầu các bước mã hóa từ điển thủ công. Polars tự động quản lý các bộ nhớ đệm chuỗi toàn cầu, cho phép tính toán nối và nhóm theo nhanh chóng trên các cột chuỗi mà không có chi phí con trỏ đối tượng.

Ngoài ra, các biểu thức Polars được căn chỉnh bộ nhớ cache CPU. Công cụ thực thi của Rust xử lý các vector dữ liệu trong các khối bộ nhớ vừa vặn trực tiếp bên trong bộ nhớ cache L1/L2 của CPU, giảm thiểu thời gian chờ bus bộ nhớ trong các vòng lặp tổng hợp.

Ngoài ra, Polars hỗ trợ xác minh căn chỉnh bộ nhớ gốc trong quá trình xây dựng vector Arrow, đảm bảo rằng các mảng số được căn chỉnh với các ranh giới thanh ghi SIMD để xử lý tăng tốc phần cứng.

Ngoài ra, Polars tránh thu thập GIL Python trung gian trong các bước tính toán. Bởi vì các biểu thức cơ bản thực thi trong Rust gốc đã được biên dịch, các chuyển đổi số xử lý trên các luồng CPU mà không phải chờ khóa trình thông dịch Python.

Cuối cùng, Polars hỗ trợ phân tích cú pháp tệp CSV và Parquet song song ngay lập tức, đọc các tệp đầu vào trên tất cả các lõi CPU có sẵn đồng thời để giảm thiểu độ trễ tải dữ liệu.

Đánh giá lười biếng tối ưu hóa biểu đồ thực thi truy vấn Polars như thế nào?

Đánh giá lười biếng tối ưu hóa biểu đồ thực thi truy vấn Polars bằng cách phân tích toàn bộ các đường ống truy vấn, sắp xếp lại các thao tác lọc và loại bỏ các cột không sử dụng trước khi cấp phát bộ nhớ.

Pandas hoạt động độc quyền ở chế độ tức thì (eager mode), đánh giá mã từng dòng khi các câu lệnh thực thi. Đánh giá tức thì ngăn công cụ tối ưu hóa các bước thực thi trên nhiều thao tác. Ví dụ, nếu một nhà phát triển tải một tệp CSV năm mươi cột trong Pandas và lọc các hàng mười dòng sau đó, Pandas sẽ tải tất cả năm mươi cột vào bộ nhớ trước khi loại bỏ các hàng không mong muốn. Polars giới thiệu một API thực thi lười biếng được gọi qua lazy(). Khi sử dụng LazyFrame, Polars xây dựng một kế hoạch truy vấn logic trừu tượng thay vì thực thi các thao tác ngay lập tức. Khi .collect() được gọi, trình tối ưu hóa truy vấn Polars viết lại biểu đồ thực thi để áp dụng các tối ưu hóa đẩy xuống vị từ (predicate pushdown) và đẩy xuống phép chiếu (projection pushdown). Các kỹ sư cơ sở dữ liệu phân tích khối lượng công việc phân tích đánh giá cao việc tối ưu hóa biểu đồ truy vấn để giảm thông lượng I/O đĩa. Nếu bạn chưa bật đánh giá lười biếng cho các đường ống dữ liệu lớn, bạn đang lãng phí băng thông bộ nhớ CPU trên các cột không đọc.

Hãy xem xét cách chức năng tối ưu hóa đẩy xuống vị từ và phép chiếu cột trong một đường ống truy vấn lười biếng của Polars:

import polars as pl

def execute_optimized_lazy_query(parquet_path: str) -> pl.DataFrame:
    # Construct logical query plan without reading parquet file contents into memory
    lazy_plan = (
        pl.scan_parquet(parquet_path)
        .filter(pl.col("region") == "US-EAST")
        .filter(pl.col("is_active") == True)
        .select(["user_id", "region", "revenue"])
        .group_by("region")
        .agg(pl.col("revenue").sum().alias("total_revenue"))
    )
    
    # Collect triggers query optimization:
    # 1. Projection Pushdown: Only loads user_id, region, revenue columns from disk
    # 2. Predicate Pushdown: Pushes region/is_active filters down into Parquet scanner
    optimized_df = lazy_plan.collect()
    return optimized_df

Bảng dưới đây phác thảo các lần tối ưu hóa truy vấn chính được thực hiện tự động bởi công cụ lười biếng của Polars:

Tối ưu hóa truy vấn lười biếng cho phép Polars đạt được tốc độ thực thi vượt trội so với xử lý tức thì của Pandas theo cấp số nhân. Nếu bạn không sử dụng quét lười biếng cho các tệp Parquet lớn, các ứng dụng của bạn sẽ tải các cột không cần thiết vào RAM một cách không cần thiết. Đó là lý do tại sao các biểu đồ đánh giá lười biếng đại diện cho một bước tiến lớn cho kỹ thuật dữ liệu Python.

Ngoài ra, Polars cung cấp một phương thức .explain() để in kế hoạch thực thi vật lý đã tối ưu hóa. Các nhà phát triển có thể kiểm tra kế hoạch truy vấn để xác minh rằng các vị từ lọc được đẩy xuống các lớp lưu trữ đúng cách trước khi chạy các tác vụ hàng loạt dài.

Ngoài ra, đánh giá lười biếng cho phép quét tập dữ liệu đa tệp trên các cây thư mục một cách liền mạch. Polars quét hàng trăm tệp Parquet được phân vùng đồng thời, tự động áp dụng các vị từ lọc trên các ranh giới tệp.

Ngoài ra, công cụ thực thi lười biếng của Polars tự động hợp nhất các điều kiện lọc tuần tự, tạo ra các biểu thức so sánh đơn giản hóa thực thi trong một lần hướng dẫn CPU duy nhất.

Ngoài ra, biểu đồ truy vấn lười biếng cho phép Polars sắp xếp lại các thao tác nối dựa trên thống kê lược đồ, đặt các bảng nhỏ hơn ở phía bên phải của các phép nối băm để giảm thiểu mức tiêu thụ bộ nhớ trong quá trình thực thi nối.

Cuối cùng, thực thi truy vấn lười biếng cho phép kết hợp nhiều chuyển đổi phân tích thành một lần tối ưu hóa duy nhất trên dữ liệu, tránh ghi tràn đĩa trung gian.

API Streaming của Polars xử lý các tập dữ liệu lớn hơn RAM hệ thống như thế nào?

API streaming của Polars xử lý các tập dữ liệu lớn hơn RAM hệ thống bằng cách thực thi các kế hoạch truy vấn trên các lô dữ liệu được phân đoạn ánh xạ bộ nhớ, ghi trực tiếp vào các tệp đầu ra mà không tải toàn bộ bảng vào bộ nhớ.

Khi làm việc với các tập dữ liệu vượt quá RAM vật lý có sẵn, mã Pandas truyền thống sẽ gặp lỗi Out-Of-Memory (OOM). Giải quyết tình trạng hết bộ nhớ trong Pandas yêu cầu viết các vòng lặp phân đoạn thủ công với các trình lặp chunksize, gây ra mã phức tạp. Polars giải quyết việc xử lý dữ liệu ngoài lõi một cách tự nhiên thông qua công cụ thực thi streaming của nó. Truyền streaming=True đến .collect() hướng dẫn Polars xử lý dữ liệu theo các lô streaming được phân đoạn. Công cụ này truyền các lô dữ liệu từ đĩa qua các toán tử truy vấn, ghi kết quả trực tiếp vào các đích đầu ra mà không tải toàn bộ bảng vào RAM. Các kỹ sư cơ sở hạ tầng quản lý các đường ống dữ liệu đám mây sử dụng thực thi streaming để xử lý các tập dữ liệu khổng lồ trên các phiên bản container nhẹ. Nếu đường ống của bạn không hỗ trợ thực thi lô streaming, các tập dữ liệu lớn sẽ gây ra các lần khởi động lại container không mong muốn.

Đây là cách xử lý tập dữ liệu năm mươi gigabyte trên máy tính xách tay bằng API streaming sink của Polars:

import polars as pl

def process_large_dataset_out_of_core(input_parquet: str, output_parquet: str) -> None:
    # Configure lazy scanning pipeline over multi-gigabyte dataset
    lazy_query = (
        pl.scan_parquet(input_parquet)
        .filter(pl.col("transaction_status") == "COMPLETED")
        .with_columns(
            (pl.col("amount") * pl.col("exchange_rate")).alias("converted_amount")
        )
        .group_by(["account_id", "currency"])
        .agg([
            pl.col("converted_amount").sum().alias("total_account_spend"),
            pl.col("transaction_id").count().alias("transaction_count")
        ])
    )
    
    # Execute query in streaming mode, writing output directly to Parquet file
    lazy_query.sink_parquet(
        output_parquet,
        compression="snappy",
        maintain_order=False
    )
    print(f"Streaming execution completed successfully. Saved to {output_parquet}")

Sử dụng các đường ống streaming của Polars cho phép các kỹ sư dữ liệu xử lý các tập dữ liệu khổng lồ trên cơ sở hạ tầng đám mây khiêm tốn mà không gặp lỗi hết bộ nhớ. Nếu bạn không streaming các tập dữ liệu lớn, mức tiêu thụ bộ nhớ sẽ tăng tuyến tính với kích thước tệp cho đến khi vượt quá giới hạn bộ nhớ tiến trình. Bạn sẽ thấy rằng thực thi streaming giúp việc chuyển đổi dữ liệu ngoài lõi nhanh chóng và dễ dàng duy trì.

Ngoài ra, các công cụ streaming của Polars tự động quản lý các bộ đệm ánh xạ bộ nhớ. Khi xử lý các lô dữ liệu được phân đoạn, các trang ánh xạ bộ nhớ được giải phóng trở lại hạt nhân OS một cách linh hoạt khi các phân đoạn hoàn tất xử lý.

Ngoài ra, Polars hỗ trợ các phép nối và tổng hợp streaming trên các tập dữ liệu lớn, duy trì các bảng băm nội bộ một cách hiệu quả trong các lần truyền streaming.

Ngoài ra, các sink streaming của Polars cho phép ghi đầu ra Parquet nén một cách tăng dần, giảm mức tiêu thụ lưu trữ cục bộ trong quá trình chạy đường ống dữ liệu ETL thông lượng cao.

Ngoài ra, các đường ống dữ liệu streaming có thể xử lý các thư mục hive được phân vùng song song, ghi đầu ra phân đoạn đã xử lý vào các vị trí lưu trữ được nhắm mục tiêu mà không tích lũy các trạng thái lô trung gian trong bộ nhớ.

Cuối cùng, thực thi streaming tích hợp trực tiếp với các nguồn lưu trữ đối tượng đám mây như Amazon S3 hoặc Google Cloud Storage, cho phép chuyển đổi streaming trên các tệp Parquet từ xa mà không cần tải toàn bộ tệp xuống đĩa cục bộ trước.

Các điểm chuẩn nào chứng minh tốc độ tổng hợp và nối trong thế giới thực?

Các điểm chuẩn chứng minh tốc độ tổng hợp và nối trong thế giới thực, nơi Polars thực thi các truy vấn nhóm theo (group-by) nhanh hơn Pandas tới mười lần trong khi chỉ sử dụng một phần nhỏ bộ nhớ đỉnh.

Để đánh giá sự khác biệt về hiệu suất giữa Polars và Pandas dưới cùng một khối lượng công việc, chúng tôi đã thực hiện các điểm chuẩn trên một tập dữ liệu tổng hợp hai mươi triệu hàng (khoảng 1.6 GB trong bộ nhớ). Các thử nghiệm được tiến hành trên một máy trạm 8 lõi chạy Python 3.13, Pandas 2.2 (với backend PyArrow được bật) và Polars 1.0. Các điểm chuẩn đo thời gian thực thi và cấp phát RAM đỉnh trên ba quy trình làm việc phân tích phổ biến: lọc, tổng hợp nhóm theo đa cột và nối trong hai bảng. Các nhóm kiểm thử hiệu suất phân tích các chỉ số điểm chuẩn đặc biệt chú ý đến các mẫu sử dụng CPU đa luồng. Nếu bạn chưa kiểm tra các truy vấn phân tích của mình với các công cụ Arrow hiện đại, bạn đang bỏ lỡ những cải thiện tốc độ thực thi lớn.

Dữ liệu điểm chuẩn làm nổi bật sự khác biệt đáng kể về hiệu suất giữa hai thư viện:

Polars thực thi các tổng hợp nhóm theo nhanh hơn Pandas hơn mười lần trong khi tiêu thụ ít hơn hai mươi phần trăm bộ nhớ RAM đỉnh.

# Benchmark Script snippet demonstrating high speed Polars aggregation
import time
import polars as pl

def benchmark_polars_group_by(df: pl.DataFrame) -> float:
    start = time.perf_counter()
    result = (
        df.group_by(["category", "region"])
        .agg([
            pl.col("val1").mean().alias("avg_val1"),
            pl.col("val2").max().alias("max_val2")
        ])
    )
    elapsed = time.perf_counter() - start
    print(f"Polars GroupBy executed in {elapsed:.4f} seconds")
    return elapsed

Những điểm chuẩn thực nghiệm này chứng minh lý do tại sao các ứng dụng chuyên sâu về dữ liệu ngày càng áp dụng Polars cho các đường ống ETL sản xuất.

Ngoài tốc độ thực thi, Polars duy trì sự ổn định hiệu suất cao khi số lượng luồng worker tăng lên trên các bộ xử lý đa lõi. Thư viện Rayon của Rust cân bằng khối lượng công việc của luồng một cách linh hoạt, đảm bảo rằng không có lõi CPU nào trở thành nút thắt cổ chai trong các thao tác nối phức tạp.

Ngoài ra, Polars xử lý các thao tác thao tác chuỗi (chẳng hạn như trích xuất regex và các lần phân tách chuỗi) nhanh hơn các phương thức chuỗi của Pandas tới mười lăm lần, làm cho nó lý tưởng cho các đường ống phân tích nhật ký.

Ngoài ra, phân tích điểm chuẩn xác nhận rằng việc sử dụng bộ nhớ của Polars vẫn có thể dự đoán được trong các thao tác nối nặng, ngăn chặn các đột biến hết bộ nhớ trên các phiên bản máy chủ dùng chung.

Ngoài ra, các thử nghiệm điểm chuẩn cho thấy Polars duy trì khả năng mở rộng hiệu suất tuyến tính khi được thực thi trên các phiên bản đám mây với ba mươi hai hoặc sáu mươi bốn lõi CPU, trong khi Pandas bị chững lại do các ràng buộc đánh giá đơn luồng.

Cuối cùng, mức tiêu thụ RAM thấp hơn dưới Polars cho phép các kỹ sư dữ liệu chạy nhiều tác vụ xử lý đồng thời trên các phiên bản máy chủ dùng chung mà không có nguy cơ gặp sự cố thiếu bộ nhớ.

Bạn cũng có thể thích

• Python Tricks I Actually Reach For Daily
• Modern Python Development Environment with pyenv, Poetry, uv, and pyproject.toml
• Advanced Mypy Strict Mode Patterns for Production Python
• Advanced Pytest Fixtures and Parameterization Patterns

Các câu hỏi thường gặp về hiệu suất của Polars và Pandas

Polars có thể thay thế hoàn toàn Pandas trong các quy trình khoa học dữ liệu hiện có không?

Mặc dù Polars xử lý các chuyển đổi DataFrame phân tích nhanh hơn Pandas, Pandas vẫn duy trì khả năng tích hợp rộng hơn với các thư viện học máy cũ như scikit-learn. Các nhà phát triển có thể chuyển đổi Polars DataFrames sang mảng NumPy hoặc bảng Arrow khi giao tiếp với các gói ML chuyên biệt.

Pandas 2.0 với backend PyArrow so với hiệu suất của Polars như thế nào?

Pandas 2.0 đã giới thiệu bộ lưu trữ backend PyArrow tùy chọn, cải thiện biểu diễn bộ nhớ so với các khối NumPy gốc. Tuy nhiên, vì Pandas vẫn bị ràng buộc với các vòng lặp đánh giá đơn luồng tức thì, Polars tiếp tục vượt trội hơn Pandas về thực thi đa luồng và tối ưu hóa truy vấn.

Polars có hỗ trợ cú pháp truy vấn SQL cùng với các biểu thức DataFrame không?

Có, Polars bao gồm một SQLContext tích hợp cho phép các nhà phát triển đăng ký DataFrames hoặc LazyFrames và thực thi các truy vấn ANSI SQL trực tiếp trên các tập dữ liệu bộ nhớ Arrow.

Sự khác biệt chính giữa Eager DataFrames và LazyFrames trong Polars là gì?

Eager DataFrames đánh giá các thao tác ngay lập tức trong bộ nhớ, trả về các bảng đã chuyển đổi sau mỗi lần gọi phương thức. LazyFrames xây dựng các kế hoạch truy vấn logic, cho phép công cụ Polars tối ưu hóa các thao tác trước khi thực thi mã khi .collect() được gọi.

Polars quản lý đa luồng trên các lõi CPU có sẵn như thế nào?

Polars sử dụng thư viện Rayon của Rust để tự động song song hóa các thao tác dữ liệu trên tất cả các luồng CPU có sẵn, loại bỏ mã đa xử lý thủ công.

Có đảm bảo sao chép bộ nhớ không sao chép trên tất cả các thao tác chuyển đổi Polars không?

Thực thi không sao chép xảy ra trong quá trình cắt lát, chọn cột và đổi tên. Các thao tác thay đổi các byte dữ liệu cơ bản (chẳng hạn như phép cộng toán học hoặc nối chuỗi) cấp phát bộ nhớ cho các cột kết quả trong khi sử dụng các mặt nạ hợp lệ Arrow một cách hiệu quả.