Icône de message
Passer au contenu du pied de page
  1. IronPDF pour Python
  2. Blog IronPDF pour Python
  3. Aide Python
  4. fastparquet Python
AIDE PYTHON

fastparquet Python (Comment ça marche pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

fastparquet est une bibliothèque Python conçue pour gérer le format de fichier Parquet, couramment utilisé dans les flux de travail de big data. Elle s'intègre bien avec d'autres outils de traitement de données basés sur Python comme Dask et Pandas. Explorons ses fonctionnalités et voyons quelques exemples de code. Later in this article, we will also learn about IronPDF, a PDF generation library from Iron Software.

Aperçu de fastparquet

fastparquet est efficace et supporte une large gamme de fonctionnalités Parquet. Certaines de ses fonctionnalités clés incluent:

Lecture et écriture de fichiers Parquet

Lisez facilement à partir de et écrivez vers des fichiers Parquet et d'autres fichiers de données.

Intégration avec Pandas et Dask

Travaillez sans problème avec des DataFrames Pandas et Dask pour le traitement parallèle.

Support de la compression

Prend en charge divers algorithmes de compression comme gzip, snappy, brotli, lz4, et zstandard dans les fichiers de données.

Stockage efficace

Optimisé pour le stockage et la récupération de grands ensembles de données ou de fichiers de données en utilisant le format de fichier colonne Parquet et le fichier de métadonnées pointant vers le fichier.

Installation

Vous pouvez installer fastparquet en utilisant pip:

pip install fastparquet
pip install fastparquet
SHELL

Ou en utilisant conda:

conda install -c conda-forge fastparquet
conda install -c conda-forge fastparquet
SHELL

Utilisation de base

Voici un exemple simple pour commencer avec fastparquet.

Écriture d'un fichier Parquet

Vous pouvez écrire un DataFrame Pandas dans un fichier Parquet :

import pandas as pd

# Create a sample DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'Los Angeles', 'Chicago']
})

# Write the DataFrame to a Parquet file
df.to_parquet('example.parquet', engine='fastparquet')

# Display confirmation message
print("DataFrame successfully written to 'example.parquet'.")
import pandas as pd

# Create a sample DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'Los Angeles', 'Chicago']
})

# Write the DataFrame to a Parquet file
df.to_parquet('example.parquet', engine='fastparquet')

# Display confirmation message
print("DataFrame successfully written to 'example.parquet'.")
PYTHON

Sortie

fastparquet Python (Comment ça fonctionne pour les développeurs) : Figure 1 - Sortie de console

Lecture d'un fichier Parquet

Vous pouvez lire un fichier Parquet dans un DataFrame Pandas :

import pandas as pd

# Read a Parquet file
df = pd.read_parquet('example.parquet', engine='fastparquet')

# Display the DataFrame
print(df.head())
import pandas as pd

# Read a Parquet file
df = pd.read_parquet('example.parquet', engine='fastparquet')

# Display the DataFrame
print(df.head())
PYTHON

Sortie

fastparquet Python (Comment ça fonctionne pour les développeurs) : Figure 2 - Sortie de console

Affichage des métadonnées de fichier Parquet

import fastparquet as fp

# Reading metadata from Parquet file
meta = fp.ParquetFile('example.parquet').metadata
print("Parquet file metadata:")
print(meta)
import fastparquet as fp

# Reading metadata from Parquet file
meta = fp.ParquetFile('example.parquet').metadata
print("Parquet file metadata:")
print(meta)
PYTHON

Sortie

fastparquet Python (Comment ça fonctionne pour les développeurs) : Figure 3 - Sortie de console

Fonctionnalités avancées

Utilisation de Dask pour le traitement parallèle

fastparquet s'intègre bien avec Dask pour gérer de grands ensembles de données en parallèle :

import dask.dataframe as dd

# Read a Parquet file into a Dask DataFrame
ddf = dd.read_parquet('example.parquet', engine='fastparquet')

# Perform operations on the Dask DataFrame
result = ddf.groupby('name').mean().compute()

# Display the result
print(result)
import dask.dataframe as dd

# Read a Parquet file into a Dask DataFrame
ddf = dd.read_parquet('example.parquet', engine='fastparquet')

# Perform operations on the Dask DataFrame
result = ddf.groupby('name').mean().compute()

# Display the result
print(result)
PYTHON

Personnalisation de la compression

Vous pouvez spécifier différents algorithmes de compression lors de l'écriture de fichiers Parquet :

import pandas as pd

# Create a sample DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35]
})

# Write the DataFrame to a Parquet file with gzip compression
df.to_parquet('example.parquet', engine='fastparquet', compression='gzip')
import pandas as pd

# Create a sample DataFrame
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35]
})

# Write the DataFrame to a Parquet file with gzip compression
df.to_parquet('example.parquet', engine='fastparquet', compression='gzip')
PYTHON

Présentation d'IronPDF

fastparquet Python (Comment ça fonctionne pour les développeurs) : Figure 4 - IronPDF for Python: The Python PDF Library

IronPDF est une bibliothèque Python robuste conçue pour générer, modifier et signer numériquement des documents PDF dérivés de HTML, CSS, images et JavaScript. Elle excelle en performance tout en maintenant une empreinte mémoire minimale. Voici ses principales fonctionnalités :

1. Conversion de HTML en PDF

Convertissez des fichiers HTML, des chaînes HTML et des URL en documents PDF avec IronPDF. Par exemple, rendre facilement des pages web en PDF en utilisant le moteur de rendu PDF de Chrome.

2. Support multiplateforme

Compatible avec Python 3+ sur Windows, Mac, Linux et diverses plateformes cloud. IronPDF est également accessible pour .NET, Java, Python et Node.js.

3. Édition et signature

Modify document properties, enhance security with password protection and permissions, and integrate digital signatures into your PDFs using IronPDF.

4. Modèles de page et paramètres

Tailor PDFs with customized headers, footers, page numbers, and adjustable margins. Il supporte les mises en page réactives et s'adapte à des tailles de papier personnalisées.

5. Conformité aux standards

Conforme aux normes PDF comme PDF/A et PDF/UA. Il gère l'encodage de caractères UTF-8 et gère efficacement les ressources telles que les images, les feuilles de styles CSS et les polices.

Générer des documents PDF en utilisant IronPDF et fastparquet

Prérequis pour IronPDF pour Python

  1. IronPDF repose sur .NET 6.0 en tant que technologie sous-jacente. Par conséquent, assurez-vous que le runtime .NET 6.0 est installé sur votre système.
  2. Python 3.0+ : Assurez-vous d'avoir installé Python version 3 ou ultérieure.
  3. pip : Installez l'outil de gestion de paquets Python pip pour installer le package IronPDF.

Installation

# Install latest version of the libraries
pip install fastparquet
pip install pandas
pip install ironpdf
# Install latest version of the libraries
pip install fastparquet
pip install pandas
pip install ironpdf
SHELL

Exemple de code

L'exemple de code suivant démontre l'utilisation de fastparquet et d'IronPDF ensemble en Python :

import pandas as pd
import fastparquet as fp
from ironpdf import ChromePdfRenderer, License

# Apply your license key for IronPDF
License.LicenseKey = "your Key"

# Sample DataFrame
data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

# Writing DataFrame to a Parquet file
fp.write('example.parquet', df)

# Reading from Parquet file into DataFrame
df_read = fp.ParquetFile('example.parquet').to_pandas()

# Displaying the read DataFrame
print("Original DataFrame:")
print(df)
print("\nDataFrame read from Parquet file:")
print(df_read)

# Initialize a ChromePdfRenderer instance
renderer = ChromePdfRenderer()

# Create a PDF from a HTML string using IronPDF
content = "<h1>Awesome Iron PDF with FastParquet</h1>"
content += "<p> Original DataFrame:</p>"
content += "<p>" + f"{str(df)}" + "</p>"
content += "<p> DataFrame read from Parquet file:</p>"
content += "<p>" + f"{str(df_read)}" + "</p>"

# Render the HTML content to a PDF
pdf = renderer.RenderHtmlAsPdf(content)

# Export the PDF to a file
pdf.SaveAs("Demo-FastParquet.pdf")
import pandas as pd
import fastparquet as fp
from ironpdf import ChromePdfRenderer, License

# Apply your license key for IronPDF
License.LicenseKey = "your Key"

# Sample DataFrame
data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

# Writing DataFrame to a Parquet file
fp.write('example.parquet', df)

# Reading from Parquet file into DataFrame
df_read = fp.ParquetFile('example.parquet').to_pandas()

# Displaying the read DataFrame
print("Original DataFrame:")
print(df)
print("\nDataFrame read from Parquet file:")
print(df_read)

# Initialize a ChromePdfRenderer instance
renderer = ChromePdfRenderer()

# Create a PDF from a HTML string using IronPDF
content = "<h1>Awesome Iron PDF with FastParquet</h1>"
content += "<p> Original DataFrame:</p>"
content += "<p>" + f"{str(df)}" + "</p>"
content += "<p> DataFrame read from Parquet file:</p>"
content += "<p>" + f"{str(df_read)}" + "</p>"

# Render the HTML content to a PDF
pdf = renderer.RenderHtmlAsPdf(content)

# Export the PDF to a file
pdf.SaveAs("Demo-FastParquet.pdf")
PYTHON

Explication du code

Cet extrait de code démontre comment utiliser plusieurs bibliothèques Python pour manipuler des données et générer un document PDF à partir de contenu HTML.

  1. Imports et configuration : Importez les bibliothèques nécessaires pour la manipulation de données, la lecture et l'écriture de fichiers Parquet, et la génération de PDF.

  2. Configuration de la clé de licence : Définissez la clé de licence pour IronPDF, activant ses fonctionnalités complètes.

  3. Création d'un DataFrame d'exemple : Définissez un DataFrame d'exemple (df) contenant des informations sur des individus (nom, âge, ville).

  4. Écriture du DataFrame en Parquet : Écrivez le DataFrame df dans un fichier Parquet nommé example.parquet.

  5. Lecture depuis un fichier Parquet : Lisez des données depuis le fichier Parquet (example.parquet) dans un DataFrame (df_read).

  6. Génération de PDF à partir de HTML :
    • Initialisez une instance de ChromePdfRenderer en utilisant IronPDF.
    • Construisez une chaîne HTML (content) qui inclut un titre (<h1>) et des paragraphes (<p>) affichant le DataFrame original (df) et le DataFrame lu à partir du fichier Parquet (df_read).
    • Rendre le contenu HTML en tant que document PDF en utilisant IronPDF.
    • Sauvegardez le document PDF généré en tant que Demo-FastParquet.pdf.

Le code montre un exemple de code pour FastParquet, intégrant des capacités de traitement de données avec la génération de PDF, le rendant utile pour créer des rapports ou des documents basés sur les données stockées dans des fichiers Parquet.

SORTIE

fastparquet Python (Comment ça fonctionne pour les développeurs) : Figure 5 - Sortie de console affichant les données du DataFrame original et du DataFrame lu à partir du fichier Parquet.

SORTIE PDF

fastparquet Python (Comment ça fonctionne pour les développeurs) : Figure 6 - PDF généré à l'aide de la bibliothèque IronPDF

Licence IronPDF

Pour obtenir des informations sur la licence, visitez la page de licence IronPDF.

Placez la clé de licence au début du script avant d'utiliser le package IronPDF :

from ironpdf import License

# Apply your license key
License.LicenseKey = "your Key"
from ironpdf import License

# Apply your license key
License.LicenseKey = "your Key"
PYTHON

Conclusion

fastparquet est une bibliothèque puissante et efficace pour travailler avec des fichiers Parquet en Python. Son intégration avec Pandas et Dask en fait un excellent choix pour gérer de grands ensembles de données dans un flux de travail big data basé sur Python. IronPDF est une bibliothèque Python robuste qui facilite la création, la manipulation et le rendu de documents PDF directement à partir d'applications Python. Elle simplifie des tâches telles que la conversion de contenu HTML en documents PDF, la création de formulaires interactifs et la réalisation de diverses manipulations PDF comme la fusion de fichiers ou l'ajout de filigranes. IronPDF s'intègre parfaitement aux frameworks et environnements Python existants, offrant aux développeurs une solution polyvalente pour générer et personnaliser dynamiquement des documents PDF. Avec fastparquet, IronPDF permet une manipulation transparente des données dans des formats de fichiers Parquet et la génération de PDF.

IronPDF offre une documentation complète et des exemples de code pour aider les développeurs à tirer le meilleur parti de ses fonctionnalités. For more information, please refer to the documentation and code example pages.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit