Python Polars快速入门指南：LazyFrames

前文已经介绍了Polars的Dataframe, Contexts 和 Expressions，本文继续介绍Polars的惰性API。惰性API是该库最强大的功能之一，使用惰性API可以设定一系列操作，而无需立即运行它们。相反，这些操作被保存为计算图，只在必要时运行。这允许Polars在执行前优化查询，在处理数据之前捕获模式错误，并在超出内存限制的数据集上执行内存高效查询。

创建LazyFrames

惰性API中的核心对象是LazyFrame，你可以通过几种不同的方式创建LazyFrame。要开始学习LazyFrames和lazy API，请看下面的例子：

python 复制代码

import numpy as np
import polars as pl

num_rows = 5000
rng = np.random.default_rng(seed=7)

buildings = {
    "sqft": rng.exponential(scale=1000, size=num_rows),
    "price": rng.exponential(scale=100_000, size=num_rows),
    "year": rng.integers(low=1995, high=2023, size=num_rows),
    "building_type": rng.choice(["A", "B", "C"], size=num_rows),
}

lydf = pl.LazyFrame(buildings)
# lydf = df.lazy()
lydf

还是使用前文的数据集，增加了price字段；这里调用pl.LazyFrame()从buildings中创建LazyFrame。我们也可以使用.lazy()将现有的DataFrame转换为LazyFrame。下面通过示例说明lazy API是如何工作的，查询代码如下：

python 复制代码

lazy_query = (
    lydf
    .with_columns(
        (pl.col("price") / pl.col("sqft")).alias("price_per_sqft")
    )
    .filter(pl.col("price_per_sqft") > 100)
    .filter(pl.col("year") < 2010)
)
lazy_query.show_graph()

可能已经注意到，惰性查询返回另一个LazyFrame，而不是实际执行查询。这就是惰性API背后的思想。它只在显式调用查询时执行查询。在执行查询之前，可以检查所谓的查询计划。查询计划查询将触发的步骤顺序，lazy_query.show_graph()显示可视化步骤流程：

vscode 环境中不能显示，可能需要安装 sudo apt install graphviz 。在polar中从下到上阅读查询计划图，每个方框对应于查询计划中的一个阶段。σ (σ)和π (π)是关系代数中的符号，它们告诉你对数据执行的操作。

了解了延迟查询要做什么之后，就可以实际执行它了。为此，在惰性查询上调用.collect()，根据查询计划对其求值。下面是它的实际效果：

python 复制代码

(
    lazy_query
    .collect()
    .select(pl.col(["price_per_sqft", "year"]))
)

显示结果：

shape: (1_338, 2)
price_per_sqft	year
f64	i64
552.294274	2006
465.851448	1998
147.77145	2000
147.608287	2009
850.446036	2000
...	...
220.480873	2005
612.279463	2003
1407.598853	2006
955.962262	1996
124.381572	1997

使用.collect()运行延迟查询时，将获得带有结果的常规polar DataFrame。由于过滤条件，仅仅获得到原始1338行。显示的所有price_per_sqft和year值分别大于124而小于154895。为了进一步验证查询是否正确过滤了数据，我们可以查看摘要统计信息：

(
    lazy_query
    .collect()
    .select(pl.col(["price_per_sqft", "year"]))
    .describe()
)

返回结果：

shape: (9, 3)
statistic	price_per_sqft	year
str	f64	f64
"count"	1338.0	1338.0
"null_count"	0.0	0.0
"mean"	1197.977747	2001.893124
"std"	5821.706266	4.32589
"min"	100.357816	1995.0
"25%"	174.913631	1998.0
"50%"	299.238917	2002.0
"75%"	703.415704	2006.0
"max"	154895.785598	2009.0

使用.describe()查看汇总统计信息时，可以看到最小的price_per_sqft大约是100，最大的年份是2009。现在我们对惰性API有了一定的了解，但是惰性API的优势是什么。如果整个数据集已经存储在内存中，为什么需要惰性查询来进行分析？继续阅读，看看lazy API真正的亮点在哪里。

scan LazyFrame

在实际应用程序中，在使用Python进行任何处理之前，您很可能将数据存储在外部的静态文件或数据库中。lazy API的主要超级功能之一是，支持处理存储在文件中的大型数据集，而无需将所有数据读入内存。

在处理csv之类的文件时，通常会在分析数据之前将所有数据读入内存。使用Polars的lazy API，可以通过只处理必要的数据来最小化读入内存的数据量。这使得Polars可以优化内存占用和减少计算时间。

下面示例中，使用来自data .gov的电动汽车统计数据。此数据集包含在华盛顿州注册的电动和混合动力汽车的信息。数据中的每一行表示一辆车，每一列包含有关该车的信息。我们可以手动下载该数据进行测试，通过lazy API高效处理文件的关键是使用polar的scan功能。当你扫描文件时，而不是把整个文件读入内存，Polars创建LazyFrame引用文件的数据。与前面一样，在显式执行查询之前不会对数据进行处理。使用以下代码scan electric_cars.csv：

python 复制代码

lazy_car_data = pl.scan_csv(local_file_path)
lazy_car_data


lazy_car_data.schema
{'VIN (1-10)': Utf8, 'County': Utf8, 'City': Utf8, 'State': Utf8,
'Postal Code': Int64, 'Model Year': Int64, 'Make': Utf8, 'Model': Utf8,
'Electric Vehicle Type': Utf8, 'Clean Alternative Fuel Vehicle (CAFV) Eligibility': Utf8,
'Electric Range': Int64, 'Base MSRP': Int64, 'Legislative District': Int64,
'DOL Vehicle ID': Int64, 'Vehicle Location': Utf8, 'Electric Utility': Utf8,
'2020 Census Tract': Int64}

通过使用scan_csv()创建lazy_car_data。至关重要的是，CSV文件中的数据没有存储在内存中。相反，lazy_car_data从electric_cars.csv中存储的唯一东西是lazy_car_data.schema中的模式。

这样可以查看文件的列名和它们各自的数据类型，它还可以帮助Polars优化在这些数据上运行的查询。实际上，polar必须在执行查询计划的任何步骤之前了解模式。

现在可以使用惰性API对electric_cars.csv中包含的数据运行查询。查询可以包括任意的复杂性表达式，Polars将只存储和处理必要的数据。例如运行以下查询：

python 复制代码

lazy_car_query = (
	lazy_car_data
		.filter((pl.col("Model Year") >= 2018))
		.filter(
			 pl.col("Electric Vehicle Type") == "Battery Electric Vehicle (BEV)"
		).groupby(["State", "Make"])
		.agg(
			pl.mean("Electric Range").alias("Average Electric Range"),
			pl.min("Model Year").alias("Oldest Model Year"),
			pl.count().alias("Number of Cars"),
		)
		.filter(pl.col("Average Electric Range") > 0)
		.filter(pl.col("Number of Cars") > 5)
		.sort(pl.col("Number of Cars"), descending=True)
	)

lazy_car_query.collect()
shape: (20, 5)
┌───────┬───────────┬────────────────────────┬───────────────────┬────────────────┐
│ State ┆ Make      ┆ Average Electric Range ┆ Oldest Model Year ┆ Number of Cars │
│ ---   ┆ ---       ┆ ---                    ┆ ---               ┆ ---            │
│ str   ┆ str       ┆ f64                    ┆ i64               ┆ u32            │
╞═══════╪═══════════╪════════════════════════╪═══════════════════╪════════════════╡
│ WA    ┆ TESLA     ┆ 89.114509              ┆ 2018              ┆ 55690          │
│ WA    ┆ NISSAN    ┆ 93.115056              ┆ 2018              ┆ 5267           │
│ WA    ┆ CHEVROLET ┆ 111.746651             ┆ 2018              ┆ 5001           │
│ WA    ┆ KIA       ┆ 65.380428              ┆ 2018              ┆ 3178           │
│ ...     ┆ ...         ┆ ...                      ┆ ...                 ┆ ...              │
│ VA    ┆ TESLA     ┆ 139.133333             ┆ 2018              ┆ 15             │
│ MD    ┆ TESLA     ┆ 50.6                   ┆ 2018              ┆ 10             │
│ TX    ┆ TESLA     ┆ 94.625                 ┆ 2018              ┆ 8              │
│ NC    ┆ TESLA     ┆ 61.428571              ┆ 2018              ┆ 7              │
└───────┴───────────┴────────────────────────┴───────────────────┴────────────────┘

因为这是延迟查询，所以在调用lazy_car_query.collect()之前不会执行任何计算。在执行查询之后，只存储和返回所请求的数据------仅此而已。

从lazy_car_query.collect()返回的DataFrame中的每一行都包括平均续航里程、最旧的车型年份以及每个州和制造商的汽车数量。例如，第一行告诉你，华盛顿州2018年或之后有55690辆特斯拉，它们的平均续航里程约为89.11英里。

通过这个例子可以看到Polars如何使用lazy API以高性能和内存高效的方式从文件中查询数据。这个强大的API使polar比其他DataFrame库有了巨大的优势，你应该尽可能选择使用lazy API。在下一节中，您将了解polar如何与外部数据源和更广泛的Python生态系统集成。