Python操作Parquet文件：pyarrow实用教程

## Python操作Parquet文件指南：pyarrow实用教程 本文深入解析了如何使用Python中的核心工具`pyarrow`高效操作Parquet文件，Parquet作为一种列式存储格式，在大数据分析领域拥有显著优势。我们将学习如何利用`pyarrow.parquet`模块的`read_table`和`write_table`函数实现Parquet文件的读写，并掌握与`Pandas`进行高效数据转换的方法，例如`pa.Table.from_pandas()`和`to_pandas()`。此外，本文还提供了处理大型Parquet文件、提升查询效率的高级技巧，包括分块读取、谓词下推和列裁剪等。同时，还会介绍如何使用`pyarrow.dataset`模块管理分区数据集，并讨论数据类型映射和异常处理等注意事项，助你轻松应对大数据分析挑战。

在Python中操作Parquet文件的核心工具是pyarrow。1. 使用pyarrow.parquet模块的read_table和write_table函数实现Parquet文件的读写；2. 利用pa.Table.from_pandas()和to_pandas()实现与Pandas的高效转换；3. 处理大型文件时，可通过分块读取（iter_batches）控制内存使用；4. 使用谓词下推（filters）和列裁剪（columns）提升查询效率；5. 通过pyarrow.dataset模块统一管理分区数据集，并支持过滤和自动Schema识别；6. 注意数据类型映射、preserve_index参数设置以及异常处理，以避免常见问题。Parquet格式因其列式存储结构，在I/O效率、压缩率和Schema演进方面具有显著优势，非常适合大数据分析场景。

在Python里要操作Parquet文件，pyarrow无疑是那个核心工具，它让这一切变得高效且直接。无论是读写数据，还是与Pandas等数据分析库无缝衔接，pyarrow都提供了底层支持和优化，尤其适合处理大规模数据集。

直接说解决方案，其实就是用pyarrow库。它提供了parquet模块，里头包含了读写Parquet文件的核心功能。最基础的，就是read_table和write_table这两个函数。它们能把Parquet文件直接转换成pyarrow.Table对象，或者反过来。

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

# 假设我们有一个DataFrame
data = {'col1': [1, 2, 3, 4],
        'col2': ['A', 'B', 'C', 'D'],
        'col3': [True, False, True, False]}
df = pd.DataFrame(data)

# 将Pandas DataFrame写入Parquet文件
# 这里可以指定压缩方式，比如'snappy'，'gzip'，'brotli'等
table = pa.Table.from_pandas(df)
pq.write_table(table, 'example.parquet', compression='snappy')
print("文件已写入: example.parquet")

# 从Parquet文件读取数据
read_table = pq.read_table('example.parquet')
print("\n从Parquet文件读取的数据 (pyarrow.Table):")
print(read_table)

# 如果想转回Pandas DataFrame
read_df = read_table.to_pandas()
print("\n转换回Pandas DataFrame:")
print(read_df)

# 读取特定列
# 有时候我们只关心文件中的几列数据，而不是全部加载
partial_table = pq.read_table('example.parquet', columns=['col1', 'col3'])
print("\n只读取特定列 (col1, col3):")
print(partial_table)

为什么数据存储选择Parquet格式，它有什么优势？

说实话，第一次接触Parquet，我可能只是觉得它是一种文件格式，没什么特别的。但深入了解后，你会发现它在数据湖和大数据处理场景下，简直是神来之笔。它最大的亮点在于“列式存储”。这意味着数据不是按行排列的，而是按列存储。

这有什么好处呢？设想一下，你有一个巨大的表格，几百列，但你只想分析其中两三列的数据。如果数据是按行存的，数据库系统或者你的程序就得把整行都读进来，然后再挑出你需要的列。这就像去图书馆借一本书，结果图书馆把整个书架都搬给你，你再从里面找那本书。而列式存储呢，它直接就给你那几列的数据，效率高得不是一点半点。

所以，对分析型查询（OLAP）来说，Parquet简直是为它量身定做的。它能显著减少I/O操作，因为你不需要读取不相关的数据。此外，列式存储也更容易进行数据压缩，因为同一列的数据类型和模式通常是相似的，压缩算法能发挥更大效用，文件自然就小了。更小的文件意味着更快的传输速度，更少的存储成本。

还有一点，Parquet文件是自描述的，它包含了数据的Schema信息，而且支持Schema演进，这意味着你可以灵活地添加或删除列，而不会破坏现有数据。它还支持多种数据类型，并且与Hadoop、Spark、Presto、Dask等大数据生态系统无缝集成，这让它成为了构建现代数据湖的首选格式。在我看来，选择Parquet不仅仅是节省空间，更是为了未来数据分析的灵活性和性能打下基础。

pyarrow与pandas结合使用，有什么最佳实践？

Pandas是Python数据分析的利器，而pyarrow则是处理Parquet文件的高效引擎。它们俩的结合，简直是如虎添翼。但要用好，还是有些门道。

最直接的结合点就是pyarrow.Table.from_pandas()和pyarrow.Table.to_pandas()。这俩函数负责pandas.DataFrame和pyarrow.Table之间的转换。通常，当你需要把一个Pandas DataFrame存成Parquet文件，或者从Parquet文件读出来变成DataFrame时，就会用到它们。

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

# 准备一个DataFrame，包含一些常见的数据类型
df_complex = pd.DataFrame({
    'int_col': [1, 2, None, 4],
    'float_col': [1.1, 2.2, 3.3, None],
    'str_col': ['apple', 'banana', 'cherry', 'date'],
    'date_col': pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04']),
    'bool_col': [True, False, True, False]
})

# 写入Parquet，注意这里可以控制Pandas索引是否写入
# 默认情况下，Pandas的索引会作为一列写入Parquet，这在某些场景下可能不是你想要的
table_from_df = pa.Table.from_pandas(df_complex, preserve_index=False)
pq.write_table(table_from_df, 'complex_data.parquet')
print("复杂数据DataFrame已写入: complex_data.parquet")

# 从Parquet读取，并转换回Pandas DataFrame
# 注意：pyarrow在处理缺失值和数据类型推断上可能与Pandas默认行为略有不同
# 比如Pandas的NaN在pyarrow中会映射为null，datetime with timezone可能需要特殊处理
read_back_df = pq.read_table('complex_data.parquet').to_pandas()
print("\n从Parquet读取并转换回Pandas DataFrame:")
print(read_back_df.info())

一个常见的“坑”是数据类型映射。Pandas的object类型通常用来存储字符串，但在pyarrow中，更明确的类型是string或binary。from_pandas通常能很好地处理，但如果你在Pandas里混用了不同类型的对象在object列里，或者有复杂的自定义对象，可能会遇到序列化问题。明确地将Pandas列转换为pyarrow支持的类型，或者在写入前清理数据，是个好习惯。

另一个最佳实践是关于内存。当你的DataFrame非常大，大到内存装不下时，直接to_pandas()可能会导致内存溢出。pyarrow允许你分块读取Parquet文件，虽然pq.read_table本身是一次性加载，但通过ParquetFile对象和iter_batches方法，你可以迭代地处理数据，避免一次性加载所有数据到内存。

# 假设有一个非常大的Parquet文件
# 我们可以模拟一个大的Parquet文件
large_df = pd.DataFrame({
    'id': range(1_000_000),
    'value': [float(i) / 100 for i in range(1_000_000)]
})
large_table = pa.Table.from_pandas(large_df)
pq.write_table(large_table, 'large_example.parquet', row_group_size=100000) # 设置行组大小，方便分块读取

# 分块读取大型Parquet文件
parquet_file = pq.ParquetFile('large_example.parquet')
print(f"\n大型文件共有 {parquet_file.num_row_groups} 个行组。")

# 迭代读取每个行组，并转换为Pandas DataFrame
# 这种方式可以有效控制内存使用
for i, batch in enumerate(parquet_file.iter_batches(batch_size=50000)):
    batch_df = batch.to_pandas()
    print(f"处理第 {i+1} 批数据，大小: {len(batch_df)} 行")
    # 在这里可以对 batch_df 进行处理，比如写入数据库或聚合
    if i >= 1: # 只演示前两批
        break

通过这种方式，你可以将大文件切分成小块来处理，极大提升了内存效率。

处理大型Parquet文件时，pyarrow有哪些高级技巧或注意事项？

处理大型Parquet文件，特别是那种TB级别的数据集时，光会读写那点基础操作是远远不够的。pyarrow在这方面提供了不少高级功能，能让你事半功倍。

首先，是谓词下推（Predicate Pushdown）和列裁剪（Column Projection）。这听起来有点专业，但核心思想很简单：在读取数据之前，就告诉pyarrow你只想要哪些列，以及哪些行满足特定条件。pyarrow会利用Parquet文件的元数据（比如列的最小值、最大值等）来跳过那些不包含所需数据的行组（row group），甚至直接不读取不需要的列。这能极大地减少实际从磁盘读取的数据量，提升查询速度。

# 假设我们有一个包含日期和数值的Parquet文件
# 模拟数据，包含多个行组
data_rows = []
for i in range(100000):
    data_rows.append({
        'date': pd.Timestamp(f'2023-01-01') + pd.Timedelta(days=i),
        'value': i % 100,
        'category': f'cat_{i % 5}'
    })
large_df_filtered = pd.DataFrame(data_rows)
large_table_filtered = pa.Table.from_pandas(large_df_filtered)
pq.write_table(large_table_filtered, 'filtered_data.parquet', row_group_size=10000)

# 使用谓词下推和列裁剪
# 只读取 'value' 和 'category' 列，并且只读取 value > 90 的行
# 注意：pyarrow的过滤器表达式语法
filtered_table = pq.read_table(
    'filtered_data.parquet',
    columns=['value', 'category'],
    filters=[('value', '>', 90)]
)
print(f"\n使用谓词下推和列裁剪读取的数据量: {len(filtered_table)} 行")
print(filtered_table.to_pandas().head())

这里的filters参数就是谓词下推的体现。它会在读取数据时，尽可能地利用Parquet的内部结构来减少不必要的数据加载。

其次，是分区数据集（Partitioned Datasets）。在数据湖中，数据经常会按日期、地区或其他维度进行分区存储，形成类似data/year=2023/month=01/day=01/part-0.parquet这样的目录结构。pyarrow.dataset模块就是为处理这类多文件、多目录的数据集而设计的。它能让你像操作一个大文件一样操作整个数据集，pyarrow会自动发现并管理所有分区文件。

import pyarrow.dataset as ds
import os

# 模拟一个分区数据集
# 创建一些目录和文件
os.makedirs('my_partitioned_data/year=2023/month=01', exist_ok=True)
os.makedirs('my_partitioned_data/year=2023/month=02', exist_ok=True)

df_p1 = pd.DataFrame({'col_a': [1, 2], 'col_b': ['x', 'y']})
pq.write_table(pa.Table.from_pandas(df_p1), 'my_partitioned_data/year=2023/month=01/part1.parquet')

df_p2 = pd.DataFrame({'col_a': [3, 4], 'col_b': ['z', 'w']})
pq.write_table(pa.Table.from_pandas(df_p2), 'my_partitioned_data/year=2023/month=02/part2.parquet')

# 使用pyarrow.dataset读取分区数据集
dataset = ds.dataset('my_partitioned_data', format='parquet', partitioning='hive')

# 可以像查询一个表一样查询整个数据集
full_dataset_table = dataset.to_table()
print("\n读取整个分区数据集:")
print(full_dataset_table.to_pandas())

# 也可以对分区进行过滤
# 只读取 month=01 的数据
filtered_dataset_table = dataset.to_table(filter=(ds.field("month") == "01"))
print("\n过滤分区 (month='01') 后读取的数据:")
print(filtered_dataset_table.to_pandas())

pyarrow.dataset不仅支持读取，也支持写入分区数据集，并且能自动推断分区结构，非常强大。

最后，错误处理和Schema演进。在实际生产环境中，Parquet文件可能会因为各种原因损坏，或者Schema发生变化（比如添加了新列，或者改变了列的数据类型）。pyarrow通常能很好地处理Schema演进，但如果遇到不兼容的Schema变更（比如将整数列改为字符串列，且存在非数字值），可能会抛出错误。这时候，你需要仔细检查数据源和Schema定义。对于损坏的文件，pyarrow会直接抛出pyarrow.ArrowInvalid或其他相关的I/O错误，你需要捕获这些异常并进行处理，比如跳过损坏文件，或者尝试修复。这些细节在处理海量数据时，往往是决定项目成败的关键。

今天关于《Python操作Parquet文件：pyarrow实用教程》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！