当前位置：首页 > 文章列表 > 文章 > python教程 > Python高效读写Parquet，pyarrow使用教程

Python高效读写Parquet，pyarrow使用教程

2025-08-07 14:53:59 0浏览收藏

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习文章相关编程知识。下面本篇文章就来带大家聊聊《Python高效读写Parquet，pyarrow操作指南》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

处理Parquet文件的核心工具是pyarrow库，它提供高效的数据读写能力，尤其适合大规模数据集。1. 写入Parquet文件需先将Pandas DataFrame转换为PyArrow Table，再使用pq.write_table()写入，可设置压缩方式如snappy、gzip等；2. 读取Parquet文件使用pq.read_table()加载为Arrow Table，再通过to_pandas()转回DataFrame；3. Parquet相比CSV的优势在于列式存储，支持列投影、高效压缩、复杂数据类型和谓词下推，显著提升I/O效率和查询性能；4. 处理大规模数据时的关键优化包括：使用列投影减少内存占用、利用谓词下推过滤数据、采用分区存储结构、启用内存映射减少加载开销；5. pyarrow与Pandas无缝集成，支持零拷贝转换，并作为Pandas读写Parquet的后端引擎；6. 在PySpark中，pyarrow加速toPandas()操作和Pandas UDF的执行，大幅提升JVM与Python间的数据交换效率。因此，pyarrow不仅是Parquet操作的首选工具，更是连接Python数据生态各组件的高性能数据总线，完整支撑现代数据处理流程。

Python如何操作Apache Parquet？pyarrow高效读写

Python操作Apache Parquet文件，核心工具是pyarrow库。它提供了高效的数据读写能力，特别是在处理大规模数据集时，能充分利用Parquet的列式存储优势，实现快速的数据加载和存储。

解决方案

说实话，处理Parquet文件，pyarrow几乎是首选。它不仅仅是一个库，更像是Apache Arrow项目在Python端的官方实现，这意味着它能很好地与底层数据格式进行交互，效率自然不在话下。

写入Parquet文件： 通常，我们手里会有一些数据，比如一个Pandas DataFrame。要把这些数据存成Parquet，流程其实挺直接的。

数据准备： 假设我们有一个DataFrame。

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
import numpy as np

# 模拟一些数据
data = {
    'id': range(10000),
    'name': [f'User_{i}' for i in range(10000)],
    'value': np.random.rand(10000),
    'category': np.random.choice(['A', 'B', 'C'], 10000)
}
df = pd.DataFrame(data)
print("原始DataFrame：")
print(df.head())

Pandas DataFrame转为Arrow Table： 这是关键一步，pyarrow处理的是Table对象。

# 将Pandas DataFrame转换为PyArrow Table
table = pa.Table.from_pandas(df)
print("\nPyArrow Table Schema：")
print(table.schema)

写入Parquet文件： 使用pyarrow.parquet.write_table函数。这里可以设置压缩方式、Parquet版本等。
```
# 写入Parquet文件
output_path = 'my_data.parquet'
pq.write_table(table, output_path, compression='snappy', version='2.0')
print(f"\n数据已成功写入到 {output_path}")
```
snappy是一个不错的默认压缩算法，兼顾了压缩比和解压速度。如果你对压缩比有更高要求，可以试试gzip或brotli，但读写速度可能会慢一些。

读取Parquet文件： 读取就更简单了，基本上就是指定文件路径。

读取Parquet文件到Arrow Table：

# 从Parquet文件读取数据
read_table = pq.read_table(output_path)
print(f"\n从 {output_path} 读取的PyArrow Table：")
print(read_table.to_pandas().head())

Arrow Table转回Pandas DataFrame（如果需要）：

# 转换回Pandas DataFrame
read_df = read_table.to_pandas()
print("\n转换回Pandas DataFrame：")
print(read_df.head())
print(f"读取的数据行数：{len(read_df)}")

这就是一个基本的读写流程。你会发现，整个过程非常直观，而且在后台，pyarrow做了很多优化，比如内存管理和数据类型映射，让这些操作变得高效。

Parquet文件格式相比CSV有哪些显著优势？

这个问题问得好，很多人一开始都会纠结用什么格式存储数据。说实话，Parquet相比CSV，那简直是质的飞跃，尤其是在大数据场景下。

最核心的区别在于：Parquet是列式存储，而CSV是行式存储。 这听起来有点抽象，但实际影响巨大。

想象一下，CSV文件就是一行一行地记录数据，每行是一个完整的记录。这种方式对人类阅读很友好，但对计算机处理大规模数据就没那么高效了。如果你只想读取某个特定列的数据，CSV文件也得把整行都读进来，然后从中提取出你想要的列，这无疑是浪费IO和内存。

Parquet则不然，它把每一列的数据单独存储。这意味着什么？

高效的列选择（Column Projection）： 如果你只需要数据集中的几列数据，pyarrow在读取Parquet文件时，可以只加载这些列的数据，而完全跳过其他不相关的列。这能显著减少磁盘I/O和内存占用，尤其是在处理百亿级别数据时，效果立竿见影。
卓越的压缩性能： 因为同一列的数据类型通常是一致的，而且数据分布可能也有规律（比如很多重复值），列式存储更容易实现高效的压缩算法。Parquet支持多种压缩方式，比如Snappy、Gzip、LZO、Brotli等，能大幅减小文件大小，进一步降低存储成本和传输时间。我个人偏爱Snappy，因为它在压缩率和解压速度之间取得了很好的平衡。
支持复杂数据类型和Schema： Parquet能够很好地处理嵌套数据结构（如列表、字典），并且自带Schema信息。这意味着你不需要额外维护数据结构定义，读取时就能自动识别数据类型，避免了CSV文件常见的类型推断错误。这让数据管理变得更健壮。
谓词下推（Predicate Pushdown）： 这是一个高级优化。如果你在查询时添加了过滤条件（比如WHERE category = 'A'），pyarrow在读取Parquet文件时，可以在数据被完全加载到内存之前，就根据文件元数据和列统计信息，跳过不符合条件的数据块。这大大加快了查询速度，减少了不必要的数据传输和处理。

所以，如果你只是处理几百行的小数据，CSV可能还行。但一旦数据量上去，或者你需要频繁地对特定列进行分析，Parquet的优势就会变得非常明显。它更适合数据分析、机器学习等场景，是现代数据湖和数据仓库的基石之一。

pyarrow在处理大规模Parquet数据时有哪些关键优化技巧？

处理大规模Parquet数据时，光知道读写是不够的，你还得知道怎么读写得更“聪明”。pyarrow提供了不少优化手段，能让你在面对TB级别的数据时，依然能保持不错的性能。

列投影（Column Projection）： 这可能是最简单也最有效的优化。正如我前面提到的，Parquet是列式存储。如果你只需要数据集中的几列，那么在读取时就明确告诉pyarrow只加载这些列。
```
# 只读取 'id' 和 'value' 两列
selected_columns_table = pq.read_table(output_path, columns=['id', 'value'])
print("\n只读取指定列：")
print(selected_columns_table.to_pandas().head())
print(f"读取的列：{selected_columns_table.column_names}")
```
这能显著减少内存占用和I/O开销，尤其当你的Parquet文件有上百列，但你只关心其中几列时，效果非常显著。
谓词下推（Predicate Pushdown）/ 行过滤（Row Filtering）： 如果你在读取数据时有过滤条件，把这些条件传递给pyarrow，它就能在文件级别甚至数据块级别进行过滤，避免加载不需要的数据。这比先把所有数据读到内存再用Pandas过滤要高效得多。
```
# 假设我们只想读取 category 为 'A' 的数据
# 过滤条件以 (column, operator, value) 的元组列表形式表示
filtered_table = pq.read_table(output_path, filters=[('category', '=', 'A')])
print("\n应用过滤条件后：")
print(filtered_table.to_pandas().head())
print(f"过滤后数据行数：{len(filtered_table.to_pandas())}")
```
pyarrow会利用Parquet文件中的统计信息（如最小值、最大值）来判断哪些数据块可能包含符合条件的数据，从而跳过不相关的块。这在数据量巨大时，能节省大量的时间和计算资源。
使用分区（Partitioning）： 在实际的大数据场景中，Parquet文件常常是按某个或多个列进行分区的。比如，按日期分区：data/year=2023/month=01/day=01/part-0.parquet。pyarrow可以非常高效地处理这种分区数据集。
```
# 模拟分区写入
# df['year'] = 2023
# pq.write_to_dataset(table, root_path='my_partitioned_data', partition_cols=['category'])
# print("\n数据已按 'category' 分区写入。")

# 从分区数据集读取
# read_partitioned_table = pq.read_table('my_partitioned_data', filters=[('category', '=', 'B')])
# print("\n从分区读取并过滤：")
# print(read_partitioned_table.to_pandas().head())
```
当你读取分区数据时，如果你在filters中包含了分区列的条件，pyarrow会直接跳过那些不包含目标数据的分区目录，只读取相关的Parquet文件。这是一种非常强大的优化，特别适合时间序列数据或按业务维度划分的数据。
内存映射（Memory Mapping）： 在某些情况下，特别是文件很大但你想快速访问时，可以使用内存映射。这可以让操作系统直接将文件内容映射到进程的虚拟地址空间，而不是先完全读入内存。
```
# read_table(output_path, memory_map=True)
# 这种方式对于只读操作，且文件大小超过物理内存时，可以避免一次性加载所有数据，
# 操作系统会按需加载文件页面。
```
这通常在数据处理流程中，你需要快速访问文件中的一部分，而不是全部加载时比较有用。

这些技巧结合起来，能让pyarrow在处理大规模Parquet数据时发挥出最大的效能。很多时候，性能瓶颈不在于CPU计算，而在于不必要的I/O和内存加载，而这些优化恰好能解决这些问题。

pyarrow如何与Pandas、Spark等Python数据生态系统协同工作？

pyarrow的设计理念之一就是作为数据交换的桥梁，它不仅仅是一个独立的库，更是Python数据生态系统中的一个关键组件，尤其是在Pandas和PySpark之间。

与Pandas的无缝集成： 这是最常见也是最直接的协同方式。pyarrow提供了from_pandas()和to_pandas()方法，实现了Pandas DataFrame和Arrow Table之间的高效转换。
```
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

# Pandas DataFrame -> PyArrow Table
df_example = pd.DataFrame({'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']})
arrow_table = pa.Table.from_pandas(df_example)
print("Pandas DataFrame 转 PyArrow Table:\n", arrow_table)

# PyArrow Table -> Pandas DataFrame
df_from_arrow = arrow_table.to_pandas()
print("\nPyArrow Table 转 Pandas DataFrame:\n", df_from_arrow)
```
这种转换非常高效，因为pyarrow和Pandas在底层共享了一些内存布局的概念。当Pandas DataFrame转换为Arrow Table时，如果数据类型兼容，很多时候是零拷贝操作，意味着数据本身不需要复制，只是改变了访问数据的“视图”。这对于大数据集来说，能节省大量的内存和时间。
在读写Parquet文件时，你甚至可以直接用Pandas的read_parquet和to_parquet方法，它们在内部通常会调用pyarrow作为后端引擎（如果已安装）。
```
# Pandas直接读写Parquet，内部使用pyarrow
df_example.to_parquet('pandas_pyarrow.parquet', engine='pyarrow', compression='snappy')
read_df_pandas = pd.read_parquet('pandas_pyarrow.parquet', engine='pyarrow')
print("\nPandas通过pyarrow读写Parquet：")
print(read_df_pandas.head())
```
这种紧密的集成，让数据科学家和分析师可以继续使用他们熟悉的Pandas API，同时享受到pyarrow带来的高性能I/O。
与Apache Spark (PySpark) 的深度融合：pyarrow在PySpark中扮演了至关重要的角色，它极大地提升了Python和JVM之间的数据交换效率。在Spark 2.3及更高版本中，pyarrow被用于优化PySpark的toPandas()操作以及基于Pandas UDFs（用户定义函数）的数据转换。
- toPandas()优化： 当你将一个大型Spark DataFrame转换为Pandas DataFrame时，如果没有pyarrow，数据需要在JVM和Python进程之间进行序列化和反序列化，这个过程非常慢。有了pyarrow，数据可以直接以Arrow格式在JVM和Python之间传输，避免了昂贵的序列化成本，速度可以提升数倍甚至数十倍。
```
# 伪代码，Spark环境下的操作
# from pyspark.sql import SparkSession
# spark = SparkSession.builder.appName("PyArrowSpark").getOrCreate()
# spark.conf.set("spark.sql.execution.arrow.pyspark.enabled", "true") # 启用Arrow优化

# spark_df = spark.createDataFrame(df) # 从Pandas DataFrame创建Spark DataFrame
# pandas_df_from_spark = spark_df.toPandas() # 此时会利用Arrow进行优化
# spark.stop()
```
- Pandas UDFs： 在PySpark中，Pandas UDFs允许你编写Python函数，这些函数以Pandas Series或DataFrame作为输入和输出，并在Spark集群上以矢量化的方式执行。pyarrow是实现这种矢量化执行的关键技术，它确保了数据在Python工作进程中以高效的Arrow格式进行处理。
```
# 伪代码，Pandas UDF示例
# from pyspark.sql.functions import pandas_udf, PandasUDFType
# from pyspark.sql.types import LongType
#
# @pandas_udf("long", PandasUDFType.SCALAR)
# def multiply_by_two(series: pd.Series) -> pd.Series:
#     return series * 2
#
# spark_df.withColumn("new_col", multiply_by_two(spark_df["value"]))
```
  可以说，没有pyarrow，PySpark在处理大数据时的性能会大打折扣，尤其是在需要频繁与Python数据结构交互的场景。