Fonction df.to_parquet() de Pandas

Pandas 常用函数 Fonctions courantes de Pandas

to_parquet()C'est une méthode de DataFrame, utilisée pour exporter des données vers un fichier au format Parquet.

Parquet est un format de fichier de stockage en colonnes spécialement conçu pour les scénarios d'analyse de big data. Il présente des avantages tels qu'un taux de compression élevé, des performances de lecture/écriture élevées et la prise en charge de types de données complexes. C'est le format standard pour les frameworks de big data tels qu'Apache Hadoop et Apache Spark.

Syntaxe de base et paramètres

Format de syntaxe

DataFrame.to_parquet(path, engine='auto', compression='snappy',
                     index=None, partition_cols=None, storage_options=None, ...)

Description du paramètre

Paramètre	Type	Description	Valeur par défaut
path	str, objet de chemin	Chemin du fichier	Requis
engine	str	Moteur : 'auto', 'pyarrow', 'fastparquet'	'auto'
compression	str	Compression : 'snappy', 'gzip', 'brotli', None	'snappy'
index	bool, None	Indique si l'index doit être inclus	Aucune
partition_cols	liste	Colonne(s) de partition, stocke les données partitionnées par colonne	Aucune

Description de la valeur de retour

Type de retour：None
Écrit les données directement dans un fichier Parquet, aucune valeur de retour.

Exemples

À travers les exemples suivants, maîtrisez de manière exhaustiveto_parquet()les différentes utilisations.

Exemple 1 : Utilisation de base - Exportation vers un fichier Parquet

Créez d'abord un DataFrame, puis utilisezto_parquet()pour exporter vers un fichier Parquet.

Exemple

import pandas as pd

# Créer un DataFrame d'exemple
data = {
'name': ['Tom', 'Jerry', 'Mike', 'Lucy', 'John'],
'age': [28, 35, 42, 26, 31],
'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen', 'Hangzhou'],
'salary': [8000, 12000, 15000, 7000, 9000],
'department': ['IT', 'HR', 'Sales', 'IT', 'HR']
}
df = pd.DataFrame(data)

# Exemple 1a : Export de base
# path: chemin du fichier (obligatoire)
# Utilise la compression snappy par défaut
df.to_parquet('employees.parquet')
print("Exporté vers employees.parquet")

# Vérifier la taille du fichier
import os
file_size = os.path.getsize('employees.parquet')
print(f"Taille du fichier : {file_size} bytes")

# Exemple 1b : Lire et vérifier
# Nécessite l'installation de pyarrow ou fastparquet
df_check = pd.read_parquet('employees.parquet')
print("nVérifier en lisant :")
print(df_check)

Sortie :

已导出到 employees.parquet
文件大小: 约 600-800 字节（远小于 CSV）

验证读取:
    name  age       city  salary department
0    Tom   28    Beijing    8000         IT
1  Jerry   35  Shanghai   12000         HR
2   Mike   42  Guangzhou   15000       Sales
3   Lucy   26   Shenzhen    7000         IT
4   John   31   Hangzhou    9000         HR

Explication du code :

to_parquet()Exporter le DataFrame au format Parquet.
Par défaut, utilisesnappyla compression, avec des résultats de compression remarquables.
Les fichiers Parquet sont beaucoup plus petits que les fichiers CSV et également plus rapides à lire.

Exemple 2 : Sélection du moteur et de la méthode de compression

Le format Parquet prend en charge plusieurs moteurs et méthodes de compression, que l'on peut sélectionner selon les besoins.

Exemple

import pandas as pd
import os

# Créer un DataFrame plus grand pour observer l'effet de compression
import numpy as np
np.random.seed(42)
df_large = pd.DataFrame({
'id': range(10000),
'value': np.random.randn(10000),
'category': np.random.choice(['A', 'B', 'C', 'D'], 10000),
'name': np.random.choice(['Tom', 'Jerry', 'Mike', 'Lucy', 'John'], 10000)
})

# Exemple 2a : Utiliser différentes méthodes de compression
# snappy : compression rapide, vitesse élevée, taux de compression modéré (par défaut)
df_large.to_parquet('output_snappy.parquet', compression='snappy')

# gzip : taux de compression élevé, fichiers plus petits
df_large.to_parquet('output_gzip.parquet', compression='gzip')

# brotli : taux de compression plus élevé
df_large.to_parquet('output_brotli.parquet', compression='brotli')

# aucune compression
df_large.to_parquet('output_none.parquet', compression=None)

# Comparer les tailles de fichiers
print("Comparaison des tailles de fichiers avec différentes méthodes de compression :")
for name in ['snappy', 'gzip', 'brotli', 'none']:
size = os.path.getsize(f'output_{name}.parquet')
print(f" {name}: {size:,} bytes")
print()

# Exemple 2b : Choisir le moteur
# auto : sélection automatique (par défaut)
# pyarrow : implémentation Apache Arrow, complète, bonnes performances
# fastparquet : implémentation pure Python, bonne compatibilité
print("Moteurs disponibles : auto, pyarrow, fastparquet")
print("Actuellement utilisé :", end=" ")

# Vérifier les moteurs disponibles
try:
import pyarrow
print("pyarrow")
except ImportError:
pass

try:
import fastparquet
print("fastparquet")
except ImportError:
pass

Sortie :

不同压缩方式的文件大小对比:
  snappy: 约 100KB
  gzip: 约 80KB
  brotli: 约 70KB
  none: 约 200KB

不同压缩方式各有优劣:
  snappy: 速度快，压缩比适中（默认推荐）
  gzip: 压缩比更高，适合存储
  brotli: 最高压缩比，适合冷数据
  none: 无压缩，速度最快

Explication du code :

compressionLe paramètre compression permet de sélectionner différentes méthodes de compression.
snappyest l'option par défaut, offrant un équilibre entre vitesse et taux de compression.
gzipA un taux de compression plus élevé, mais est légèrement plus lent.
engineLe paramètre engine permet de sélectionner le moteur à utiliser.

Exemple 3 : Stockage partitionné

Parquet prend en charge le stockage partitionné par colonne, une fonctionnalité importante dans l'analyse du big data.

Exemple

import pandas as pd
import os
import shutil

# Créer un DataFrame
df = pd.DataFrame({
'name': ['Tom', 'Jerry', 'Mike', 'Lucy', 'John', 'Mary', 'Bob', 'Alice'],
'age': [28, 35, 42, 26, 31, 29, 38, 24],
'department': ['IT', 'HR', 'Sales', 'IT', 'RH', 'IT', 'Ventes', 'RH'],
'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen', 'Hangzhou',
'Pékin', 'Shanghai', 'Pékin']
})

# Exemple 3a : Partitionner par une seule colonne
# partition_cols spécifie la colonne de partition, ce qui génère des sous-répertoires
if os.path.exists('partitioned'):
shutil.rmtree('partitioned')

df.to_parquet('partitioned', partition_cols=['department'])
print("Exporté avec partitionnement par département")

# Afficher la structure du répertoire de partition
for root, dirs, files in os.walk('partitioned'):
level = root.replace('partitioned', '').count(os.sep)
indent = ' ' * 2 * level
print(f'{indent}{os.path.basename(root)}/')
subindent = ' ' * 2 * (level + 1)
for file in files:
print(f'{subindent}{file}')

Sortie :

已按 department 分区导出

分区目录结构:
partitioned/
  department=HR/
    xxx.parquet
  department=IT/
    xxx.parquet
  department=Sales/
    xxx.parquet

Explication du code :

partition_colsLe paramètre partition_cols effectue un stockage partitionné par la colonne spécifiée.
Le stockage partitionné crée des sous-répertoires dans le système de fichiers, un répertoire par valeur de partition.
Le stockage partitionné est très avantageux pour les requêtes big data, car seules les partitions nécessaires doivent être lues.

Exemple 4 : Gestion de l'index

Lors de l'exportation vers Parquet, vous pouvez choisir d'inclure ou non l'index.

Exemple

import pandas as pd

# Créer un DataFrame avec un index
df = pd.DataFrame({
'name': ['Tom', 'Jerry', 'Mike', 'Lucy'],
'age': [28, 35, 42, 26],
'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen']
})
df.index = ['A001', 'A002', 'A003', 'A004']

# Exemple 4a : Inclure l'index par défaut
df.to_parquet('with_index.parquet')
print("Export (index inclus par défaut)")

# Exemple 4b : Exclure l'index
df.to_parquet('without_index.parquet', index=False)
print("Export (index non inclus)")

# Exemple 4c : Inclure explicitement l'index
df.to_parquet('explicit_index.parquet', index=True)
print("Export (inclure explicitement l'index)")

# Lire et comparer
print("nLire et comparer les différences :")
print("nDonnées d'origine :")
print(df)
print("nRead with_index.parquet:")
print(pd.read_parquet('with_index.parquet'))
print("nRead without_index.parquet:")
print(pd.read_parquet('without_index.parquet'))
print("nRead explicit_index.parquet:")
print(pd.read_parquet('explicit_index.parquet'))

Sortie :

导出（默认包含索引）
导出（不包含索引）
导出（显式包含索引）

读取并比较差异:

原始数据:
    name  age       city
A001  Tom   28    Beijing
A002  Jerry   35  Shanghai
A003   Mike   42  Guangzhou
A004  Lucy   26   Shenzhen

读取 with_index.parquet:
    name  age       city  index
0    Tom   28   Beijing   A001
1   Jerry  35  Shanghai   A002
2    Mike   42  Guangzhou  A003
3    Lucy   26  Shenzhen   A004

读取 without_index.parquet:
    name  age       city
0    Tom   28   Beijing
1   Jerry  35  Shanghai
2    Mike   42  Guangzhou
3    Lucy   26   Shenzhen

读取 explicit_index.parquet:
    name  age       city  index
0    Tom   28   Beijing   A001
1   Jerry  35  Shanghai   A002
2    Mike   42  Guangzhou  A003
3    Lucy   26  Shenzhen   A004

Explication du code :

index=TrueInclut explicitement l'index en tant que colonne.
index=FalseN'inclut pas l'index.
Le comportement par défaut dépend des paramètres d'index de pandas.

Notes

Utilisationto_parquet()nécessite l'installation depyarrowoufastparquet。
Il est recommandé d'installerpyarrow：pip install pyarrow。
Parquet est un stockage colonnaire, adapté aux scénarios d'analyse de big data, mais pas aux petites données.
Le stockage partitionné peut améliorer considérablement les performances des requêtes big data.
Parquet prend en charge les types de données complexes (structures imbriquées), mais ils ne sont pas couramment utilisés dans les DataFrames pandas.

Résumé

to_parquet()C'est une méthode permettant à DataFrame d'exporter au format Parquet. Parquet est le format de stockage colonnaire standard dans le domaine du big data, avec des avantages tels qu'un taux de compression élevé, de hautes performances et la prise en charge du partitionnement.

Dans les scénarios de traitement du big data, Parquet est le format de données privilégié. Il est parfaitement compatible avec les frameworks big data tels qu'Apache Spark et Apache Hive. Lors du traitement de données à grande échelle, il est recommandé d'utiliser le format Parquet au lieu de CSV ou Excel.

Pandas 常用函数 Fonctions courantes de Pandas

Autres extensions

Lecture et écriture de données

Cœur du traitement des données

Manuel de référence

Statistiques et cas

Fonction df.to_parquet() de Pandas

Syntaxe de base et paramètres

Format de syntaxe

Description du paramètre

Description de la valeur de retour

Exemples

Exemple 1 : Utilisation de base - Exportation vers un fichier Parquet

Exemple

Exemple 2 : Sélection du moteur et de la méthode de compression

Exemple

Exemple 3 : Stockage partitionné

Exemple

Exemple 4 : Gestion de l'index

Exemple

Notes

Résumé