首页 on Python数据分析

Polars快速入门

Thu, 20 Mar 2025 13:20:29 +0800

Polars快速入门#

安装#

采用 pip install 即可安装 Polars 。

$ pip install polars

所有的二进制包都是基于 Python v3.6+ 构建的。

实例#

下面的例子中我们读入并解析一个 CSV 文件，过滤后紧跟一个 groupby 分组求和操作（该例子仅在Python中演示，因为对于Rust而言，即时执行的API并不推荐）：

import polars as pl

df = pl.read_csv("https://j.mp/iriscsv")
print(df.filter(pl.col("sepal_length") > 5)
 .groupby("species")
 .agg(pl.all().sum())
)

上面的代码输出如下：

shape: (3, 5)
╭──────────────┬──────────────────┬─────────────────┬──────────────────┬─────────────────╮
│ species ┆ sepal_length_sum ┆ sepal_width_sum ┆ petal_length_sum ┆ petal_width_sum │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ f64 ┆ f64 ┆ f64 ┆ f64 │
╞══════════════╪══════════════════╪═════════════════╪══════════════════╪═════════════════╡
│ "virginica" ┆ 324.5 ┆ 146.2 ┆ 273.1 ┆ 99.6 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "versicolor" ┆ 281.9 ┆ 131.8 ┆ 202.9 ┆ 63.3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┤
│ "setosa" ┆ 116.9 ┆ 81.7 ┆ 33.2 ┆ 6.1 │
╰──────────────┴──────────────────┴─────────────────┴──────────────────┴─────────────────╯

如上所示， Polars 可以格式化输出，包括作为表头的列名和数据类型。

Polars基本操作

Fri, 07 Mar 2025 11:31:29 +0800

Polars基本操作#

本节展示如何对dataframe的列执行基本操作，比如进行基本的算术计算、执行比较操作以及其他通用操作。在接下来的示例中，我们将使用以下dataframe：

import polars as pl
import numpy as np

np.random.seed(42) # For reproducibility.

df = pl.DataFrame(
 {
 "nrs": [1, 2, 3, None, 5],
 "names": ["foo", "ham", "spam", "egg", "spam"],
 "random": np.random.rand(5),
 "groups": ["A", "A", "B", "A", "B"],
 }
)
print(df)

shape: (5, 4)
┌──────┬───────┬──────────┬────────┐
│ nrs ┆ names ┆ random ┆ groups │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ f64 ┆ str │
╞══════╪═══════╪══════════╪════════╡
│ 1 ┆ foo ┆ 0.37454 ┆ A │
│ 2 ┆ ham ┆ 0.950714 ┆ A │
│ 3 ┆ spam ┆ 0.731994 ┆ B │
│ null ┆ egg ┆ 0.598658 ┆ A │
│ 5 ┆ spam ┆ 0.156019 ┆ B │
└──────┴───────┴──────────┴────────┘

基本算术运算#

Polars 支持相同长度的序列之间进行基本算术运算，也支持序列与字面值之间的基本算术运算。当字面值与序列混合使用时，字面值会被广播扩展，以匹配与之运算的序列的长度。

Polars数据类型和结构

Thu, 06 Mar 2025 23:16:29 +0800

Polars数据类型和结构#

Polars数据类型#

Polars支持多种数据类型，大致可分为以下几类：

数字数据类型：有符号整数、无符号整数、浮点数和小数。
嵌套数据类型：列表、结构体和数组。
时间：日期、日期时间、时间和时间增量。
杂项：字符串、二进制数据、布尔值、分类、枚举和对象。

所有类型都支持由特殊值null表示的缺失值。在浮点数据类型中与特殊值NaN合并；参考有关浮点数的更多信息。

你也可以找到附录中支持的所有数据类型的完整表，说明何时使用每种数据类型，并提供指向文档相关部分的链接。

序列(Series)#

Polars提供的核心基础数据结构是序列（series）和数据框（dataframe）。序列是一种一维的同构数据结构。这里所说的“同构”是指一个序列中的所有元素都具有相同的数据类型。下面的代码片段展示了如何创建一个带名称的序列：

import polars as pl

s = pl.Series("ints", [1, 2, 3, 4, 5])
print(s)

shape: (5,)
Series: 'ints' [i64]
[
 1
 2
 3
 4
 5
]

创建一个序列时，Polars会从你提供的值中推断数据类型。你可以指定一个具体的数据类型来覆盖这种推断机制：

s1 = pl.Series("ints", [1, 2, 3, 4, 5])
s2 = pl.Series("uints", [1, 2, 3, 4, 5], dtype=pl.UInt64)
print(s1.dtype, s2.dtype)

Int64 UInt64

数据框(Dataframe)#

数据框是一种二维的异构数据结构，它包含了具有唯一名称的序列。通过将数据存储在数据框中，你将能够使用Polars API编写用于操作数据的查询。你可以通过使用Polars提供的上下文和表达式来实现这一点，我们接下来会讲到这些内容。

下面的代码片段展示了如何根据一个由列表组成的字典来创建一个数据框：

from datetime import date

df = pl.DataFrame(
 {
 "name": ["Alice Archer", "Ben Brown", "Chloe Cooper", "Daniel Donovan"],
 "birthdate": [
 date(1997, 1, 10),
 date(1985, 2, 15),
 date(1983, 3, 22),
 date(1981, 4, 30),
 ],
 "weight": [57.9, 72.5, 53.6, 83.1], # (kg)
 "height": [1.56, 1.77, 1.65, 1.75], # (m)
 }
)

print(df)

shape: (4, 4)
┌────────────────┬────────────┬────────┬────────┐
│ name ┆ birthdate ┆ weight ┆ height │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ date ┆ f64 ┆ f64 │
╞════════════════╪════════════╪════════╪════════╡
│ Alice Archer ┆ 1997-01-10 ┆ 57.9 ┆ 1.56 │
│ Ben Brown ┆ 1985-02-15 ┆ 72.5 ┆ 1.77 │
│ Chloe Cooper ┆ 1983-03-22 ┆ 53.6 ┆ 1.65 │
│ Daniel Donovan ┆ 1981-04-30 ┆ 83.1 ┆ 1.75 │
└────────────────┴────────────┴────────┴────────┘

检查数据框dataframe#

在本小节中，我们将展示一些有用的方法来快速检查一个数据框。我们将以之前创建的数据框作为参考。

第 1 章准备工作

Thu, 06 Mar 2025 22:20:29 +0800

第 1 章准备工作#

1.1 本书的内容#

本书讲的是利用 Python 进行数据控制、处理、整理、分析等方面的具体细节和基本要点。我的目标是介绍 Python 编程和用于数据处理的库和工具环境，掌握这些，可以让你成为一个数据分析专家。虽然本书的标题是“数据分析”，重点却是 Python 编程、库，以及用于数据分析的工具。这就是数据分析要用到的 Python 编程。

什么样的数据？#

当书中出现“数据”时，究竟指的是什么呢？主要指的是结构化数据（structured data），这个故意含糊其辞的术语代指了所有通用格式的数据，例如：

表格型数据，其中各列可能是不同的类型（字符串、数值、日期等）。比如保存在关系型数据库中或以制表符/逗号为分隔符的文本文件中的那些数据。
多维数组（矩阵）。
通过关键列（对于 SQL 用户而言，就是主键和外键）相互联系的多个表。
间隔平均或不平均的时间序列。

这绝不是一个完整的列表。大部分数据集都能被转化为更加适合分析和建模的结构化形式，虽然有时这并不是很明显。如果不行的话，也可以将数据集的特征提取为某种结构化形式。例如，一组新闻文章可以被处理为一张词频表，而这张词频表就可以用于情感分析。

大部分电子表格软件（比如 Microsoft Excel，它可能是世界上使用最广泛的数据分析工具了）的用户不会对此类数据感到陌生。

1.2 为什么要使用 Python 进行数据分析#

许许多多的人（包括我自己）都很容易爱上 Python 这门语言。自从 1991 年诞生以来，Python 现在已经成为最受欢迎的动态编程语言之一，其他还有 Perl、Ruby 等。由于拥有大量的 Web 框架（比如 Rails（Ruby）和 Django（Python）），自从 2005 年，使用 Python 和 Ruby 进行网站建设工作非常流行。这些语言常被称作脚本（scripting）语言，因为它们可以用于编写简短而粗糙的小程序（也就是脚本）。我个人并不喜欢“脚本语言”这个术语，因为它好像在说这些语言无法用于构建严谨的软件。在众多解释型语言中，由于各种历史和文化的原因，Python 发展出了一个巨大而活跃的科学计算（scientific computing）社区。在过去的 10 年，Python 从一个边缘或“自担风险”的科学计算语言，成为了数据科学、机器学习、学界和工业界软件开发最重要的语言之一。

在数据分析、交互式计算以及数据可视化方面，Python 将不可避免地与其他开源和商业的领域特定编程语言/工具进行对比，如 R、MATLAB、SAS、Stata 等。近年来，由于 Python 的库（例如 pandas 和 scikit-learn）不断改良，使其成为数据分析任务的一个优选方案。结合其在通用编程方面的强大实力，我们完全可以只使用 Python 这一种语言构建以数据为中心的应用。

Python 作为胶水语言#

Python 成为成功的科学计算工具的部分原因是，它能够轻松地集成 C、C++ 以及 Fortran 代码。大部分现代计算环境都利用了一些 Fortran 和 C 库来实现线性代数、优选、积分、快速傅里叶变换以及其他诸如此类的算法。许多企业和国家实验室也利用 Python 来“粘合”那些已经用了多年的遗留软件系统。

Polars入门

Thu, 06 Mar 2025 21:23:29 +0800

Polars入门#

本章旨在帮助你开始使用Polars。它涵盖了该库的所有基本特性和功能，让新用户能够轻松熟悉从初始安装和设置到核心功能等基础知识。如果你已经是高级用户，或者熟悉数据框，那么可以直接跳至下一章安装Polars。

安装Polars#

 pip install polars

读取 & 写入#

Polars支持读取和写入常见的文件格式（例如，CSV、JSON、Parquet）、云存储（亚马逊S3、微软Azure Blob、谷歌BigQuery）以及数据库（例如，PostgreSQL、MySQL）。下面，我们创建一个小的数据框，并展示如何将其写入磁盘以及再读取回来。

import polars as pl
import datetime as dt

df = pl.DataFrame(
 {
 "name": ["Alice Archer", "Ben Brown", "Chloe Cooper", "Daniel Donovan"],
 "birthdate": [
 dt.date(1997, 1, 10),
 dt.date(1985, 2, 15),
 dt.date(1983, 3, 22),
 dt.date(1981, 4, 30),
 ],
 "weight": [57.9, 72.5, 53.6, 83.1], # (kg)
 "height": [1.56, 1.77, 1.65, 1.75], # (m)
 }
)

print(df)

shape: (4, 4)
┌────────────────┬────────────┬────────┬────────┐
│ name ┆ birthdate ┆ weight ┆ height │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ date ┆ f64 ┆ f64 │
╞════════════════╪════════════╪════════╪════════╡
│ Alice Archer ┆ 1997-01-10 ┆ 57.9 ┆ 1.56 │
│ Ben Brown ┆ 1985-02-15 ┆ 72.5 ┆ 1.77 │
│ Chloe Cooper ┆ 1983-03-22 ┆ 53.6 ┆ 1.65 │
│ Daniel Donovan ┆ 1981-04-30 ┆ 83.1 ┆ 1.75 │
└────────────────┴────────────┴────────┴────────┘

有关CSV文件格式和其他数据格式的更多示例，请参阅用户指南的输入输出部分。

谓词下推

Fri, 21 Mar 2025 14:45:29 +0800

谓词下推#

谓词下推是Polars所做的优化，可以减少查询时间和内存使用。谓词是数据库行话，用于在某个表上应用过滤器，从而减少该表上的行数。

那么，让我们看看是否可以加载一些Reddit数据并对几个谓词进行过滤。

import polars as pl

from ..paths import DATA_DIR

q1 = (
 pl.scan_csv(f"{DATA_DIR}/reddit.csv")
 .filter(pl.col("comment_karma") > 0) # 谓词过滤
 .filter(pl.col("link_karma") > 0)
 .filter(pl.col("name").str.contains(r"^a")) # filter name that start with an "a"
)

如果我们在上面运行这个查询，什么都不会发生！这是由于懒惰的评估。除非特别要求，否则不会发生任何事情。这使Polars能够看到查询的整个上下文，并及时优化以执行。

.collect方法请求执行。这将查询所有可用数据。在编写、优化和检查查询时，这通常是不可取的。另一个调用执行的方法是.fetch方法。.fetch接受一个参数n_rows，并尝试在数据源上’获取’该数量的行（尽管没有给出任何保证）。

因此，让我们从源文件中“获取”约1000万行，并应用谓词。

q1.fetch(n_rows=int(1e7))

shape: (656, 6)
┌─────────┬─────────────┬─────────────┬────────────┬───────────────┬────────────┐
│ id ┆ name ┆ created_utc ┆ updated_on ┆ comment_karma ┆ link_karma │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ i64 ┆ i64 ┆ i64 │
╞═════════╪═════════════╪═════════════╪════════════╪═══════════════╪════════════╡
│ 77860 ┆ aquarin ┆ 1137474000 ┆ 1536528294 ┆ 150 ┆ 11 │
│ 77974 ┆ aadvaark ┆ 1137301200 ┆ 1536528294 ┆ 26 ┆ 47 │
│ 78004 ┆ apoisel ┆ 1137301200 ┆ 1536497404 ┆ 42 ┆ 2549 │
│ 78041 ┆ aonic ┆ 1137301200 ┆ 1536497404 ┆ 2931 ┆ 2095 │
│ … ┆ … ┆ … ┆ … ┆ … ┆ … │
│ 1192656 ┆ atothedrian ┆ 1162785880 ┆ 1536497412 ┆ 748 ┆ 585 │
│ 1204607 ┆ akbusiness ┆ 1162899425 ┆ 1536532995 ┆ 73 ┆ 512 │
│ 1214809 ┆ aaminics ┆ 1162969322 ┆ 1536533034 ┆ 22 ┆ 6 │
│ 1225341 ┆ antonulrich ┆ 1163110623 ┆ 1536497412 ┆ 9304 ┆ 1782 │
└─────────┴─────────────┴─────────────┴────────────┴───────────────┴────────────┘

上面我们看到，从1000万行中，61503行匹配我们的谓词。

字符串

Fri, 21 Mar 2025 13:45:29 +0800

字符串#

了解Arrow和Polars使用的内存格式可以真正提高查询的性能. 对于大型字符串数据尤其如此。下图显示了Arrow UTF8数组在内存中的布局。

数组[“foo”、“bar”、“ham”]由以下编码：

连接字符串foobarham，
一个偏移数组，指示每个字符串[0,2,5,8]的开始（和结束），
空位图，指示空值。

如果我们要读取字符串值，这种内存结构的缓存效率非常高。尤其是如果我们将它与Vec<String>（在Rust中由堆分配的字符串数据组成的数组）进行比较。

然而，如果我们需要对Arrow UTF8数组重新排序，我们需要交换字符串值的所有字节，这在处理大型字符串时可能会非常昂贵。另一方面，对于Vec<String>，我们只需要交换指针，只需移动8字节的数据，成本很低。由于一项操作（过滤、连接、分组等）而嵌入大量Utf8 Series的DataFrame的重新排序可能很快变得非常昂贵。

范畴型#

因此，Polars有一个CategoricalType。category Series是一个数组，其中填充了u32值，每个值代表一个唯一的字符串值。因此，在保持缓存效率的同时，移动值的成本也很低。

在下面的示例中，我们将演示如何将一个Utf8 Series列强制转换为一个Categorical Series。

import polars as pl

df["utf8-column"].cast(pl.Categorical)

在分类数据上加入多个数据帧#

当需要基于字符串数据连接两个DataFrame时，需要同步Category数据（df1的A列中的数据需要指向与df2中的B列相同的底层字符串数据）。可以通过在StringCache上下文管理器中强制转换数据来实现。这将在该上下文管理器期间同步所有可发现的字符串值。如果希望全局字符串缓存在整个运行期间存在，可以将toggle_string_cache设置为True。

import polars as pl

df1 = pl.DataFrame({"a": ["foo", "bar", "ham"], "b": [1, 2, 3]})
df2 = pl.DataFrame({"a": ["foo", "spam", "eggs"], "c": [3, 2, 2]})

with pl.StringCache():
 df1.with_columns(pl.col("a").cast(pl.Categorical))
 df2.with_columns(pl.col("a").cast(pl.Categorical))

惰性连接分类数据上的多个数据帧#

在查询期间（直到调用.collect()），惰性查询始终具有全局字符串缓存（除非您选择退出）。下面的示例显示了如何将两个DataFrame与Category类型连接起来。

import polars as pl

lf1 = pl.DataFrame({"a": ["foo", "bar", "ham"], "b": [1, 2, 3]}).lazy()
lf2 = pl.DataFrame({"a": ["foo", "spam", "eggs"], "c": [3, 2, 2]}).lazy()

lf1 = lf1.with_columns(pl.col("a").cast(pl.Categorical))
lf2 = lf2.with_columns(pl.col("a").cast(pl.Categorical))

lf1.join(lf2, on="a", how="inner")

Polars自定义函数

Fri, 21 Mar 2025 13:42:29 +0800

Polars自定义函数#

总会有一个操作非常特殊，以至于人们无法用Polars的公共方法来完成它。幸运的是，polars允许您应用自定义函数。这意味着可以定义一个Python函数（或lambda），并将其传递给逻辑计划。

假设我们想要以一种迫切（eager）的方式将一个映射操作应用于一个Polars Series。这可以按如下所示进行：

import polars as pl

my_map = {1: "foo", 2: "bar", 3: "ham", 4: "spam", 5: "eggs"}

s = pl.Series("a", [1, 2, 3, 4, 5]) # 构建Series
s = s.apply(lambda x: my_map[x]) # 用lambda表达式添加Series

shape: (5,)
Series: 'a' [str]
[
 "foo"
 "bar"
 "ham"
 "spam"
 "eggs"
]

然而，由于Polars Series只能包含一个数据类型，因此存在一些问题。

在上面的apply()方法中我们没有指定Series应该包含的数据类型Polars试图通过调用提供的函数本身来提前推断输出数据类型。如果它后来得到的数据类型与最初推断的类型不匹配，则该值将被指示为缺失（null）。

如果输出数据类型已知，建议将该信息提供给Polars（通过.apply()的dtype选项）。

注意，应用函数后可能会更改数据类型：我们上面使用的lambda得到一个整数作为输入，并在my_map字典中找到正确的键后返回一个字符串（pl.Utf8）。

使用map或者apply?#

使用自定义函数有两种方法，一种是使用map，另一种是使用apply。您需要哪一个取决于使用自定义函数的上下文：

apply
- 选择上下文：自定义函数应用于所有值 Fn(value) -> y
- 聚合上下文：自定义函数应用于所有组 Fn([group_value_1, ... group_value_n]) -> y
map
- 选择上下文：自定义函数应用于Series，并且必须生成一个新的Series Fn(Series) -> Series
- 聚合上下文：自定义函数应用于Series，并且必须生成一个新的Series Fn(Series) -> Series

选中行或列

Fri, 21 Mar 2025 11:27:29 +0800

选中行或列#

对行或列进行选择的操作与其他数据框架库类似。

选中列#

# 推荐写法
df.select(["a", "b"])
# 也可以写成这样
df(["a", "b"])

shape: (5, 2)
┌──────┬──────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ str │
╞══════╪══════╡
│ 1 ┆ foo │
│ 2 ┆ ham │
│ 3 ┆ spam │
│ null ┆ egg │
│ 5 ┆ null │
└──────┴──────┘

选中行#

df[0:2]

shape: (2, 4)
┌─────┬─────┬──────────┬─────┐
│ a ┆ b ┆ c ┆ d │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ f64 ┆ str │
╞═════╪═════╪══════════╪═════╡
│ 1 ┆ foo ┆ 0.37454 ┆ a │
│ 2 ┆ ham ┆ 0.950714 ┆ b │
└─────┴─────┴──────────┴─────┘

字符串

Fri, 21 Mar 2025 11:26:29 +0800

字符串#

由于 Arrow 后端, Polars字符串操作比使用NumPy或Pandas执行的相同操作快得多。在后者中，字符串存储为Python对象。在遍历np.array or the pd.Series时，CPU需要跟踪所有字符串指针，并跳转到许多随机内存位置——这是非常低效的缓存。在Polars（通过Arrow数据结构）中，字符串在内存中是连续的。因此，对于CPU来说，遍历缓存是最优的，也是可预测的。

Polars中可用的字符串处理函数可以在 ``str` namespace 中找到。

下面是几个例子。要计算字符串长度，请执行以下操作：

import polars as pl

df = pl.DataFrame({"shakespeare": "All that glitters is not gold".split(" ")})

df = df.with_columns(pl.col("shakespeare").str.lengths().alias("letter_count"))

shape: (6, 2)
┌─────────────┬──────────────┐
│ shakespeare ┆ letter_count │
│ --- ┆ --- │
│ str ┆ u32 │
╞═════════════╪══════════════╡
│ All ┆ 3 │
│ that ┆ 4 │
│ glitters ┆ 8 │
│ is ┆ 2 │
│ not ┆ 3 │
│ gold ┆ 4 │
└─────────────┴──────────────┘

下面是从句子中过滤出冠词（the、a、and、etc.）的正则表达式模式：

Arrow

Fri, 21 Mar 2025 11:24:29 +0800

Arrow#

Arrow 正在迅速地成为列式数据 事实上 的标准。这意味着对 Arrow 的支持（包括语言与工具）也在迅速增加。由于开发者在这种格式的背后投入了大量的努力与支持，使用 Arrow 可能是完成下面任务最快的方式：

读写 Parquet 格式的文件
从 CSV 读取列式数据
交换列式数据

Polars 使用 Arrow 内存缓冲作为 Polars Series 最基本的构建模块。这意味着当我们要在 Polars 和 Arrow 之间交换数据时，无需对数据进行拷贝操作。这也意味着 Polars 获得了 Arrow 带来的一切性能提升。

要将 Polars 的 DataFrame 或者 Series 转换为 Arrow，只需使用 .to_arrow() 函数。类似的，要从 Arrow 格式导入数据，可以调用 .from_arrow() 函数。

Polars操作CSV文件

Fri, 21 Mar 2025 10:22:29 +0800

Polars操作CSV文件#

读与写#

读取CSV文件应该看起来很熟悉:

df = pl.read_csv("path.csv")

CSV文件会有非常多的样式，所以一定要去看一下 read_csv() API。

写入CSV文件可以用 write_csv()方法。

df = pl.DataFrame({"foo": [1, 2, 3], "bar": [None, "bak", "baz"]})
df.write_csv("path.csv")

扫描#

Polars允许你扫描CSV文件。扫描操作延迟了对文件的实际解析，并返回一个延迟计算的容器LazyFrame。

df = pl.scan_csv("path.csv")

如果你想了解更多这样设计的精妙之处，请移步PolarsOptimizations这一章。

Polars表达式和上下文

Fri, 07 Mar 2025 10:46:29 +0800

Polars表达式和上下文#

Polars开发了其专有的领域特定语言（DSL）用于转换数据。这种语言非常易于使用，能够进行复杂的查询，同时查询语句仍具有可读性。这里将介绍的表达式和上下文，对于实现这种可读性至关重要，同时它们也能让Polars查询引擎对你的查询进行优化，使其尽可能快速地运行。

Polars表达式#

在Polars中，表达式是数据转换的一种惰性表示形式。表达式具有模块化和灵活性，这意味着你可以将它们用作构建块来构建更复杂的表达式。以下是一个Polars表达式的示例：

import polars as pl

pl.col("weight") / (pl.col("height") ** 2)

正如你可能猜到的，这个表达式选取了名为“体重（weight）”的一列，并将该列的值除以“身高（height）”列中值的平方，从而计算出一个人的身体质量指数（BMI）。

上面的代码表达了一种抽象的计算过程，我们可以将其保存到一个变量中，进一步进行处理，或者直接打印出来：

bmi_expr = pl.col("weight") / (pl.col("height") ** 2)
print(bmi_expr)

[(col("weight")) / (col("height").pow([dyn int: 2]))]

由于表达式是惰性的，目前尚未进行任何计算。这就是我们需要上下文的原因。

Polars上下文#

Polars表达式需要在一个上下文中执行才能产生结果。根据其使用的上下文不同，同一个Polars表达式可能会产生不同的结果。在本节中，我们将了解Polars提供的四种最常见的上下文：

select
with_columns
filter
group_by

我们使用下面的dataframe来展示每种上下文是如何工作的。

from datetime import date

df = pl.DataFrame(
 {
 "name": ["Alice Archer", "Ben Brown", "Chloe Cooper", "Daniel Donovan"],
 "birthdate": [
 date(1997, 1, 10),
 date(1985, 2, 15),
 date(1983, 3, 22),
 date(1981, 4, 30),
 ],
 "weight": [57.9, 72.5, 53.6, 83.1], # (kg)
 "height": [1.56, 1.77, 1.65, 1.75], # (m)
 }
)

print(df)

shape: (4, 4)
┌────────────────┬────────────┬────────┬────────┐
│ name ┆ birthdate ┆ weight ┆ height │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ date ┆ f64 ┆ f64 │
╞════════════════╪════════════╪════════╪════════╡
│ Alice Archer ┆ 1997-01-10 ┆ 57.9 ┆ 1.56 │
│ Ben Brown ┆ 1985-02-15 ┆ 72.5 ┆ 1.77 │
│ Chloe Cooper ┆ 1983-03-22 ┆ 53.6 ┆ 1.65 │
│ Daniel Donovan ┆ 1981-04-30 ┆ 83.1 ┆ 1.75 │
└────────────────┴────────────┴────────┴────────┘

`select`#

选择上下文 select 会对列应用表达式。select 上下文可能会生成新的列，这些新列可以是聚合结果、其他列的组合，或者是字面值：

第 2 章 Python 语法基础

Thu, 06 Mar 2025 22:20:29 +0800

第 2 章 Python 语法基础#

当我在 2011 年和 2012 年写作本书的第一版时，可用的学习 Python 数据分析的资源很少。这部分上是一个鸡和蛋的问题：我们现在使用的库，比如 pandas、scikit-learn 和 statsmodels，那时相对来说并不成熟。2017 年，数据科学、数据分析和机器学习的资源已经很多，原来通用的科学计算拓展到了计算机科学家、物理学家和其它研究领域的工作人员。学习 Python 和成为软件工程师的优秀书籍也有了。

因为这本书是专注于 Python 数据处理的，对于一些 Python 的数据结构和库的特性难免不足。因此，本章和第 3 章的内容只够你能学习本书后面的内容。

在我来看，没有必要为了数据分析而去精通 Python。我鼓励你使用 IPython shell 和 Jupyter 试验示例代码，并学习不同类型、函数和方法的文档。虽然我已尽力让本书内容循序渐进，但读者偶尔仍会碰到没有之前介绍过的内容。

本书大部分内容关注的是基于表格的分析和处理大规模数据集的数据准备工具。为了使用这些工具，必须首先将混乱的数据规整为整洁的表格（或结构化）形式。幸好，Python 是一个理想的语言，可以快速整理数据。Python 使用得越熟练，越容易准备新数据集以进行分析。

最好在 IPython 和 Jupyter 中亲自尝试本书中使用的工具。当你学会了如何启动 Ipython 和 Jupyter，我建议你跟随示例代码进行练习。与任何键盘驱动的操作环境一样，记住常见的命令也是学习曲线的一部分。

笔记：本章没有介绍 Python 的某些概念，如类和面向对象编程，你可能会发现它们在 Python 数据分析中很有用。为了加强 Python 知识，我建议你学习官方 Python 教程，或是通用的 Python 教程书籍，比如：

Python Cookbook，第 3 版，David Beazley 和 Brian K. Jones 著（O’Reilly）

流畅的 Python，Luciano Ramalho 著（O’Reilly）

高效的 Python，Brett Slatkin 著（Pearson）

2.1 Python 解释器#

Python 是解释性语言。Python 解释器同一时间只能运行一个程序的一条语句。标准的交互 Python 解释器可以在命令行中通过键入python命令打开：

安装Polars

Thu, 06 Mar 2025 22:13:29 +0800

安装Polars#

Polars是一个库，安装起来就像调用相应编程语言的包管理器一样简单。

pip install polars

#或者对于那些不支持高级矢量扩展指令集2（AVX2）的旧CPU
pip install polars-lts-cpu

cargo add polars -F lazy

# Or Cargo.toml
[dependencies]
polars = { version = "x", features = ["lazy", ...]}

大索引#

默认情况下，Polars dataframes的行数限制为2^32(约43亿)行。通过启用大索引扩展功能，可将此限制提升至2^64(约1800京）行：

pip install polars-u64-idx

cargo add polars -F bigidx

# Or Cargo.toml
[dependencies]
polars = { version = "x", features = ["bigidx", ...] }

旧款CPU#

在不支持高级矢量扩展指令集（AVX）的旧款 CPU 上为 Python 安装 Polars，请运行：

pip install polars-lts-cpu

导入polars#

要使用polars库，只需将其导入到你的项目中即可：

import polars as pl

use polars::prelude::*;

特性标志#

通过使用上述命令，你可以将 Polars 的核心部分安装到你的系统上。然而，根据你的使用场景，你可能还需要安装一些可选的依赖项。将这些设置为可选的目的是尽量减少占用空间。根据编程语言的不同，相应的标志也有所不同。在整个用户指南中，当所使用的某项功能需要额外的依赖项时，将会提别提醒。

Python#

# 示例
pip install 'polars[numpy,fsspec]'

All#

标志	说明
all	安装所有可选的依赖项。

GPU#

标志	说明
gpu	在英伟达（NVIDIA）图形处理器（GPU）上运行查询。

说明

投影下推

Fri, 21 Mar 2025 15:25:29 +0800

投影下推#

我们来把上一章节中的查询与在 Runescape （一款游戏）数据中进行 FILTER 操作的结果结合起来，来找出以字母 a 开头且玩过 Runescape 的流行 Reddit 用户名。相信你一定也会对此感兴趣的！

你可以构建类似于以下的查询：

import polars as pl

from ..paths import DATA_DIR

reddit = (
 pl.scan_csv(f"{DATA_DIR}/reddit.csv")
 .filter(pl.col("comment_karma") > 0)
 .filter(pl.col("link_karma") > 0)
 .filter(pl.col("name").str.contains(r"^a"))
)

runescape = pl.scan_csv("data/runescape.csv", has_header=False).select(pl.col("column_1").alias("name"))

dataset = reddit.join(runescape, on="name", how="inner").select(["name", "comment_karma", "link_karma"])

df1 = dataset.fetch(int(1e7))
df2 = dataset.fetch(int(1e7), predicate_pushdown=True, projection_pushdown=True)

这将产出以下 DataFrame：

shape: (0, 3)
┌──────┬───────────────┬────────────┐
│ name ┆ comment_karma ┆ link_karma │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 │
╞══════╪═══════════════╪════════════╡
└──────┴───────────────┴────────────┘

更近一步#

让我们再来看看查询计划。

Polars窗口函数

Fri, 21 Mar 2025 13:42:29 +0800

Polars窗口函数#

Polars 支持窗口函数，灵感来自于PostgreSQL. Pandas 用户可能会将其识别为a groupby.transform(aggregation).

Polars 窗口函数比Pandas转换（transform）函数更加优雅. 我们可以在一个表达式中的多个列上应用多个函数！

import polars as pl

dataset = pl.DataFrame(
 {
 "A": [1, 2, 3, 4, 5],
 "fruits": ["banana", "banana", "apple", "apple", "banana"],
 "B": [5, 4, 3, 2, 1],
 "cars": ["beetle", "audi", "beetle", "beetle", "beetle"],
 }
)

q = dataset.lazy().with_columns(
 [
 pl.sum("A").over("fruits").alias("fruit_sum_A"), # 在"fruits"列的基础上进行"A"的加和，并另起一列
 pl.first("B").over("fruits").alias("fruit_first_B"),
 pl.max("B").over("cars").alias("cars_max_B"),
 ]
)

df = q.collect()

shape: (5, 7)
┌─────┬────────┬─────┬────────┬─────────────┬───────────────┬────────────┐
│ A ┆ fruits ┆ B ┆ cars ┆ fruit_sum_A ┆ fruit_first_B ┆ cars_max_B │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ str ┆ i64 ┆ i64 ┆ i64 │
╞═════╪════════╪═════╪════════╪═════════════╪═══════════════╪════════════╡
│ 1 ┆ banana ┆ 5 ┆ beetle ┆ 8 ┆ 5 ┆ 5 │
│ 2 ┆ banana ┆ 4 ┆ audi ┆ 8 ┆ 5 ┆ 4 │
│ 3 ┆ apple ┆ 3 ┆ beetle ┆ 7 ┆ 3 ┆ 5 │
│ 4 ┆ apple ┆ 2 ┆ beetle ┆ 7 ┆ 3 ┆ 5 │
│ 5 ┆ banana ┆ 1 ┆ beetle ┆ 8 ┆ 5 ┆ 5 │
└─────┴────────┴─────┴────────┴─────────────┴───────────────┴────────────┘

常用操作

Fri, 21 Mar 2025 11:28:29 +0800

常用操作#

与许多其他数据框架库一样，Polars 提供了大量的常用函数来对 Dataframe 进行操作。熟悉 Dataframes 的用户会发现 Polars 与 Pandas 或 R 的实现有许多相似之处。

添加列#

out = df.with_columns(pl.Series(["p", "q", "r", "s", "t"]).alias("e")) # .alias方法增加一列
print(out)

shape: (5, 5)
┌──────┬──────┬──────────┬─────┬─────┐
│ a ┆ b ┆ c ┆ d ┆ e │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ f64 ┆ str ┆ str │
╞══════╪══════╪══════════╪═════╪═════╡
│ 1 ┆ foo ┆ 0.37454 ┆ a ┆ p │
│ 2 ┆ ham ┆ 0.950714 ┆ b ┆ q │
│ 3 ┆ spam ┆ 0.731994 ┆ c ┆ r │
│ null ┆ egg ┆ 0.598658 ┆ d ┆ s │
│ 5 ┆ null ┆ 0.156019 ┆ e ┆ t │
└──────┴──────┴──────────┴─────┴─────┘

类型转换#

这个例子使用的是 Python 数据类型，但我们也可以在 Polars dtypes （如 pl.Float32、pl.Float64）之间进行转换。

时间戳

Fri, 21 Mar 2025 11:27:29 +0800

时间戳#

Polars 提供了4时间数据类型：

pl.Date, 用于日期对象：自UNIX纪元以来的天数，为32位有符号整数。
pl.Datetime, 用于datetime项目：自UNIX纪元以来的纳秒数，为64位有符号整数。
pl.Time, 编码为午夜后的纳秒数。

Polars 字符串(pl.Utf8) 数据类型可以解析为它们中的任何一个。您可以让Polars尝试猜测日期[time]的格式，或者显式提供fmt规则。

举例来说（查看此此链接以获取全面列表）：

"%Y-%m-%d" 对于 "2020-12-31"
"%Y/%B/%d" 对于 "2020/December/31"
"%B %y" 对于 "December 20"

下面是一个简单的例子：

import polars as pl

dataset = pl.DataFrame({"date": ["2020-01-02", "2020-01-03", "2020-01-04"], "index": [1, 2, 3]})

q = dataset.lazy().with_columns(pl.col("date").str.strptime(pl.Date, "%Y-%m-%d"))

df = q.collect()

shape: (3, 2)
┌────────────┬───────┐
│ date ┆ index │
│ --- ┆ --- │
│ date ┆ i64 │
╞════════════╪═══════╡
│ 2020-01-02 ┆ 1 │
│ 2020-01-03 ┆ 2 │
│ 2020-01-04 ┆ 3 │
└────────────┴───────┘

所有datetime功能都显示在 dt 命名空间中。

Numpy

Fri, 21 Mar 2025 11:25:29 +0800

Numpy#

Polars 的 Series 支持 NumPy 的通用函数 (ufuncs)。调用元素层面的 (element-wise) 函数，比如 np.exp()、np.cos() 或 np.div()，基本上没有额外开销。

需要注意的是，Polars 中的缺失值是一个独立的比特掩码 —— 其在 NumPy 中是不可见的。这可能导致窗口函数或 np.convolve() 输出有缺陷或不完整的结果。

要将一个 Polars Series 转换为 NumPy 数组，可以调用 .to_numpy() 函数。转换时，此函数将会把缺失值替换为 np.nan。如果 Series 中没有缺失值，或转换后不再需要这些值，可以使用 .view() 函数作为代替，这将为数据生成一个零拷贝的 NumPy 数组。

Polars操作Parquet文件

Fri, 21 Mar 2025 10:23:29 +0800

Parquet文件#

加载或写入 Parquet文件快如闪电。

Pandas 使用 PyArrow（用于Apache Arrow的Python库）将Parquet数据加载到内存，但不得不将数据复制到了Pandas的内存空间中。

Polars就没有这部分额外的内存开销，因为读取Parquet时，Polars会直接复制进Arrow的内存空间，且始终使用这块内存。

读&写#

df = pl.read_parquet("path.parquet")

df = pl.DataFrame({"foo": [1, 2, 3], "bar": [None, "bak", "baz"]})
df.write_parquet("path.parquet")

扫描#

Polars允许你扫描Parquet输入。扫描操作延迟了对文件的实际解析，并返回一个延迟计算的容器LazyFrame。

df = pl.scan_parquet("path.parquet")

如果你想了解更多这样设计的精妙之处，请移步PolarsOptimizations这一章。

Polars索引

Thu, 20 Mar 2025 13:22:29 +0800

Polars索引#

Polars DataFrame没有索引，因此索引行为可以是一致的，而不需要 df.loc, df.iloc, or a df.at 操作。

规则如下（取决于值的数据类型）:

数值型
- axis 0: 行（row）
- axis 1: 列（column）
数值型 + 字符串
- axis 0: 行（这里只接收数字)
- axis 1: 列（接受数字+字符串值）
仅字符串
- axis 0: 列（column）
- axis 1: 报错（error）
表达式

所有表达式求值都是并行执行的
- axis 0: 列（column）
- axis 1: 列（column）
- ..
- axis n: 列（column）

与Pandas的对比#

pandas	polars
选择列 `df.iloc[2]`	`df[2, :]`
按索引选择几行 `df.iloc[[2, 5, 6]]`	`df[[2, 5, 6], :]`
选择行的切片 `df.iloc[2:6]`	`df[2:6, :]`
使用布尔掩码（boolean mask）选择行 `df.iloc[True, True, False]`	`df[[True, True, False]]`
按谓词（predicate）条件选择行 `df.loc[df["A"] > 3]`	`df[df["A"] > 3]`
选择列的切片 `df.iloc[:, 1:3]`	`df[:, 1:3]`
按字符串顺序选择列的切片 `df.loc[:, "A":"Z"]`	`df[:, "A":"Z"]`
选择单个值（标量） `df.loc[2, "A"]`	`df[2, "A"]`
选择单个值（标量） `df.iloc[2, 1]`	`df[2, 1]`
选择单个值（Series或DataFrame） `df.loc[2, ["A"]]`	`df[2, ["A"]]`
选择单个值 (Series或DataFrame) `df.iloc[2, [1]]`	`df[2, [1]]`

表达式#

表达式也可以用于索引（它是df.select的语法糖）。

Polars表达式

Thu, 20 Mar 2025 13:20:29 +0800

Polars 表达式#

下面是一个表达式：

pl.col("foo").sort().head(2)

这个表达式的意思是：

选择 foo 列
给 foo 排序
然后取排序后的前两个值

表达式的强大之处在于：每一个表达式都会生成一个新的表达式，他们可以被串在一起。你也可以把多个表达式放入一个 Polars 的执行上下文中。

比如，下面我们通过 df.select 将两个表达式放在同一个执行上下文中：

df.select([
 pl.col("foo").sort().head(2),
 pl.col("bar").filter(pl.col("foo") == 1).sum()
])

这里的两个表达式是并行执行的，这就意味着 Polars 表达式可以易并行计算（即无通讯并行）。值得注意的是，每一个表达式的执行可能同时存在更多的并行。

表达式举例#

这一小节我们通过例子了解表达式。首先，创建一个数据集：

import polars as pl
import numpy as np

np.random.seed(12) # 设置随机数种子（保证每次生成的随机数相同）

df = pl.DataFrame(
 {
 "nrs": [1, 2, 3, None, 5],
 "names": ["foo", "ham", "spam", "egg", None],
 "random": np.random.rand(5),
 "groups": ["A", "A", "B", "C", "B"],
 }
)

print(df)

shape: (5, 4)
┌──────┬───────┬──────────┬────────┐
│ nrs ┆ names ┆ random ┆ groups │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ f64 ┆ str │
╞══════╪═══════╪══════════╪════════╡
│ 1 ┆ foo ┆ 0.154163 ┆ A │
│ 2 ┆ ham ┆ 0.74005 ┆ A │
│ 3 ┆ spam ┆ 0.263315 ┆ B │
│ null ┆ egg ┆ 0.533739 ┆ C │
│ 5 ┆ null ┆ 0.014575 ┆ B │
└──────┴───────┴──────────┴────────┘

你可以通过表达式做很多事情，他们的表达能力很强以至于很多时候你有多种不同的方法得到同一个计算结果。为了更好的理解表达式，让我们看更多的例子。

Polars延迟API

Fri, 07 Mar 2025 11:04:29 +0800

Polars延迟API#

Polars 支持两种操作模式：立即执行模式（eager）和延迟执行模式（lazy）。到目前为止的示例都使用了立即执行 API，在这种模式下，查询会被立即执行。而在延迟执行 API 中，查询只有在调用 collect 方法时才会被求值。将执行操作推迟到最后一刻可以带来显著的性能优势，这也是为什么在大多数情况下更倾向于使用延迟执行 API。下面我们通过一个示例来演示这一点：

df = pl.read_csv("docs/assets/data/iris.csv")
df_small = df.filter(pl.col("sepal_length") > 5)
df_agg = df_small.group_by("species").agg(pl.col("sepal_width").mean())
print(df_agg)

在这个示例中，我们使用立即执行 API 来：

读取鸢尾花数据集。
根据花萼长度对数据集进行筛选。
计算每个品种的花萼宽度的平均值。

每一步都会立即执行并返回中间结果。这可能非常浪费资源，因为我们可能会做一些无用功，或者加载一些未被使用的额外数据。相反，如果我们使用延迟执行 API，并在定义好所有步骤之后再等待执行，那么查询规划器就可以执行各种优化操作。在这种情况下：

谓词下推：在读取数据集时尽早应用筛选条件，这样就只读取花萼长度大于 5 的行。
投影下推：在读取数据集时只选择所需的列，从而无需加载额外的列（例如，花瓣长度和花瓣宽度）。

q = (
 pl.scan_csv("docs/assets/data/iris.csv")
 .filter(pl.col("sepal_length") > 5)
 .group_by("species")
 .agg(pl.col("sepal_width").mean())
)

df = q.collect()

这些优化将显著降低内存和中央处理器（CPU）的负载，从而使你能够在内存中处理更大的数据集，并且处理速度更快。一旦定义好查询，你就调用 collect 方法来告知 Polars 你想要执行该查询。你可以在专门介绍延迟执行 API 的章节中.了解到更多相关信息。

说明:在许多情况下，立即执行 API 实际上在底层调用了延迟执行 API，并且会立即收集结果。这样做的好处是，在查询本身的执行过程中，查询规划器仍然可以进行优化操作。

何时使用哪种模式#

一般来说，应该优先使用延迟执行 API，除非你对中间结果感兴趣，或者正在进行探索性工作，还不确定你的查询最终会是什么样子。

预览查询计划#

在使用延迟执行 API 时，你可以使用 explain 函数让 Polars 创建一份查询计划的描述，当你收集结果时，这份查询计划就会被执行。如果你想了解 Polars 对你的查询执行了哪些类型的优化，这个功能会很有用。我们可以让 Polars 解释一下我们上面定义的查询 q：

print(q.explain())

AGGREGATE
 [col("sepal_width").mean()] BY [col("species")] FROM
 simple π 3/3 ["sepal_width", "species", ... 1 other column]
 Csv SCAN [docs/assets/data/iris.csv]
 PROJECT 3/5 COLUMNS
 SELECTION: [(col("sepal_length")) > (5.0)]

我们可以从解释中立刻看出，Polars 确实应用了谓词下推，因为它只读取花萼长度大于 5 的行；并且它也应用了投影下推，因为它只读取查询所需的列。

第 3 章 Python 的数据结构、函数和文件

Thu, 06 Mar 2025 22:20:29 +0800

第 3 章 Python 的数据结构、函数和文件#

本章讨论 Python 的内置功能，这些功能本书会用到很多。虽然扩展库，比如 pandas 和 Numpy，使处理大数据集很方便，但它们是和 Python 的内置数据处理工具一同使用的。

我们会从 Python 最基础的数据结构开始：元组、列表、字典和集合。然后会讨论创建你自己的、可重复使用的 Python 函数。最后，会学习 Python 的文件对象，以及如何与本地硬盘交互。

3.1 数据结构和序列#

Python 的数据结构简单而强大。通晓它们才能成为熟练的 Python 程序员。

元组#

元组是一个固定长度，不可改变的 Python 序列对象。创建元组的最简单方式，是用逗号分隔一列值：

In [1]: tup = 4, 5, 6

In [2]: tup
Out[2]: (4, 5, 6)

当用复杂的表达式定义元组，最好将值放到圆括号内，如下所示：

In [3]: nested_tup = (4, 5, 6), (7, 8)

In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

用tuple可以将任意序列或迭代器转换成元组：

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

In [6]: tup = tuple('string')

In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

可以用方括号访问元组中的元素。和 C、C++、JAVA 等语言一样，序列是从 0 开始的：

In [8]: tup[0]
Out[8]: 's'

元组中存储的对象可能是可变对象。一旦创建了元组，元组中的对象就不能修改了：

其它优化

Fri, 21 Mar 2025 15:35:29 +0800

其它优化#

除了谓词和投影下推之外，Polars还进行其他优化。

一个重要的主题是可选的缓存和并行化。很容易想象，有两种不同的DataFrame计算会导致扫描同一个文件Polars可能会缓存扫描的文件，以防止扫描同一文件两次。但是，如果您愿意，可以重写此行为并强制Polars读取同一文件。这可能会更快，因为扫描可以并行进行。

联结并行化#

如果我们查看上一个查询，就会发现join操作有一个输入带有data/reddit.csv的计算路径作为根目录，一个路径带有data/runescape.csv作为根目录。Polars可以观察到两个DataFrame之间没有依赖关系，将并行读取这两个文件。如果在加入之前完成了其他操作（例如groupby、filters等），它们也会并行执行。

简化表达式#

其他一些优化是表达式简化。这些优化的影响比谓词和投影下推的影响小，但它们很可能加起来。你可以追踪这个问题查看这些的最新状态。

聚合

Fri, 21 Mar 2025 11:30:29 +0800

聚合#

你可以调用 .select() 函数或使用 .with_column()/.with_columns() 上下文进行列聚合操作。

要对所有列进行聚合，可以使用通配符表达式： .select(pl.col("*").sum())。

以下面的代码为例：

import polars as pl

# 扫描级导入csv数据集
q = pl.scan_csv("data/reddit.csv").select([pl.sum("comment_karma"), pl.min("link_karma")])

df = q.fetch()

其结果为：

shape: (1, 2)
┌───────────────┬────────────┐
│ comment_karma ┆ link_karma │
│ --- ┆ --- │
│ i64 ┆ i64 │
╞═══════════════╪════════════╡
│ 242649 ┆ -109 │
└───────────────┴────────────┘

更多内容请参见表达式的 API 文档。

分组

Fri, 21 Mar 2025 11:29:29 +0800

分组#

急性 & 惰性#

分组操作的语法在两个 API 中是类似的 —— 二者中均可使用表达式。要完成分组操作，先调用 .groupby() 函数，并跟随一个 .agg() 函数。

在 .agg() 函数中，你可以对任意数量的列进行任意聚合操作。要对所有列进行聚合，可以使用通配符表达式： .agg(pl.col("*").sum())。

来看一个简单的（惰性）例子：

import polars as pl

q = (
 pl.scan_csv("data/reddit.csv")
 .groupby("comment_karma")
 .agg([pl.col("name").n_unique().alias("unique_names"), pl.max("link_karma")])
 .sort(by="unique_names", descending=True) # 逆序排列，reverse=True
)

df = q.fetch()

这将返回下面的结果：

shape: (100, 3)
┌───────────────┬──────────────┬────────────┐
│ comment_karma ┆ unique_names ┆ link_karma │
│ --- ┆ --- ┆ --- │
│ i64 ┆ u32 ┆ i64 │
╞═══════════════╪══════════════╪════════════╡
│ 0 ┆ 367 ┆ 611 │
│ 1 ┆ 9 ┆ 22 │
│ 3 ┆ 6 ┆ 1 │
│ 38 ┆ 4 ┆ 291 │
│ … ┆ … ┆ … │
│ -5 ┆ 1 ┆ 0 │
│ 232 ┆ 1 ┆ 47 │
│ 835 ┆ 1 ┆ 1154 │
│ 431 ┆ 1 ┆ 8 │
└───────────────┴──────────────┴────────────┘

Polars处理多个文件

Fri, 21 Mar 2025 10:24:29 +0800

处理多个文件#

Polars可以根据您的需要和内存紧张程度，以不同的方式处理多个文件。

让我们创建一些文件来使用一些上下文（context）：

import polars as pl

df = pl.DataFrame({"foo": [1, 2, 3], "bar": [None, "ham", "spam"]})

for i in range(5):
 df.write_csv(f"my_many_files_{i}.csv")

读入单个`DataFrame`#

要将多个文件读入一个DataFrame，我们可以使用全局模式：

df = pl.read_csv("my_many_files_*.csv")
print(df)

shape: (15, 2)
┌─────┬──────┐
│ foo ┆ bar │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪══════╡
│ 1 ┆ null │
│ 2 ┆ ham │
│ 3 ┆ spam │
│ 1 ┆ null │
│ … ┆ … │
│ 3 ┆ spam │
│ 1 ┆ null │
│ 2 ┆ ham │
│ 3 ┆ spam │
└─────┴──────┘

要了解这是如何工作的，我们可以看看查询计划。下面我们可以看到，所有文件都是单独读取并连接成一个DataFrame 。Polars将尝试将读取并行化。

Polars上下文

Fri, 21 Mar 2025 09:20:29 +0800

Polars上下文#

表达式几乎可以在任何地方使用，但是表达式需要一个上下文，这些上下文包括：

选择: df.select([..])
分组集合: df.groupby(..).agg([..])
横向堆叠(hstack) 或者增加列: df.with_columns([..])

语法糖#

需要上下文的主要原因是：即使在即时执行中，你也在使用 Polars 的延迟执行API。比如如下代码实例：

df.groupby("foo").agg([pl.col("bar").sum()])

去掉语法糖后：

(df.lazy().groupby("foo").agg([pl.col("bar").sum()])).collect()

这种设计可以让 Polars 把表达式推送给查询引擎，进行一些优化和缓存操作。

`select` 上下文#

在 select 上下文中，选择操作是按照列进行的。在选择向下文的表达式必须要返回 Series 并且这些 Series 需要有相同的长度或者长度为1。

一个长度为 1 的 Series 会将 DataFrame 的一列赋予完全一样的值(这个值来自Series)。注意，select 可能会返回一个新的列，这个列可能是一些聚合的结果、一些表达式的组合或者常量。

选择上下文#

out = df.select(
 [
 pl.sum("nrs"),
 pl.col("names").sort(),
 pl.col("names").first().alias("first name"),
 (pl.mean("nrs") * 10).alias("10xnrs"),
 ]
)
print(out)

shape: (5, 4)
┌─────┬───────┬────────────┬────────┐
│ nrs ┆ names ┆ first name ┆ 10xnrs │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ str ┆ f64 │
╞═════╪═══════╪════════════╪════════╡
│ 11 ┆ null ┆ foo ┆ 27.5 │
│ 11 ┆ egg ┆ foo ┆ 27.5 │
│ 11 ┆ foo ┆ foo ┆ 27.5 │
│ 11 ┆ ham ┆ foo ┆ 27.5 │
│ 11 ┆ spam ┆ foo ┆ 27.5 │
└─────┴───────┴────────────┴────────┘

添加列

Polars数据类型

Thu, 20 Mar 2025 13:22:29 +0800

Polars数据类型#

Polars完全基于Arrow数据类型，并由Arrow内存阵列支持。这使得数据处理缓存效率高，支持进程间通信。大多数数据类型遵循确切的实现来自Arrow，除了Utf8（实际上是LargeUtf8）、category和Object（支持有限）。

这些数据类型是:

Int8: 8位有符号整数。
Int16: 16位有符号整数。
Int32: 32位有符号整数。
Int64: 64位有符号整数。
UInt8: 8位有符号整数。
UInt16: 16位无符号整数。
UInt32: 32位无符号整数。
UInt64: 64位无符号整数。
Float32: 32位浮点数。
Float64: 64位浮点数。
Boolean: 布尔型有效位压缩。
Utf8: 字符串数据（内部实际上是Arrow LargeUtf8）。
List: 列表数组包含着包含列表值的子数组和偏移数组。（这实际上是内部的Arrow LargeList）。
Date: 日期表示，内部表示为自UNIX纪元以来的天数，由32位有符号整数编码。
Datetime: Datetime表示法，内部表示为自UNIX纪元以来的纳秒，由64位有符号整数编码。
Duration: 时间型。在减去Date/Datetime时创建。
Time: 时间表示法，从午夜开始在内部表示为纳秒。
Object: 受支持的有限数据类型，可以是任何值。

要了解有关这些数据类型的内部表示形式的更多信息，请查看Arrow柱状格式。

第 4 章 NumPy 基础：数组和向量计算

Thu, 06 Mar 2025 22:20:29 +0800

第 4 章 NumPy 基础：数组和向量计算#

NumPy（Numerical Python 的简称）是 Python 数值计算最重要的基础包。大多数提供科学计算的包都是用 NumPy 的数组作为构建基础。

NumPy 的部分功能如下：

ndarray，一个具有向量算术运算和复杂广播能力的快速且节省空间的多维数组。
用于对整组数据进行快速运算的标准数学函数（无需编写循环）。
用于读写磁盘数据的工具以及用于操作内存映射文件的工具。
线性代数、随机数生成以及傅里叶变换功能。
用于集成由 C、C++、Fortran 等语言编写的代码的 C API。

由于 NumPy 提供了一个简单易用的 C API，因此很容易将数据传递给由低级语言编写的外部库，外部库也能以 NumPy 数组的形式将数据返回给 Python。这个功能使 Python 成为一种包装 C/C++/Fortran 历史代码库的选择，并使被包装库拥有一个动态的、易用的接口。

NumPy 本身并没有提供多么高级的数据分析功能，理解 NumPy 数组以及面向数组的计算将有助于你更加高效地使用诸如 pandas 之类的工具。因为 NumPy 是一个很大的题目，我会在附录 A 中介绍更多 NumPy 高级功能，比如广播。

对于大部分数据分析应用而言，我最关注的功能主要集中在：

用于数据整理和清理、子集构造和过滤、转换等快速的向量化数组运算。
常用的数组算法，如排序、唯一化、集合运算等。
高效的描述统计和数据聚合/摘要运算。
用于异构数据集的合并/连接运算的数据对齐和关系型数据运算。
将条件逻辑表述为数组表达式（而不是带有if-elif-else分支的循环）。
数据的分组运算（聚合、转换、函数应用等）。。

虽然 NumPy 提供了通用的数值数据处理的计算基础，但大多数读者可能还是想将 pandas 作为统计和分析工作的基础，尤其是处理表格数据时。pandas 还提供了一些 NumPy 所没有的领域特定的功能，如时间序列处理等。

笔记：Python 的面向数组计算可以追溯到 1995 年，Jim Hugunin 创建了 Numeric 库。接下来的 10 年，许多科学编程社区纷纷开始使用 Python 的数组编程，但是进入 21 世纪，库的生态系统变得碎片化了。2005 年，Travis Oliphant 从 Numeric 和 Numarray 项目整了出了 NumPy 项目，进而所有社区都集合到了这个框架下。

过滤

Fri, 21 Mar 2025 11:32:29 +0800

过滤#

急性#

Polars 的急性过滤操作与 Pandas 中的非常相似。

import polars as pl

df = pl.DataFrame({"a": [1, 2, 3], "b": [None, "b", "c"]})

mask = df["a"] > 2 # 谓词表达式
out = df[mask] # 谓词过滤

或者用下面更符合 Polars 习惯的方式：

df.filter(pl.col("a") > 2)

惰性#

惰性过滤操作通常使用以下表达：


df = pl.DataFrame({"a": [1, 2, 3], "b": [None, "b", "c"]})

out = df.lazy().filter(pl.col("a") > 2).collect() # 惰性过滤

两者的结果都是：

shape: (1, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪═════╡
│ 3 ┆ c │
└─────┴─────┘

Polars读取数据库

Fri, 21 Mar 2025 10:24:29 +0800

Polars读取数据库#

读取MySQL、Postgres、Sqlite、Redshift、Clickhouse

从以上数据库中读取数据，请先安装connector-x。

$ pip install connectorx>=0.2.0a3

import polars as pl

conn = "postgres://username:password@server:port/database"
query = "SELECT * FROM foo"

pl.read_sql(query, conn)

Polars分组

Fri, 21 Mar 2025 09:21:29 +0800

Polars分组#

多线程#

处理表状数据最高效的方式就是通过“分割-处理-组合”的方式并行地进行。这样的操作正是 Polars 的分组操作的核心，也是 Polars 如此高效的秘密。特别指出，分割和处理都是多线程执行的。

下面的例子展示了分组操作的流程：

对于分割阶段的哈希操作，Polars 使用了无锁多线程方式，如下图所示：

这样的并行操作可以让分组和联合操作非常非常高效。

更多解释参考这篇博客

不要“杀死”并行#

众所周知，Python 慢、水平拓展不好。除了因为是解释型语言，Python 还收到全局解释器锁，GIL。这就意味着，如果你传入一个 lambda 或者 Python 自定义函数，Polars 速度会被限制，即无法使用多核进行并行计算。

这是个很糟糕的情况，特别我们在做 .groupby 的时候会经常传入 lambda 函数。虽然 Polars 支持这种操作，但是请注意 Python 的限制，特别是解释器和GIL。

为了解决这个问题，Polars 实现了一种非常强大的语法，在其延迟执行API和即时执行API上都有定义。

Polars Expressions#

刚才我们提到自定义 Python 函数会损伤并行能力，Polars 提供了惰性 API 来应对这种情况。接下来我们看看这是什么意思。

我们可以从这个数据集开始：US congress dataset.

import polars as pl

from .dataset import dataset

q = (
 dataset.lazy()
 .groupby("first_name")
 .agg(
 [
 pl.count(),
 pl.col("gender"),
 pl.first("last_name"),
 ]
 )
 .sort("count", descending=True)
 .limit(5)
)

df = q.collect()

基本聚合操作#

你可以轻松地把多个聚合表达式放在一个 list 里面，并没有数量限制，你可以任意组合你放入任何数量的表达式。下面这段代码中我们做如下聚合操作：

来自Pandas

Thu, 20 Mar 2025 13:22:29 +0800

来自Pandas#

如果你很熟悉Pandas，那么你只需要知道一件事：

polars != pandas

如果你的Polars代码写起来很像Pandas，程序也许可以运行，但是很有可能会慢于它本该有的速度。

下面我们就通过几段经典Pandas代码来对比同样功能的Polars代码。

列运算#

`Pandas`#

# 以下代码是顺序执行的
df["a"] = df["b"] * 10
df["c"] = df["b"] * 100

`Polars`#

# 以下代码是并发执行的
df.with_columns([
 (pl.col("b") * 10).alias("a"),
 (pl.col("b") * 100).alias("c"),
])

基于判定的列运算#

`Pandas`#

df.loc[df["c"] == 2, "a"] = df.loc[df["c"] == 2, "b"]

`Polars`#

df.with_column(
 pl.when(pl.col("c") == 2)
 .then(pl.col("b"))
 .otherwise(pl.col("a")).alias("a")
)

注意，Polars的方式更“干净”，因而原始DataFrame中的数据并没有被修改。并且，mask（掩膜）也不像在Pandas中那样被计算了两次。

当然，你可以在Pandas中防止原始DataFrame中的数据在这一步被修改，但这需要借助临时变量。

另外，Polars能并行计算每一个 if -> then -> otherwise的分支。当分支的计算复杂度提高时，就能体现并行计算的优势了。

筛选#

`Pandas`#

df.loc[(df['sqft_living'] > 2500) & (df['price'] < 300000)]

`Polars`#

df.filter(
 (pl.col("m2_living") > 2500) & (pl.col("price") < 300000)
)

PS: 这部分内容还在建设中，内容有缺少？欢迎提交PR!

没有索引列#

根本不需要索引列！没有索引列会让处理变得更简单。如果你不相信来说服我们吧!

Pandas重塑#

在Pandas文档中演示了一种聚合操作 transform（重塑）：

`Pandas`#

df = pd.DataFrame({
 "c": [1, 1, 1, 2, 2, 2, 2],
 "type": ["m", "n", "o", "m", "m", "n", "n"]
})

df["size"] = df.groupby("c")["type"].transform(len)

使用Pandas 要先聚合"c"列、截取出"type"列、计算组的长度，最后将结果拼接回原始DataFrame中。

其结果是:

 c type size
0 1 m 3
1 1 n 3
2 1 o 3
3 2 m 4
4 2 m 4
5 2 n 4
6 2 n 4

`Polars`#

在 Polars中可以用 窗口 函数来达到相同的目的。

第 5 章 Pandas 入门

Thu, 06 Mar 2025 22:20:29 +0800

第 5 章 Pandas 入门#

Pandas 是本书后续内容的首选库。它含有使数据清洗和分析工作变得更快更简单的数据结构和操作工具。pandas 经常和其它工具一同使用，如数值计算工具 NumPy 和 SciPy，分析库 statsmodels 和 scikit-learn，和数据可视化库 matplotlib。pandas 是基于 NumPy 数组构建的，特别是基于数组的函数和不使用for循环的数据处理。

虽然 pandas 采用了大量的 NumPy 编码风格，但二者最大的不同是 pandas 是专门为处理表格和混杂数据设计的。而 NumPy 更适合处理统一的数值数组数据。

自从 2010 年 pandas 开源以来，pandas 逐渐成长为一个非常大的库，应用于许多真实案例。开发者社区已经有了 800 个独立的贡献者，他们在解决日常数据问题的同时为这个项目提供贡献。

在本书后续部分中，我将使用下面这样的 pandas 引入约定：

In [1]: import pandas as pd

因此，只要你在代码中看到 pd.，就得想到这是 pandas。因为Series和DataFrame用的次数非常多，所以将其引入本地命名空间中会更方便：

In [2]: from pandas import Series, DataFrame

5.1 pandas 的数据结构介绍#

要使用 pandas，你首先就得熟悉它的两个主要数据结构：Series和DataFrame。虽然它们并不能解决所有问题，但它们为大多数应用提供了一种可靠的、易于使用的基础。

`Series`#

Series是一种类似于一维数组的对象，它由一组数据（各种 NumPy 数据类型）以及一组与之相关的数据标签（即索引）组成。仅由一组数据即可产生最简单的Series：

In [11]: obj = pd.Series([4, 7, -5, 3])

In [12]: obj
Out[12]: 
0 4
1 7
2 -5
3 3
dtype: int64

Series的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引，于是会自动创建一个 0 到N-1（N为数据的长度）的整数型索引。你可以通过Series的values和index属性获取其数组表示形式和索引对象：

连接

Fri, 21 Mar 2025 11:33:29 +0800

连接#

类似于其他数据框架库，Polars 支持一系列连接操作。

在单个或多个列上进行连接
左连接
内连接
外连接

数据集#

import polars as pl

df_a = pl.DataFrame({"a": [1, 2, 1, 1], "b": ["a", "b", "c", "c"], "c": [0, 1, 2, 3]})

df_b = pl.DataFrame({"foo": [1, 1, 1], "bar": ["a", "c", "c"], "ham": ["let", "var", "const"]})
print(df_a)

shape: (4, 3)
┌─────┬─────┬─────┐
│ a ┆ b ┆ c │
│ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 │
╞═════╪═════╪═════╡
│ 1 ┆ a ┆ 0 │
│ 2 ┆ b ┆ 1 │
│ 1 ┆ c ┆ 2 │
│ 1 ┆ c ┆ 3 │
└─────┴─────┴─────┘

print(df_b)

shape: (3, 3)
┌─────┬─────┬───────┐
│ foo ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ str │
╞═════╪═════╪═══════╡
│ 1 ┆ a ┆ let │
│ 1 ┆ c ┆ var │
│ 1 ┆ c ┆ const │
└─────┴─────┴───────┘

急性#


out = df_a.join(df_b, left_on=["a", "b"], right_on=["foo", "bar"], how="left")
print(out)

shape: (6, 4)
┌─────┬─────┬─────┬───────┐
│ a ┆ b ┆ c ┆ ham │
│ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ str │
╞═════╪═════╪═════╪═══════╡
│ 1 ┆ a ┆ 0 ┆ let │
│ 2 ┆ b ┆ 1 ┆ null │
│ 1 ┆ c ┆ 2 ┆ var │
│ 1 ┆ c ┆ 2 ┆ const │
│ 1 ┆ c ┆ 3 ┆ var │
│ 1 ┆ c ┆ 3 ┆ const │
└─────┴─────┴─────┴───────┘

惰性#


q = df_a.lazy().join(df_b.lazy(), left_on="a", right_on="foo", how="outer")
out = q.collect()
print(out)

shape: (10, 5)
┌─────┬─────┬─────┬──────┬───────┐
│ a ┆ b ┆ c ┆ bar ┆ ham │
│ --- ┆ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ i64 ┆ str ┆ str │
╞═════╪═════╪═════╪══════╪═══════╡
│ 1 ┆ a ┆ 0 ┆ a ┆ let │
│ 1 ┆ a ┆ 0 ┆ c ┆ var │
│ 1 ┆ a ┆ 0 ┆ c ┆ const │
│ 2 ┆ b ┆ 1 ┆ null ┆ null │
│ … ┆ … ┆ … ┆ … ┆ … │
│ 1 ┆ c ┆ 2 ┆ c ┆ const │
│ 1 ┆ c ┆ 3 ┆ a ┆ let │
│ 1 ┆ c ┆ 3 ┆ c ┆ var │
│ 1 ┆ c ┆ 3 ┆ c ┆ const │
└─────┴─────┴─────┴──────┴───────┘

Polars与AWS交互

Fri, 21 Mar 2025 10:25:29 +0800

Polars与AWS交互#

要读取或写入AWS存储桶，需要额外的依赖项：

$ pip install s3fs

在接下来的几个片段中，我们将演示如何与Parquet文件交互位于AWS桶上。

读入#

使用如下加载一个.parquet：

import polars as pl
import pyarrow.parquet as pq
import s3fs

fs = s3fs.S3FileSystem()
bucket = "<YOUR_BUCKET>"
path = "<YOUR_PATH>"

dataset = pq.ParquetDataset(f"s3://{bucket}/{path}", filesystem=fs)
df = pl.from_arrow(dataset.read())

Polars折叠

Fri, 21 Mar 2025 09:21:29 +0800

Polars折叠#

Polars 提供了横向表达式或者方法，比如sum, min, mean 等等，我们只需要设置 axis=1 即可实现横向聚合。但是，当我们需要复杂的聚合模式时，Polars 提供的基本函数可能不能胜任，这时候我们需要 fold 函数。

fold 函数在列方向的性能最佳，它很好的利用了数据的内存格局，通常还会伴随向量化操作。

让我们通过里一个例子看看如何受使用 fold 实现 sum 函数。

手工 `sum`#

 {
 "a": [1, 2, 3],
 "b": [10, 20, 30],
 }
)

out = df.select(
 pl.fold(acc=pl.lit(0), function=lambda acc, x: acc + x, exprs=pl.col("*")).alias("sum"),
)
print(out)

shape: (3, 1)
┌─────┐
│ sum │
│ --- │
│ i64 │
╞═════╡
│ 11 │
│ 22 │
│ 33 │
└─────┘

上面的例子中，函数 f(acc, x) -> acc 被反复调用并把结果累加到 acc 变量，最终把结果放入 x 列。这个函数按照列执行，并且充分利用了缓存和向量化操作。

来自ApacheSpark

Thu, 20 Mar 2025 13:22:29 +0800

来自ApacheSpark#

基于列的方法 vs. 基于行的方法#

Spark DataFrame 类似于一个行的集合，而 Polars DataFrame 更接近于一个列的集合。这意味着你可以在 Polars 中以 Spark 中不可能的方式组合列，因为 Spark 保留了每一行中的数据关系。

考虑下面这个样本数据集。

import polars as pl

df = pl.DataFrame({
 "foo": ["a", "b", "c", "d", "d"],
 "bar": [1, 2, 3, 4, 5],
})

dfs = spark.createDataFrame(
 [
 ("a", 1),
 ("b", 2),
 ("c", 3),
 ("d", 4),
 ("d", 5),
 ],
 schema=["foo", "bar"],
)

案例 1: 合并 `head` 与 `sum`#

在 Polars 中你可以写出下面的语句：

df.select([
 pl.col("foo").sort().head(2),
 pl.col("bar").filter(pl.col("foo") == "d").sum()
])

该代码段输出:

shape: (2, 2)
┌─────┬─────┐
│ foo ┆ bar │
│ --- ┆ --- │
│ str ┆ i64 │
╞═════╪═════╡
│ a ┆ 9 │
├╌╌╌╌╌┼╌╌╌╌╌┤
│ b ┆ 9 │
└─────┴─────┘

列 foo 和 bar 上的表达式是完全独立的。由于 bar 上的表达式返回一个单一的值，这个值在 foo 表达式输出的每个值中都会重复，但是 a 和 b 与产生 9 没有关系。

第 6 章数据加载、存储与文件格式

Thu, 06 Mar 2025 22:20:29 +0800

第 6 章数据加载、存储与文件格式#

访问数据是使用本书所介绍的这些工具的第一步。我会着重介绍 pandas 的数据输入与输出，虽然别的库中也有不少以此为目的的工具。

输入输出通常可以划分为几个大类：读取文本文件和其他更高效的磁盘存储格式，加载数据库中的数据，利用 Web API 操作网络资源。

6.1 读写文本格式的数据#

pandas 提供了一些用于将表格型数据读取为DataFrame对象的函数。表 6-1 对它们进行了总结，其中read_csv和read_table可能会是你今后用得最多的。

函数	说明
read_csv	从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为逗号
read_table	从文件、URL、文件型对象中加载带分隔符的数据。默认分隔符为制表符(’\t')
read_fwf	读取定宽列格式数据(也就是说没有分隔符)
read_clipboard	读取剪贴板中的数据，可以看做read table的剪贴板版。将网页转换为表格时很有用
read_excel	从 Excel XLS 或 XLSX读取表格数据
read_hdf	读取 pandas 写的 HDF5 文件
read_html	读取 HTMI 文档中的所有表格
read_json	读取 JSON (JavaScript Object Notation)字符串中的数据
read_msgpack	二进制格式编码的 pandas 数据
read_pickle	读取 Python pickle格式中存储的任意对象
read_sas	读取存储于 SAS 系统自定义存储格式的 SAS 数据集
read_sql	使用 SQLAlchemy读取 SQL查询结果为 pandas 的 DataFrame
read_stata	读取 Stata 文件格式的数据集
read_feather	读取 Feather 二进制文件格式

我将大致介绍一下这些函数在将文本数据转换为DataFrame时所用到的一些技术。这些函数的选项可以划分为以下几个大类：

重塑

Fri, 21 Mar 2025 11:35:29 +0800

重塑#

重塑操作将一个宽格式的 DataFrame 逆透视为长格式。

数据集#

import polars as pl

df = pl.DataFrame({"A": ["a", "b", "a"], "B": [1, 3, 5], "C": [10, 11, 12], "D": [2, 4, 6]})
print(df)

shape: (3, 4)
┌─────┬─────┬─────┬─────┐
│ A ┆ B ┆ C ┆ D │
│ --- ┆ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ i64 ┆ i64 │
╞═════╪═════╪═════╪═════╡
│ a ┆ 1 ┆ 10 ┆ 2 │
│ b ┆ 3 ┆ 11 ┆ 4 │
│ a ┆ 5 ┆ 12 ┆ 6 │
└─────┴─────┴─────┴─────┘

急性 + 惰性#

急性 与 惰性 操作的 API 相同。

Polars与Google BigQuery交互

Fri, 21 Mar 2025 11:16:29 +0800

Polars与Google BigQuery交互#

读写BigQuery数据库，需要额外依赖项：

$ pip install google-cloud-bigquery

读取#

从BigQuery查询并得到DataFrame，可以像这样：

import polars as pl
from google.cloud import bigquery

client = bigquery.Client()

# 执行查询
QUERY = (
 'SELECT name FROM `bigquery-public-data.usa_names.usa_1910_2013` '
 'WHERE state = "TX" '
 'LIMIT 100')
query_job = client.query(QUERY) # API 请求
rows = query_job.result() # 等待查询完成

df = pl.from_arrow(rows.to_arrow())

写入#

from google.cloud import bigquery

client = bigquery.Client()

with io.BytesIO() as stream:
 df.write_parquet(stream)
 stream.seek(0)
 job = client.load_table_from_file(
 stream,
 destination='tablename',
 project='projectname',
 job_config=bigquery.LoadJobConfig(
 source_format=bigquery.SourceFormat.PARQUET,
 ),
 )
job.result()

Polars自定义函数

Fri, 21 Mar 2025 09:21:39 +0800

Polars自定义函数#

现在你应该相信，polar表达式是如此的强大和灵活，以至于对自定义python函数的需求比你在其他库中可能需要的要少得多。

尽管如此，你仍然需要有能力将表达式传递给第三方库，或者将你的黑匣子函数应用于polar数据。

为此，我们提供了以下几种表达式：

map
apply

map#

在操作方式上和最终向用户传递的数据上，map和apply函数有重要的区别。

map函数将表达式所支持的Series数据原封不动的传递。

map函数在select和groupby中遵循相同的规则，这将意味着Series代表DataFrame中的一个列。注意，在groupby情况下，该列还没有被分组！

map函数的用法是将表达式中的Series传递给第三方库。下面我们展示了如何使用map将一个表达式列传递给神经网络模型。

df.with_column([
 pl.col("features").map(lambda s: MyNeuralNetwork.forward(s.to_numpy())).alias("activations")
])

在groupby中，map的使用情况很有限。它们只用于性能方面，但很容易导致不正确的结果。让我们来解释一下原因。

df = pl.DataFrame(
 {
 "keys": ["a", "a", "b"],
 "values": [10, 7, 1],
 }
)

out = df.groupby("keys", maintain_order=True).agg(
 [
 pl.col("values").map(lambda s: s.shift()).alias("shift_map"),
 pl.col("values").shift().alias("shift_expression"),
 ]
)
print(df)
shape: (3, 2)
┌──────┬────────┐
│ keys ┆ values │
│ --- ┆ --- │
│ str ┆ i64 │
╞══════╪════════╡
│ a ┆ 10 │
├╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ a ┆ 7 │
├╌╌╌╌╌╌┼╌╌╌╌╌╌╌╌┤
│ b ┆ 1 │
└──────┴────────┘

在上面的片段中，我们按"keys"列分组。这意味着我们有以下几个组。

"a" -> [10, 7]
"b" -> [1]

如果我们再向右应用一个shift操作，我们就会发现。

"a" -> [null, 10]
"b" -> [null]

现在，让我们打印一下得到的结果：

第 7 章数据清洗和准备

Thu, 06 Mar 2025 22:20:29 +0800

第 7 章数据清洗和准备#

在数据分析和建模的过程中，相当多的时间要用在数据准备上：加载、清理、转换以及重塑。这些工作会占到分析师时间的 80%或更多。有时，存储在文件和数据库中的数据的格式不适合某个特定的任务。许多研究者都选择使用通用编程语言（如 Python、Perl、R 或 Java）或 UNIX 文本处理工具（如sed或awk）对数据格式进行专门处理。幸运的是，pandas 和内置的 Python 标准库提供了一组高级的、灵活的、快速的工具，可以让你轻松地将数据规整为想要的格式。

如果你发现了一种本书或 pandas 库中没有的数据操作方式，请在邮件列表或 GitHub 网站上提出。实际上，pandas 的许多设计和实现都是由真实应用的需求所驱动的。

在本章中，我会讨论处理缺失数据、重复数据、字符串操作和其它分析数据转换的工具。下一章，我会关注于用多种方法合并、重塑数据集。

7.1 处理缺失数据#

在许多数据分析工作中，缺失数据是经常发生的。pandas 的目标之一就是尽量轻松地处理缺失数据。例如，pandas 对象的所有描述性统计默认都不包括缺失数据。

缺失数据在 pandas 中呈现的方式有些不完美，但对于大多数用户可以保证功能正常。对于数值数据，pandas 使用浮点值NaN（Not a Number）表示缺失数据。我们称其为哨兵值，可以方便的检测出来：

In [10]: string_data = pd.Series(['aardvark', 'artichoke', np.nan, 'avocado'])

In [11]: string_data
Out[11]:
0 aardvark
1 artichoke
2 NaN
3 avocado
dtype: object

In [12]: string_data.isnull()
Out[12]: 
0 False
1 False
2 True
3 False
dtype: bool

在 pandas 中，我们采用了 R 语言中的惯用法，即将缺失值表示为 NA，它表示不可用（not available）。在统计应用中，NA 数据可能是不存在的数据或者虽然存在，但是没有观察到（例如，数据采集中发生了问题）。当进行数据清洗以进行分析时，最好直接对缺失数据进行分析，以判断数据采集的问题或缺失数据可能导致的偏差。

Python 内置的None值在对象数组中也可以作为 NA：

条件应用

Fri, 21 Mar 2025 11:42:29 +0800

条件应用#

要修改一个 Series 或 DataFrame 中的一列，需要以下两步。

基于一些谓词创建一个 boolean 掩码
替换掉掩码评估为 True 的值
（仅当惰性操作时）定义掩码评估为 False 的值

数据集#

import numpy as np
import polars as pl

# 构造数据帧
df = pl.DataFrame({"range": np.arange(10), "left": ["foo"] * 10, "right": ["bar"] * 10})
df.head()

shape: (5, 3)
┌───────┬──────┬───────┐
│ range ┆ left ┆ right │
│ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ str │
╞═══════╪══════╪═══════╡
│ 0 ┆ foo ┆ bar │
│ 1 ┆ foo ┆ bar │
│ 2 ┆ foo ┆ bar │
│ 3 ┆ foo ┆ bar │
│ 4 ┆ foo ┆ bar │
└───────┴──────┴───────┘

我们可以使用 .when()/.then()/.otherwise() 表达式。

Polars实例

Fri, 21 Mar 2025 09:25:39 +0800

Polars实例#

第 10 章数据聚合与分组运算

Thu, 06 Mar 2025 22:20:29 +0800

第 10 章数据聚合与分组运算#

对数据集进行分组并对各组应用一个函数（无论是聚合还是转换），通常是数据分析工作中的重要环节。在将数据集加载、融合、准备好之后，通常就是计算分组统计或生成透视表。pandas 提供了一个灵活高效的gruopby功能，它使你能以一种自然的方式对数据集进行切片、切块、摘要等操作。

关系型数据库和 SQL（Structured Query Language，结构化查询语言）能够如此流行的原因之一就是其能够方便地对数据进行连接、过滤、转换和聚合。但是，像 SQL 这样的查询语言所能执行的分组运算的种类很有限。在本章中你将会看到，由于 Python 和 pandas 强大的表达能力，我们可以执行复杂得多的分组运算（利用任何可以接受 pandas 对象或 NumPy 数组的函数）。在本章中，你将会学到：

使用一个或多个键（形式可以是函数、数组或DataFrame列名）分割 pandas 对象。
计算分组的概述统计，比如数量、平均值或标准差，或是用户定义的函数。
应用组内转换或其他运算，如规格化、线性回归、排名或选取子集等。
计算透视表或交叉表。
执行分位数分析以及其它统计分组分析。

笔记：对时间序列数据的聚合（groupby的特殊用法之一）也称作重采样（resampling），本书将在第 11 章中单独对其进行讲解。

10.1 `GroupBy`机制#

Hadley Wickham（许多热门 R 语言包的作者）创造了一个用于表示分组运算的术语拆分－应用－合并（split-apply-combine）。第一个阶段，pandas 对象（无论是Series、DataFrame还是其他的）中的数据会根据你所提供的一个或多个键被拆分（split）为多组。拆分操作是在对象的特定轴上执行的。例如，DataFrame可以在其行（axis=0）或列（axis=1）上进行分组。然后，将一个函数应用（apply）到各个分组并产生一个新值。最后，所有这些函数的执行结果会被合并（combine）到最终的结果对象中。结果对象的形式一般取决于数据上所执行的操作。图 10-1 大致说明了一个简单的分组聚合过程。

分组键可以有多种形式，且类型不必相同：

列表或数组，其长度与待分组的轴一样。
表示DataFrame某个列名的值。
字典或Series，给出待分组轴上的值与分组名之间的对应关系。
函数，用于处理轴索引或索引中的各个标签。

注意，后三种都只是快捷方式而已，其最终目的仍然是产生一组用于拆分对象的值。如果觉得这些东西看起来很抽象，不用担心，我将在本章中给出大量有关于此的示例。首先来看看下面这个非常简单的表格型数据集（以DataFrame的形式）：

In [10]: df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'],
 ....: 'key2' : ['one', 'two', 'one', 'two', 'one'],
 ....: 'data1' : np.random.randn(5),
 ....: 'data2' : np.random.randn(5)})

In [11]: df
Out[11]: 
 data1 data2 key1 key2
0 -0.204708 1.393406 a one
1 0.478943 0.092908 a two
2 -0.519439 0.281746 b one
3 -0.555730 0.769023 b two
4 1.965781 1.246435 a one

假设你想要按key1进行分组，并计算data1列的平均值。实现该功能的方式有很多，而我们这里要用的是：访问data1，并根据key1调用groupby：

Polars表达式方法

Fri, 21 Mar 2025 09:27:39 +0800

Polars表达式方法#

可以在Expr上找到可能的表达式的完整列表，参考指南中的定义。

第 11 章时间序列

Thu, 06 Mar 2025 22:20:29 +0800

第 11 章时间序列#

时间序列（time series）数据是一种重要的结构化数据形式，应用于多个领域，包括金融学、经济学、生态学、神经科学、物理学等。在多个时间点观察或测量到的任何事物都可以形成一段时间序列。很多时间序列是固定频率的，也就是说，数据点是根据某种规律定期出现的（比如每 15 秒、每 5 分钟、每月出现一次）。时间序列也可以是不定期的，没有固定的时间单位或单位之间的偏移量。时间序列数据的意义取决于具体的应用场景，主要有以下几种：

时间戳（timestamp），特定的时刻。
固定时期（period），如 2007 年 1 月或 2010 年全年。
时间间隔（interval），由起始和结束时间戳表示。时期（period）可以被看做间隔（interval）的特例。
实验或过程时间，每个时间点都是相对于特定起始时间的一个度量。例如，从放入烤箱时起，每秒钟饼干的直径。

本章主要讲解前 3 种时间序列。许多技术都可用于处理实验型时间序列，其索引可能是一个整数或浮点数（表示从实验开始算起已经过去的时间）。最简单也最常见的时间序列都是用时间戳进行索引的。

提示：pandas 也支持基于timedeltas的指数，它可以有效代表实验或经过的时间。这本书不涉及timedelta指数，但你可以学习 pandas 的文档。

pandas 提供了许多内置的时间序列处理工具和数据算法。因此，你可以高效处理非常大的时间序列，轻松地进行切片/切块、聚合、对定期/不定期的时间序列进行重采样等。有些工具特别适合金融和经济应用，你当然也可以用它们来分析服务器日志数据。

11.1 日期和时间数据类型及工具#

Python 标准库包含用于日期（date）和时间（time）数据的数据类型，而且还有日历方面的功能。我们主要会用到datetime、time以及calendar模块。datetime.datetime（也可以简写为datetime）是用得最多的数据类型：

In [10]: from datetime import datetime

In [11]: now = datetime.now()

In [12]: now
Out[12]: datetime.datetime(2017, 9, 25, 14, 5, 52, 72973)

In [13]: now.year, now.month, now.day
Out[13]: (2017, 9, 25)

datetime以毫秒形式存储日期和时间。timedelta表示两个datetime对象之间的时间差：

In [14]: delta = datetime(2011, 1, 7) - datetime(2008, 6, 24, 8, 15)

In [15]: delta
Out[15]: datetime.timedelta(926, 56700)

In [16]: delta.days
Out[16]: 926

In [17]: delta.seconds
Out[17]: 56700

可以给datetime对象加上（或减去）一个或多个timedelta，这样会产生一个新对象：

Polars视频介绍

Fri, 21 Mar 2025 09:27:39 +0800

Polars视频介绍#

你不喜欢阅读文档吗？看看这段关于Polars及其表达的介绍视频。

Polars参考指南

Thu, 20 Mar 2025 13:22:29 +0800

Polars参考指南#

需要查看Polars的所有可用方法/功能吗？我们有Rust和Python的参考向导：

第 12 章 pandas 高级应用

Thu, 06 Mar 2025 22:20:29 +0800

第 12 章 pandas 高级应用#

前面的章节关注于不同类型的数据规整流程和 NumPy、pandas 与其它库的特点。随着时间的发展，pandas 发展出了更多适合高级用户的功能。本章就要深入学习 pandas 的高级功能。

12.1 分类数据#

这一节介绍的是 pandas 的分类类型。我会向你展示通过使用它，提高性能和内存的使用率。我还会介绍一些在统计和机器学习中使用分类数据的工具。

背景和目的#

表中的一列通常会有重复的包含不同值的小集合的情况。我们已经学过了unique和value_counts，它们可以从数组提取出不同的值，并分别计算频率：

In [10]: import numpy as np; import pandas as pd

In [11]: values = pd.Series(['apple', 'orange', 'apple',
 ....: 'apple'] * 2)

In [12]: values
Out[12]: 
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
dtype: object

In [13]: pd.unique(values)
Out[13]: array(['apple', 'orange'], dtype=object)

In [14]: pd.value_counts(values)
Out[14]: 
apple 6
orange 2
dtype: int64

许多数据系统（数据仓库、统计计算或其它应用）都发展出了特定的表征重复值的方法，以进行高效的存储和计算。在数据仓库中，最好的方法是使用所谓的包含不同值的维表（Dimension Table），将主要的参数存储为引用维表整数键：

In [15]: values = pd.Series([0, 1, 0, 0] * 2)

In [16]: dim = pd.Series(['apple', 'orange'])

In [17]: values
Out[17]: 
0 0
1 1
2 0
3 0
4 0
5 1
6 0
7 0
dtype: int64

In [18]: dim
Out[18]: 
0 apple
1 orange
dtype: object

可以使用take方法存储原始的字符串Series：

第 13 章 Python 建模库介绍

Thu, 06 Mar 2025 22:20:29 +0800

第 13 章 Python 建模库介绍#

本书中，我已经介绍了 Python 数据分析的编程基础。因为数据分析师和科学家总是在数据规整和准备上花费大量时间，这本书的重点在于掌握这些功能。

开发模型选用什么库取决于应用本身。许多统计问题可以用简单方法解决，比如普通的最小二乘回归，其它问题可能需要复杂的机器学习方法。幸运的是，Python 已经成为了运用这些分析方法的语言之一，因此读完此书，你可以探索许多工具。

本章中，我会回顾一些 pandas 的特点，在你胶着于 pandas 数据规整和模型拟合和评分时，它们可能派上用场。然后我会简短介绍两个流行的建模工具，statsmodels 和 scikit-learn。这二者每个都值得再写一本书，我就不做全面的介绍，而是建议你学习两个项目的线上文档和其它基于 Python 的数据科学、统计和机器学习的书籍。

13.1 pandas 与模型代码的接口#

模型开发的通常工作流是使用 pandas 进行数据加载和清洗，然后切换到建模库进行建模。开发模型的重要一环是机器学习中的“特征工程”。它可以描述从原始数据集中提取信息的任何数据转换或分析，这些数据集可能在建模中有用。本书中学习的数据聚合和GroupBy工具常用于特征工程中。

优秀的特征工程超出了本书的范围，我会尽量直白地介绍一些用于数据操作和建模切换的方法。

pandas 与其它分析库通常是靠 NumPy 的数组联系起来的。将DataFrame转换为 NumPy 数组，可以使用.values属性：

In [10]: import pandas as pd

In [11]: import numpy as np

In [12]: data = pd.DataFrame({
 ....: 'x0': [1, 2, 3, 4, 5],
 ....: 'x1': [0.01, -0.01, 0.25, -4.1, 0.],
 ....: 'y': [-1.5, 0., 3.6, 1.3, -2.]})

In [13]: data
Out[13]: 
 x0 x1 y
0 1 0.01 -1.5
1 2 -0.01 0.0
2 3 0.25 3.6
3 4 -4.10 1.3
4 5 0.00 -2.0

In [14]: data.columns
Out[14]: Index(['x0', 'x1', 'y'], dtype='object')

In [15]: data.values
Out[15]: 
array([[ 1. , 0.01, -1.5 ],
 [ 2. , -0.01, 0. ],
 [ 3. , 0.25, 3.6 ],
 [ 4. , -4.1 , 1.3 ],
 [ 5. , 0. , -2. ]])

要转换回DataFrame，可以传递一个二维ndarray，可带有列名：

第 14 章数据分析案例

Thu, 06 Mar 2025 22:20:29 +0800

第 14 章数据分析案例#

本书正文的最后一章，我们来看一些真实世界的数据集。对于每个数据集，我们会用之前介绍的方法，从原始数据中提取有意义的内容。展示的方法适用于其它数据集，也包括你的。本章包含了一些各种各样的案例数据集，可以用来练习。

案例数据集可以在 Github 仓库找到，见第一章。

14.1 来自 Bitly 的 USA.gov 数据#

2011 年，URL 缩短服务 Bitly 跟美国政府网站 USA.gov 合作，提供了一份从生成.gov或.mil短链接的用户那里收集来的匿名数据。在 2011 年，除实时数据之外，还可以下载文本文件形式的每小时快照。写作此书时（2017 年），这项服务已经关闭，但我们保存一份数据用于本书的案例。

以每小时快照为例，文件中各行的格式为 JSON（即 JavaScript Object Notation，这是一种常用的 Web 数据格式）。例如，如果我们只读取某个文件中的第一行，那么所看到的结果应该是下面这样：

In [5]: path = 'datasets/bitly_usagov/example.txt'

In [6]: open(path).readline()
Out[6]: '{ "a": "Mozilla\\/5.0 (Windows NT 6.1; WOW64) AppleWebKit\\/535.11
(KHTML, like Gecko) Chrome\\/17.0.963.78 Safari\\/535.11", "c": "US", "nk": 1,
"tz": "America\\/New_York", "gr": "MA", "g": "A6qOVH", "h": "wfLQtf", "l":
"orofrog", "al": "en-US,en;q=0.8", "hh": "1.usa.gov", "r":
"http:\\/\\/www.facebook.com\\/l\\/7AQEFzjSi\\/1.usa.gov\\/wfLQtf", "u":
"http:\\/\\/www.ncbi.nlm.nih.gov\\/pubmed\\/22415991", "t": 1331923247, "hc":
1331822918, "cy": "Danvers", "ll": [ 42.576698, -70.954903 ] }\n'

Python 有内置或第三方模块可以将 JSON 字符串转换成 Python 字典对象。这里，我将使用json模块及其loads函数逐行加载已经下载好的数据文件：

import json
path = 'datasets/bitly_usagov/example.txt'
records = [json.loads(line) for line in open(path)]

现在，records对象就成为一组 Python 字典了：

附录 A NumPy 高级应用

Thu, 06 Mar 2025 22:20:29 +0800

附录 A NumPy 高级应用#

在这篇附录中，我会深入 NumPy 库的数组计算。这会包括ndarray更内部的细节，和更高级的数组操作和算法。

本章包括了一些杂乱的章节，不需要仔细研究。

A.1 `ndarray`对象的内部机理#

NumPy 的ndarray提供了一种将同质数据块（可以是连续或跨越）解释为多维数组对象的方式。正如你之前所看到的那样，数据类型（dtype）决定了数据的解释方式，比如浮点数、整数、布尔值等。

ndarray如此强大的部分原因是所有数组对象都是数据块的一个跨度视图（strided view）。你可能想知道数组视图arr[::2,::-1]不复制任何数据的原因是什么。简单地说，ndarray不只是一块内存和一个dtype，它还有跨度信息，这使得数组能以各种步幅（step size）在内存中移动。更准确地讲，ndarray内部由以下内容组成：

一个指向数据（内存或内存映射文件中的一块数据）的指针。
数据类型或dtype，描述在数组中的固定大小值的格子。
一个表示数组形状（shape）的元组。
一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要“跨过”的字节数。

图 A-1 简单地说明了ndarray 的内部结构。

例如，一个10×5的数组，其形状为(10,5)：

In [10]: np.ones((10, 5)).shape
Out[10]: (10, 5)

一个典型的（C 顺序，稍后将详细讲解）3×4×5的float64（8 个字节）数组，其跨度为(160,40,8) —— 知道跨度是非常有用的，通常，跨度在一个轴上越大，沿这个轴进行计算的开销就越大：

In [11]: np.ones((3, 4, 5), dtype=np.float64).strides
Out[11]: (160, 40, 8)

虽然 NumPy 用户很少会对数组的跨度信息感兴趣，但它们却是构建非复制式数组视图的重要因素。跨度甚至可以是负数，这样会使数组在内存中后向移动，比如在切片obj[::-1]或obj[:,::-1]中就是这样的。

NumPy 数据类型体系#

你可能偶尔需要检查数组中所包含的是否是整数、浮点数、字符串或 Python 对象。因为浮点数的种类很多（从float16到float128），判断dtype是否属于某个大类的工作非常繁琐。幸运的是，dtype都有一个超类（比如np.integer和np.floating），它们可以跟np.issubdtype函数结合使用：

In [12]: ints = np.ones(10, dtype=np.uint16)

In [13]: floats = np.ones(10, dtype=np.float32)

In [14]: np.issubdtype(ints.dtype, np.integer)
Out[14]: True

In [15]: np.issubdtype(floats.dtype, np.floating)
Out[15]: True

调用dtype的mro方法即可查看其所有的父类：

附录 B 更多关于 IPython 的内容

Thu, 06 Mar 2025 22:20:29 +0800

附录 B 更多关于 IPython 的内容#

第 2 章中，我们学习了 IPython shell 和 Jupyter 笔记本的基础。本章中，我们会探索 IPython 更深层次的功能，可以从控制台或在 jupyter 使用。

B.1 使用命令历史#

Ipython 维护了一个位于磁盘的小型数据库，用于保存执行的每条指令。它的用途有：

只用最少的输入，就能搜索、补全和执行先前运行过的指令；
在不同会话间保存命令历史；
将日志输入/输出历史到一个文件

这些功能在 shell 中，要比笔记本更为有用，因为笔记本从设计上是将输入和输出的代码放到每个代码格子中。

搜索和重复使用命令历史#

Ipython 可以让你搜索和执行之前的代码或其他命令。这个功能非常有用，因为你可能需要重复执行同样的命令，例如%run命令，或其它代码。假设你必须要执行：

In[7]: %run first/second/third/data_script.py

运行成功，然后检查结果，发现计算有错。解决完问题，然后修改了data_script.py，你就可以输入一些%run命令，然后按Ctrl+P或上箭头。这样就可以搜索历史命令，匹配输入字符的命令。多次按Ctrl+P或上箭头，会继续搜索命令。如果你要执行你想要执行的命令，不要害怕。你可以按下Ctrl-N或下箭头，向前移动历史命令。这样做了几次后，你可以不假思索地按下这些键！

Ctrl-R可以带来如同 Unix 风格 shell（比如 bash shell）的readline的部分增量搜索功能。在 Windows 上，readline功能是被 IPython 模仿的。要使用这个功能，先按Ctrl-R，然后输入一些包含于输入行的想要搜索的字符：

In [1]: a_command = foo(x, y, z)

(reverse-i-search)`com': a_command = foo(x, y, z)

Ctrl-R会循环历史，找到匹配字符的每一行。

输入和输出变量#

忘记将函数调用的结果分配给变量是非常烦人的。IPython 的一个会话会在一个特殊变量，存储输入和输出 Python 对象的引用。前面两个输出会分别存储在_（一个下划线）和__（两个下划线）变量：

In [24]: 2 ** 27
Out[24]: 134217728

In [25]: _
Out[25]: 134217728

输入变量是存储在名字类似_iX的变量中，X是输入行的编号。对于每个输入变量，都有一个对应的输出变量_X。因此在输入第 27 行之后，会有两个新变量_27（输出）和_i27（输入）:

Polars与pandas差异对比

Tue, 15 Apr 2025 12:20:29 +0800

如果您有关注过去一年中 Python DataFrame 的进展，那么您一定听说过 Polars，专为处理大型数据集而设计的强大 DataFrame 库。

与 Spark、Dask 和 Ray 等处理大型数据集的其他库有所不同，Polars 在单台机器上使用，也因此引起许多与 pandas 的比较。事实上，Polars 在许多重要方面都与 pandas 存在差异，包括数据处理方式以及最佳应用。下文将探讨这两种 DataFrame 库的技术细节区别，并分析其各自优点和局限。

如果您想听 Polars 的缔造者 Ritchie Vink 亲口讲述，您可以在此处找到我们对他的采访！

为什么使用 Polars 而不是 pandas？#

两个字：性能。 Polars 从一开始就速度极快，执行常见运算的速度是 pandas 的 5 到 10 倍。另外，Polars 运算的内存需求明显小于 pandas：pandas 需要数据集大小的 5 到 10 倍左右的 RAM 来执行运算，而 Polars 需要 2 到 4 倍。

您可以在这里了解 Polars 与其他 DataFrame 库的性能对比。对于常见运算，Polars 的速度是 pandas 的 10 到 100 倍，也是最快的 DataFrame 库之一。此外，在内存不足错误之前，它可以处理比 pandas 更大的数据集。

排序

Fri, 21 Mar 2025 11:39:29 +0800

排序#

Polars 支持与其他数据框架库类似的排序行为，即按一个或多个列以及多个（不同的）顺序进行排序。

数据集#

import numpy as np
import polars as pl

df = pl.DataFrame({"a": np.arange(1, 4), "b": ["a", "a", "b"]}) # np.arange(1, 4): 生成[1, 4)的数组
print(df)

shape: (3, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪═════╡
│ 1 ┆ a │
│ 2 ┆ a │
│ 3 ┆ b │
└─────┴─────┘

急性#

out = df.sort(["b", "a"], descending=[True, False]) # 分别对两列"b", "a"进行排序，"b"逆序，"a"顺序
print(out)

shape: (3, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪═════╡
│ 1 ┆ a │
│ 2 ┆ a │
│ 3 ┆ b │
└─────┴─────┘

惰性#

import polars as pl

q = df.lazy().sort(pl.col("a"), descending=True) # 惰性排序，对"a"列
df = q.collect()
print(out)

shape: (3, 2)
┌─────┬─────┐
│ a ┆ b │
│ --- ┆ --- │
│ i64 ┆ str │
╞═════╪═════╡
│ 3 ┆ b │
│ 2 ┆ a │
│ 1 ┆ a │
└─────┴─────┘

透视

Fri, 21 Mar 2025 11:37:29 +0800

透视#

在 DataFrame 中透视一列，并执行下列其中一种聚合。

first：第一项
sum：求和
min：最小值
max：最大值
mean：平均值
median：中位数

透视操作包括一个或多个列的分组（它们将成为新的 y 轴），将被透视的列（它们将成为新的 x 轴）以及一个聚合。

数据集#

import polars as pl

# 构造DataFrame（数据帧）
df = pl.DataFrame(
 {
 "foo": ["A", "A", "B", "B", "C"],
 "N": [1, 2, 2, 4, 2],
 "bar": ["k", "l", "m", "n", "o"],
 }
)
print(df)

shape: (5, 3)
┌─────┬─────┬─────┐
│ foo ┆ N ┆ bar │
│ --- ┆ --- ┆ --- │
│ str ┆ i64 ┆ str │
╞═════╪═════╪═════╡
│ A ┆ 1 ┆ k │
│ A ┆ 2 ┆ l │
│ B ┆ 2 ┆ m │
│ B ┆ 4 ┆ n │
│ C ┆ 2 ┆ o │
└─────┴─────┴─────┘

急性#


out = df.pivot(
 index="foo",
 columns="bar",
 values="N",
)

惰性#

惰性操作的 API 中并不包含转置操作，因此想要惰性地使用转置，我们可以使用 map 来在惰性计算节点中执行一个急性的自定义函数。

Polars与Postgres交互

Fri, 21 Mar 2025 11:17:29 +0800

Polars与Postgres交互#

读取#

从postgres数据库中读取数据，需要额外依赖项:

$ pip install connectorx>=0.2.0a3

import polars as pl

conn = "postgresql://username:password@server:port/database"
query = "SELECT * FROM foo"

pl.read_sql(query, conn)

写入#

写入postgres数据库，需要额外依赖项:

$ pip install psycopg2-binary

用psycopg2写入postgres数据库，我们会用批处理的方法，限制与服务器的往返行程以提高写入性能。

我们首先要保证所有的数据类型可以被psycopg2所识别，再使用DataFrame.rows轻松将每列数据转置成数据库驱动程序可以处理的行。

from psycopg2 import sql
import psycopg2.extras
import polars as pl

# 不仿假设有一个DataFrame，其列分别为：浮点，整数，字符串，日期（date64）类型的数据
df = pl.read_parquet("somefile.parquet")

# 首先将 polars 的 date64 数据类型转换成 python 的 datetime 对象
for col in df:
 # 只转换date64类型数据
 if col.dtype == pl.Date64:
 df = df.with_column(col.dt.to_python_datetime())

# 为字段名创建 sql 标识符
# 这一步是为了在sql语句中安全插入数据
columns = sql.SQL(",").join(sql.Identifier(name) for name in df.columns)

# 为值创建占位符，之后再被值填充
values = sql.SQL(",").join([sql.Placeholder() for _ in df.columns])

table_id = "mytable"

# 准备insert语句
insert_stmt = sql.SQL("INSERT INTO ({}) VALUES({});").format(
 sql.Identifier(table_id), columns, values
)

# 创建与数据库的连接
conn = psycopg2.connect()
cur = conn.cursort()

# 执行insert语句
psycopg2.extras.execute_batch(cur, insert_stmt, df.rows())
conn.commit()

Polars与Numpy交互

Fri, 21 Mar 2025 09:23:39 +0800

Polars与Numpy交互#

Polars 表达式支持NumPy ufuncs。这里查看所有受支持的numpy函数的列表。

这意味着，如果一个函数不是由Polars提供的，我们可以使用NumPy，我们仍然可以通过NumPyAPI进行快速的列操作。

实例#

import polars as pl
import numpy as np

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

out = df.select(
 [
 np.log(pl.all()).suffix("_log"), # 对df所有列求对数
 ]
)
print(out)

shape: (3, 2)
┌──────────┬──────────┐
│ a_log ┆ b_log │
│ --- ┆ --- │
│ f64 ┆ f64 │
╞══════════╪══════════╡
│ 0.0 ┆ 1.386294 │
│ 0.693147 ┆ 1.609438 │
│ 1.098612 ┆ 1.791759 │
└──────────┴──────────┘

Gotcha’s#

阅读更多关于 gotcha’s 这里.

Polars窗口函数

Fri, 21 Mar 2025 09:22:39 +0800

Polars窗口函数#

窗口函数是一种强大的表达式。它可以让用户在 select 上下文中分组进行类聚。让我们通过例子看看这是什么意思。首先，我们创建一个数据结构，这个数据包含如下列，分别代表口袋妖怪的一些信息：

['#', 'Name', 'Type 1', 'Type 2', 'Total', 'HP', 'Attack', 'Defense', 'Sp. Atk', 'Sp. Def', 'Speed', 'Generation', 'Legendary']

import polars as pl

# 然后，让我们加载一些包pokemon信息的csv数据
df = pl.read_csv(
 "https://gist.githubusercontent.com/ritchie46/cac6b337ea52281aa23c049250a4ff03/raw/89a957ff3919d90e6ef2d34235e6bf22304f3366/pokemon.csv"
)

shape: (163, 13)
┌─────┬───────────────────────┬─────────┬────────┬───┬─────────┬───────┬────────────┬───────────┐
│ # ┆ Name ┆ Type 1 ┆ Type 2 ┆ … ┆ Sp. Def ┆ Speed ┆ Generation ┆ Legendary │
│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ --- ┆ --- ┆ --- │
│ i64 ┆ str ┆ str ┆ str ┆ ┆ i64 ┆ i64 ┆ i64 ┆ bool │
╞═════╪═══════════════════════╪═════════╪════════╪═══╪═════════╪═══════╪════════════╪═══════════╡
│ 1 ┆ Bulbasaur ┆ Grass ┆ Poison ┆ … ┆ 65 ┆ 45 ┆ 1 ┆ false │
│ 2 ┆ Ivysaur ┆ Grass ┆ Poison ┆ … ┆ 80 ┆ 60 ┆ 1 ┆ false │
│ 3 ┆ Venusaur ┆ Grass ┆ Poison ┆ … ┆ 100 ┆ 80 ┆ 1 ┆ false │
│ 3 ┆ VenusaurMega Venusaur ┆ Grass ┆ Poison ┆ … ┆ 120 ┆ 80 ┆ 1 ┆ false │
│ … ┆ … ┆ … ┆ … ┆ … ┆ … ┆ … ┆ … ┆ … │
│ 147 ┆ Dratini ┆ Dragon ┆ null ┆ … ┆ 50 ┆ 50 ┆ 1 ┆ false │
│ 148 ┆ Dragonair ┆ Dragon ┆ null ┆ … ┆ 70 ┆ 70 ┆ 1 ┆ false │
│ 149 ┆ Dragonite ┆ Dragon ┆ Flying ┆ … ┆ 100 ┆ 80 ┆ 1 ┆ false │
│ 150 ┆ Mewtwo ┆ Psychic ┆ null ┆ … ┆ 90 ┆ 130 ┆ 1 ┆ true │
└─────┴───────────────────────┴─────────┴────────┴───┴─────────┴───────┴────────────┴───────────┘

Groupby 类聚#

下面我们看看如何用窗口函数对不同的列分组并且类聚。这样我们可以在一次查询中并行的运行多个分组操作。类聚的结果会投射会原有的行。因此，窗口函数永远返回一个跟原有 DataFrame 一样规格的 DataFrame。

Polars时间序列实例

Thu, 20 Mar 2025 13:22:29 +0800

Polars时间序列实例#

import polars as pl
from datetime import datetime
# 创建一个数据帧实例
df = pl.DataFrame(
 {
 "time": pl.date_range(
 low=datetime(2021, 12, 16),
 high=datetime(2021, 12, 16, 3),
 interval="30m",
 ),
 "n": range(7),
 }
)
df

shape: (7, 2)
┌─────────────────────┬─────┐
│ time ┆ n │
│ --- ┆ --- │
│ datetime ┆ i64 │
╞═════════════════════╪═════╡
│ 2021-12-16 00:00:00 ┆ 0 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2021-12-16 00:30:00 ┆ 1 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2021-12-16 01:00:00 ┆ 2 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2021-12-16 01:30:00 ┆ 3 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2021-12-16 02:00:00 ┆ 4 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2021-12-16 02:30:00 ┆ 5 │
├╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
│ 2021-12-16 03:00:00 ┆ 6 │
└─────────────────────┴─────┘

从2021-12-16 00:00:00开始，按1小时的窗口分组。

第 8 章数据规整：聚合、合并和重塑

Thu, 06 Mar 2025 22:20:29 +0800

第 8 章数据规整：聚合、合并和重塑#

在许多应用中，数据可能分散在许多文件或数据库中，存储的形式也不利于分析。本章关注可以聚合、合并、重塑数据的方法。

首先，我会介绍 pandas 的层次化索引，它广泛用于以上操作。然后，我深入介绍了一些特殊的数据操作。在第 14 章，你可以看到这些工具的多种应用。

8.1 层次化索引#

层次化索引（hierarchical indexing）是 pandas 的一项重要功能，它使你能在一个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理高维度数据。我们先来看一个简单的例子：创建一个Series，并用一个由列表或数组组成的列表作为索引：

In [9]: data = pd.Series(np.random.randn(9),
 ...: index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],
 ...: [1, 2, 3, 1, 3, 1, 2, 2, 3]])

In [10]: data
Out[10]: 
a 1 -0.204708
 2 0.478943
 3 -0.519439
b 1 -0.555730
 3 1.965781
c 1 1.393406
 2 0.092908
d 2 0.281746
 3 0.769023
dtype: float64

看到的结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使用上面的标签”：

In [11]: data.index
Out[11]: 
MultiIndex(levels=[['a', 'b', 'c', 'd'], [1, 2, 3]],
 labels=[[0, 0, 0, 1, 1, 2, 2, 3, 3], [0, 1, 2, 0, 2, 0, 1, 1, 2]])

对于一个层次化索引的对象，可以使用所谓的部分索引，使用它选取数据子集的操作更简单：

In [12]: data['b']
Out[12]: 
1 -0.555730
3 1.965781
dtype: float64

In [13]: data['b':'c']
Out[13]: 
b 1 -0.555730
 3 1.965781
c 1 1.393406
 2 0.092908
dtype: float64

In [14]: data.loc[['b', 'd']]
Out[14]: 
b 1 -0.555730
 3 1.965781
d 2 0.281746
 3 0.769023
dtype: float64

有时甚至还可以在“内层”中进行选取：

第 9 章绘图和可视化

Thu, 06 Mar 2025 22:20:29 +0800

第 9 章绘图和可视化#

信息可视化（也叫绘图）是数据分析中最重要的工作之一。它可能是探索过程的一部分，例如，帮助我们找出异常值、必要的数据转换、得出有关模型的想法等。另外，做一个可交互的数据可视化也许是工作的最终目标。Python 有许多库进行静态或动态的数据可视化，但我这里重要关注于 matplotlib 和基于它的库。

matplotlib 是一个用于创建出版质量图表的桌面绘图包（主要是 2D 方面）。该项目是由 John Hunter 于 2002 年启动的，其目的是为 Python 构建一个 MATLAB 式的绘图接口。matplotlib 和 IPython 社区进行合作，简化了从 IPython shell（包括现在的 Jupyter 笔记本）进行交互式绘图。matplotlib 支持各种操作系统上许多不同的 GUI 后端，而且还能将图片导出为各种常见的向量（vector）和光栅（raster）图：PDF、SVG、JPG、PNG、BMP、GIF 等。除了几张，本书中的大部分图都是用它生成的。

随着时间的发展，matplotlib 衍生出了多个数据可视化的工具集，它们使用 matplotlib 作为底层。其中之一是 seaborn，本章后面会学习它。

学习本章代码案例的最简单方法是在 Jupyter 笔记本进行交互式绘图。在 Jupyter 笔记本中执行下面的语句：

%matplotlib notebook

9.1 matplotlib API 入门#

matplotlib 的通常引入约定是：

In [11]: import matplotlib.pyplot as plt

在 Jupyter 笔记本中运行%matplotlib（或在 IPython 中运行%matplotlib），就可以创建一个简单的图形。如果一切设置正确，会看到图 9-1：

In [12]: import numpy as np

In [13]: data = np.arange(10)

In [14]: data
Out[14]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [15]: plt.plot(data)

使用Python批量检测URL状态码

Fri, 10 Nov 2023 12:20:29 +0800

想要找到3位长度的github ID，可以对用户页URL进行探测，找到所有不可用的就有可能没有注册。

使用python很简单能实现以上需求。

首先安装pip requests

import requests
for x1 in range(97,123): 
 for x2 in range(97,123):
 for x3 in range(97,123):
 url='https://github.com/'+chr(x1)+chr(x2)+chr(x3)
 r=requests.get(url)
 print(url,r.status_code)

其中range(97,123)就是遍历a-z

运行结果如下：

root@bwg:~# python3 ./gid.py
https://github.com/aaa status 200
https://github.com/aab status 200
https://github.com/aac status 200
https://github.com/aad status 200
https://github.com/aae status 200
https://github.com/aaf status 200
https://github.com/aag status 200
https://github.com/aah status 200
... ...

Mon, 01 Jan 0001 00:00:00 +0000

Reference guide#

The API reference contains detailed descriptions of all public functions and objects. It’s the best place to look if you need information on a specific function.

Python#

The Python API reference is built using Sphinx. It’s available in our docs.

Rust#

The Rust API reference is built using Cargo. It’s available on docs.rs.

Mon, 01 Jan 0001 00:00:00 +0000

Streaming#

One additional benefit of the lazy API is that it allows queries to be executed in a streaming manner. Instead of processing all the data at once, Polars can execute the query in batches allowing you to process datasets that do not fit in memory.

To tell Polars we want to execute a query in streaming mode we pass the streaming=True argument to collect

Mon, 01 Jan 0001 00:00:00 +0000

Overview#

Thanks for taking the time to contribute! We appreciate all contributions, from reporting bugs to implementing new features. If you’re unclear on how to proceed after reading this guide, please contact us on Discord.

Reporting bugs#

We use GitHub issues to track bugs and suggested enhancements. You can report a bug by opening a new issue. Use the appropriate issue type for the language you are using (Rust / Python).

Before creating a bug report, please check that your bug has not already been reported, and that your bug exists on the latest version of Polars. If you find a closed issue that seems to report the same bug you’re experiencing, open a new issue and include a link to the original issue in your issue description.

Mon, 01 Jan 0001 00:00:00 +0000

Versioning#

Version changes#

Polars adheres to the semantic versioning specification:

Breaking changes lead to a major version increase (1.0.0, 2.0.0, …)
New features and performance improvements lead to a minor version increase (1.1.0, 1.2.0, …)
Other changes lead to a patch version increase (1.0.1, 1.0.2, …)

Policy for breaking changes#

Polars takes backwards compatibility seriously, but we are not afraid to change things if it leads to a better product.

Philosophy#

We don’t always get it right on the first try. We learn as we go along and get feedback from our users. Sometimes, we’re a little too eager to get out a new feature and didn’t ponder all the possible implications.

Mon, 01 Jan 0001 00:00:00 +0000

Aggregation#

The Polars context group_by lets you apply expressions on subsets of columns, as defined by the unique values of the column over which the data is grouped. This is a very powerful capability that we explore in this section of the user guide.

We start by reading in a US congress dataset:

{{code_block(‘user-guide/expressions/aggregation’,‘dataframe’,[‘DataFrame’,‘Categorical’])}}

--8<-- "python/user-guide/expressions/aggregation.py:dataframe"

Basic aggregations#

You can easily apply multiple expressions to your aggregated values. Simply list all of the expressions you want inside the function agg. There is no upper bound on the number of aggregations you can do and you can make any combination you want. In the snippet below we will group the data based on the column “first_name” and then we will apply the following aggregations:

Mon, 01 Jan 0001 00:00:00 +0000

Casting#

Casting converts the underlying data type of a column to a new one. Casting is available through the function cast.

The function cast includes a parameter strict that determines how Polars behaves when it encounters a value that cannot be converted from the source data type to the target data type. The default behaviour is strict=True, which means that Polars will thrown an error to notify the user of the failed conversion while also providing details on the values that couldn’t be cast. On the other hand, if strict=False, any values that cannot be converted to the target data type will be quietly converted to null.

Mon, 01 Jan 0001 00:00:00 +0000

Categorical data and enums#

A column that holds string values that can only take on one of a limited number of possible values is a column that holds categorical data. Usually, the number of possible values is much smaller than the length of the column. Some typical examples include your nationality, the operating system of your computer, or the license that your favorite open source project uses.

When working with categorical data you can use Polars’ dedicated types, Categorical and Enum, to make your queries more performant. Now, we will see what are the differences between the two data types Categorical and Enum and when you should use one data type or the other. We also include some notes on why the data types Categorical and Enum are more efficient than using the plain string values in the end of this user guide section.

Mon, 01 Jan 0001 00:00:00 +0000

Expression expansion#

As you’ve seen in the section about expressions and contexts, expression expansion is a feature that enables you to write a single expression that can expand to multiple different expressions, possibly depending on the schema of the context in which the expression is used.

This feature isn’t just decorative or syntactic sugar. It allows for a very powerful application of DRY principles in your code: a single expression that specifies multiple columns expands into a list of expressions, which means you can write one single expression and reuse the computation that it represents.

Mon, 01 Jan 0001 00:00:00 +0000

Folds#

Polars provides many expressions to perform computations across columns, like sum_horizontal, mean_horizontal, and min_horizontal. However, these are just special cases of a general algorithm called a fold, and Polars provides a general mechanism for you to compute custom folds for when the specialised versions of Polars are not enough.

Folds computed with the function fold operate on the full columns for maximum speed. They utilize the data layout very efficiently and often have vectorized execution.

Mon, 01 Jan 0001 00:00:00 +0000

Lists and arrays#

Polars has first-class support for two homogeneous container data types: List and Array. Polars supports many operations with the two data types and their APIs overlap, so this section of the user guide has the objective of clarifying when one data type should be chosen in favour of the other.

Lists vs arrays#

The data type `List`#

The data type list is suitable for columns whose values are homogeneous 1D containers of varying lengths.

Mon, 01 Jan 0001 00:00:00 +0000

Missing data#

This section of the user guide teaches how to work with missing data in Polars.

`null` and `NaN` values#

In Polars, missing data is represented by the value null. This missing value null is used for all data types, including numerical types.

Polars also supports the value NaN (“Not a Number”) for columns with floating point numbers. The value NaN is considered to be a valid floating point value, which is different from missing data. We discuss the value NaN separately below.

Mon, 01 Jan 0001 00:00:00 +0000

Numpy functions#

Polars expressions support NumPy ufuncs. See the NumPy documentation for a list of all supported NumPy functions.

This means that if a function is not provided by Polars, we can use NumPy and we still have fast columnar operations through the NumPy API.

Example#

{{code_block(‘user-guide/expressions/numpy-example’,api_functions=[‘DataFrame’,’np.log’])}}

--8<-- "python/user-guide/expressions/numpy-example.py"

Interoperability#

Polars’ series have support for NumPy universal functions (ufuncs) and generalized ufuncs. Element-wise functions such as np.exp, np.cos, np.div, etc, all work with almost zero overhead.

Mon, 01 Jan 0001 00:00:00 +0000

Strings#

The following section discusses operations performed on string data, which is a frequently used data type when working with dataframes. String processing functions are available in the namespace str.

Working with strings in other dataframe libraries can be highly inefficient due to the fact that strings have unpredictable lengths. Polars mitigates these inefficiencies by following the Arrow Columnar Format specification, so you can write performant data queries on string data too.

Mon, 01 Jan 0001 00:00:00 +0000

Structs#

The data type Struct is a composite data type that can store multiple fields in a single column.

!!! tip “Python analogy”

For Python users, the data type `Struct` is kind of like a Python
dictionary. Even better, if you are familiar with Python typing, you can think of the data type
`Struct` as `typing.TypedDict`.

In this page of the user guide we will see situations in which the data type Struct arises, we will understand why it does arise, and we will see how to work with Struct values.

Mon, 01 Jan 0001 00:00:00 +0000

User-defined Python functions#

Polars expressions are quite powerful and flexible, so there is much less need for custom Python functions compared to other libraries. Still, you may need to pass an expression’s state to a third party library or apply your black box function to data in Polars.

In this part of the documentation we’ll be using two APIs that allows you to do this:

Mon, 01 Jan 0001 00:00:00 +0000

Window functions#

Window functions are expressions with superpowers. They allow you to perform aggregations on groups within the context select. Let’s get a feel for what that means.

First, we load a Pokémon dataset:

{{code_block(‘user-guide/expressions/window’,‘pokemon’,[‘read_csv’])}}

--8<-- "python/user-guide/expressions/window.py:pokemon"

Operations per group#

Window functions are ideal when we want to perform an operation within a group. For instance, suppose we want to rank our Pokémon by the column “Speed”. However, instead of a global ranking, we want to rank the speed within each group defined by the column “Type 1”. We write the expression to rank the data by the column “Speed” and then we add the function over to specify that this should happen over the unique values of the column “Type 1”:

Mon, 01 Jan 0001 00:00:00 +0000

Introducing Polars Cloud#

!!! tip “Polars Cloud is in alpha stage” Polars Cloud is currently available to a select group of individuals and companies for early-stage testing. You can learn more about Polars Cloud and its goals in our recent announcement post.

DataFrame implementations always differed from SQL and databases. SQL could run anywhere from embedded databases to massive data warehouses. Yet, DataFrame users have been forced to choose between a solution for local work or solutions geared towards distributed computing, each with their own APIs and limitations.

Mon, 01 Jan 0001 00:00:00 +0000

Ecosystem#

Introduction#

On this page you can find a non-exhaustive list of libraries and tools that support Polars. As the data ecosystem is evolving fast, more libraries will likely support Polars in the future. One of the main drivers is that Polars makes adheres its memory layout to the Apache Arrow spec.

Apache Arrow#

Apache Arrow enables zero-copy reads of data within the same process, meaning that data can be directly accessed in its in-memory format without the need for copying or serialisation. This enhances performance when integrating with different tools using Apache Arrow. Polars is compatible with a wide range of libraries that also make use of Apache Arrow, like Pandas and DuckDB.

Mon, 01 Jan 0001 00:00:00 +0000

GPU Support [Open Beta]#

Polars provides an in-memory, GPU-accelerated execution engine for Python users of the Lazy API on NVIDIA GPUs using RAPIDS cuDF. This functionality is available in Open Beta and is undergoing rapid development.

System Requirements#

NVIDIA Volta™ or higher GPU with compute capability 7.0+
CUDA 11 or CUDA 12
Linux or Windows Subsystem for Linux 2 (WSL2)

See the RAPIDS installation guide for full details.

Installation#

You can install the GPU backend for Polars with a feature flag as part of a normal installation.

Mon, 01 Jan 0001 00:00:00 +0000

IO#

Reading and writing your data is crucial for a DataFrame library. In this chapter you will learn more on how to read and write to different file formats that are supported by Polars.

Mon, 01 Jan 0001 00:00:00 +0000

Lazy#

The Lazy chapter is a guide for working with LazyFrames. It covers the functionalities like how to use it and how to optimise it. You can also find more information about the query plan or gain more insight in the streaming capabilities.

Mon, 01 Jan 0001 00:00:00 +0000

Coming from Pandas#

Here we set out the key points that anyone who has experience with pandas and wants to try Polars should know. We include both differences in the concepts the libraries are built on and differences in how you should write Polars code compared to pandas code.

Differences in concepts between Polars and pandas#

Polars does not have a multi-index/index#

pandas gives a label to each row with an index. Polars does not use an index and each row is indexed by its integer position in the table.

Mon, 01 Jan 0001 00:00:00 +0000

Coming from Apache Spark#

Column-based API vs. Row-based API#

Whereas the Spark DataFrame is analogous to a collection of rows, a Polars DataFrame is closer to a collection of columns. This means that you can combine columns in Polars in ways that are not possible in Spark, because Spark preserves the relationship of the data in each row.

Consider this sample dataset:

import polars as pl

df = pl.DataFrame({
 "foo": ["a", "b", "c", "d", "d"],
 "bar": [1, 2, 3, 4, 5],
})

dfs = spark.createDataFrame(
 [
 ("a", 1),
 ("b", 2),
 ("c", 3),
 ("d", 4),
 ("d", 5),
 ],
 schema=["foo", "bar"],
)

Example 1: Combining `head` and `sum`#

In Polars you can write something like this:

Mon, 01 Jan 0001 00:00:00 +0000

Arrow producer/consumer#

Using pyarrow#

Polars can move data in and out of arrow zero copy. This can be done either via pyarrow or natively. Let’s first start by showing the pyarrow solution:

pyarrow.Table
foo: int64
bar: large_string
----
foo: [[1,2,3]]
bar: [["ham","spam","jam"]]

Or if you want to ensure the output is zero-copy:

pyarrow.Table
foo: int64
bar: string_view
----
foo: [[1,2,3]]
bar: [["ham","spam","jam"]]

Importing from pyarrow can be achieved with pl.from_arrow.

Using the Arrow PyCapsule Interface#

As of Polars v1.3 and higher, Polars implements the Arrow PyCapsule Interface, a protocol for sharing Arrow data across Python libraries.

Mon, 01 Jan 0001 00:00:00 +0000

Comparison with other tools#

These are several libraries and tools that share similar functionalities with Polars. This often leads to questions from data experts about what the differences are. Below is a short comparison between some of the more popular data processing tools and Polars, to help data experts make a deliberate decision on which tool to use.

You can find performance benchmarks (h2oai benchmark) of these tools here: Polars blog post or a more recent benchmark done by DuckDB

Mon, 01 Jan 0001 00:00:00 +0000

Multiprocessing#

TLDR: if you find that using Python’s built-in multiprocessing module together with Polars results in a Polars error about multiprocessing methods, you should make sure you are using spawn, not fork, as the starting method:

{{code_block(‘user-guide/misc/multiprocess’,‘recommendation’,[])}}

When not to use multiprocessing#

Before we dive into the details, it is important to emphasize that Polars has been built from the start to use all your CPU cores. It does this by executing computations which can be done in parallel in separate threads. For example, requesting two expressions in a select statement can be done in parallel, with the results only being combined at the end. Another example is aggregating a value within groups using group_by().agg(<expr>), each group can be evaluated separately. It is very unlikely that the multiprocessing module can improve your code performance in these cases. If you’re using the GPU Engine with Polars you should also avoid manual multiprocessing. When used simultaneously, they can compete for system memory and processing power, leading to reduced performance.

Mon, 01 Jan 0001 00:00:00 +0000

Generating Polars code with LLMs#

Large Language Models (LLMs) can sometimes return Pandas code or invalid Polars code in their output. This guide presents approaches that help LLMs generate valid Polars code more consistently.

These approaches have been developed by the Polars community through testing model responses to various inputs. If you find additional effective approaches for generating Polars code from LLMs, please raise a pull request.

System prompt#

Many LLMs allow you to provide a system prompt that is included with every individual prompt you send to the model. In the system prompt, you can specify your preferred defaults, such as “Use Polars as the default dataframe library”. Including such a system prompt typically leads to models consistently generating Polars code rather than Pandas code.

Mon, 01 Jan 0001 00:00:00 +0000

Styling#

Data in a Polars DataFrame can be styled for presentation use the DataFrame.style property. This returns a GT object from Great Tables, which enables structuring, formatting, and styling for table display.

--8<-- "python/user-guide/misc/styling.py:dataframe"

Structure: add header title#

--8<-- "python/user-guide/misc/styling.py:structure-header-out"

Structure: add row stub#

--8<-- "python/user-guide/misc/styling.py:structure-stub-out"

Structure: add column spanner#

--8<-- "python/user-guide/misc/styling.py:structure-spanner-out"

Format: limit decimal places#

--8<-- "python/user-guide/misc/styling.py:format-number-out"

Style: highlight max row#

--8<-- "python/user-guide/misc/styling.py:style-simple-out"

Style: bold species column#

--8<-- "python/user-guide/misc/styling.py:style-bold-column-out"

Full example#

--8<-- "python/user-guide/misc/styling.py:full-example-out"

Mon, 01 Jan 0001 00:00:00 +0000

Visualization#

Data in a Polars DataFrame can be visualized using common visualization libraries.

We illustrate plotting capabilities using the Iris dataset. We read a CSV and then plot one column against another, colored by a yet another column.

--8<-- "python/user-guide/misc/visualization.py:dataframe"

Built-in plotting with Altair#

Polars has a plot method to create plots using Altair:

{{code_block(‘user-guide/misc/visualization’,‘altair_show_plot’,[])}}

--8<-- "python/user-guide/misc/visualization.py:altair_make_plot"

This is shorthand for:

import altair as alt

(
 alt.Chart(df).mark_point(tooltip=True).encode(
 x="sepal_length",
 y="sepal_width",
 color="species",
 )
 .properties(width=500)
 .configure_scale(zero=False)
)

and is only provided for convenience, and to signal that Altair is known to work well with Polars.

Mon, 01 Jan 0001 00:00:00 +0000

Plugins#

Polars allows you to extend its functionality with either Expression plugins or IO plugins.

Community plugins#

Here is a curated (non-exhaustive) list of community-implemented plugins.

Various#

polars-xdt Polars plugin with extra datetime-related functionality which isn’t quite in-scope for the main library
polars-hash Stable non-cryptographic and cryptographic hashing functions for Polars

Data science#

polars-distance Polars plugin for pairwise distance functions
polars-ds Polars extension aiming to simplify common numerical/string data analysis procedures

Geo#

polars-st Polars ST provides spatial operations on Polars DataFrames, Series and Expressions. Just like Shapely and Geopandas.
polars-reverse-geocode Offline reverse geocoder for finding the closest city to a given (latitude, longitude) pair.
polars-h3 This is a Polars extension that adds support for the H3 discrete global grid system, so you can index points and geometries to hexagons directly in Polars.

Other material#

Ritchie Vink - Keynote on Polars Plugins
Polars plugins tutorial Learn how to write a plugin by going through some very simple and minimal examples
cookiecutter-polars-plugin Project template for Polars Plugins

Mon, 01 Jan 0001 00:00:00 +0000

CREATE#

In Polars, the SQLContext provides a way to execute SQL statements against LazyFrames and DataFrames using SQL syntax. One of the SQL statements that can be executed using SQLContext is the CREATE TABLE statement, which is used to create a new table.

The syntax for the CREATE TABLE statement in Polars is as follows:

CREATE TABLE table_name
AS
SELECT ...

In this syntax, table_name is the name of the new table that will be created, and SELECT ... is a SELECT statement that defines the data that will be inserted into the table.

Mon, 01 Jan 0001 00:00:00 +0000

Common Table Expressions#

Common Table Expressions (CTEs) are a feature of SQL that allow you to define a temporary named result set that can be referenced within a SQL statement. CTEs provide a way to break down complex SQL queries into smaller, more manageable pieces, making them easier to read, write, and maintain.

A CTE is defined using the WITH keyword followed by a comma-separated list of subqueries, each of which defines a named result set that can be used in subsequent queries. The syntax for a CTE is as follows:

Mon, 01 Jan 0001 00:00:00 +0000

Introduction#

While Polars supports interaction with SQL, it’s recommended that users familiarize themselves with the expression syntax to produce more readable and expressive code. As the DataFrame interface is primary, new features are typically added to the expression API first. However, if you already have an existing SQL codebase or prefer the use of SQL, Polars does offers support for this.

!!! note Execution

There is no separate SQL engine because Polars translates SQL queries into [expressions](../concepts/expressions-and-contexts.md#expressions), which are then executed using its own engine. This approach ensures that Polars maintains its performance and scalability advantages as a native DataFrame library, while still providing users with the ability to work with SQL.

Context#

Polars uses the SQLContext object to manage SQL queries. The context contains a mapping of DataFrame and LazyFrame identifier names to their corresponding datasets¹. The example below starts a SQLContext:

Mon, 01 Jan 0001 00:00:00 +0000

SELECT#

In Polars SQL, the SELECT statement is used to retrieve data from a table into a DataFrame. The basic syntax of a SELECT statement in Polars SQL is as follows:

SELECT column1, column2, ...
FROM table_name;

Here, column1, column2, etc. are the columns that you want to select from the table. You can also use the wildcard * to select all columns. table_name is the name of the table or that you want to retrieve data from. In the sections below we will cover some of the more common SELECT variants

Mon, 01 Jan 0001 00:00:00 +0000

SHOW TABLES#

In Polars, the SHOW TABLES statement is used to list all the tables that have been registered in the current SQLContext. When you register a DataFrame with the SQLContext, you give it a name that can be used to refer to the DataFrame in subsequent SQL statements. The SHOW TABLES statement allows you to see a list of all the registered tables, along with their names.

The syntax for the SHOW TABLES statement in Polars is as follows:

Mon, 01 Jan 0001 00:00:00 +0000

Transformations#

The focus of this section is to describe different types of data transformations and provide some examples on how to use them.

首页 on Python数据分析

Polars快速入门

Polars快速入门#

安装#

实例#

Polars基本操作

Polars基本操作#

基本算术运算#

Polars数据类型和结构

Polars数据类型和结构#

Polars数据类型#

序列(Series)#

数据框(Dataframe)#

检查数据框dataframe#

第 1 章 准备工作

第 1 章 准备工作#

1.1 本书的内容#

什么样的数据？#

1.2 为什么要使用 Python 进行数据分析#

Python 作为胶水语言#

Polars入门

Polars入门#

安装Polars#

读取 & 写入#

谓词下推

谓词下推#

字符串

字符串#

范畴型#

在分类数据上加入多个数据帧#

惰性连接分类数据上的多个数据帧#

Polars自定义函数

Polars自定义函数#

使用map或者apply?#

选中行或列

选中行或列#

选中列#

选中行#

字符串

字符串#

Arrow

Arrow#

Polars操作CSV文件

Polars操作CSV文件#

读与写#

扫描#

Polars表达式和上下文

Polars表达式和上下文#

Polars表达式#

Polars上下文#

select#

第 2 章 Python 语法基础

第 2 章 Python 语法基础#

2.1 Python 解释器#

安装Polars

安装Polars#

大索引#

旧款CPU#

导入polars#

特性标志#

Python#

All#

GPU#

投影下推

投影下推#

更近一步#

Polars窗口函数

Polars窗口函数#

常用操作

常用操作#

添加列#

类型转换#

时间戳

时间戳#

Numpy

Numpy#

Polars操作Parquet文件

Parquet文件#

读&写#

扫描#

第 1 章准备工作

第 1 章准备工作#

`select`#

读入单个`DataFrame`#

`select` 上下文#

`Pandas`#

`Polars`#

`Pandas`#

`Polars`#

`Pandas`#

`Polars`#

`Pandas`#

`Polars`#

`Series`#