Introducción

fastparquet es una biblioteca de Python diseñada para manejar el formato de archivo Parquet, que se utiliza habitualmente en los flujos de trabajo de big data. Se integra bien con otras herramientas de procesamiento de datos basadas en Python, como Dask y Pandas. Exploremos sus características y veamos algunos ejemplos de código. Más adelante en este artículo, también aprenderemos sobreIronPDFuna biblioteca de generación de PDF de**Software de hierro.

Visión general de fastparquet

fastparquet es eficaz y admite una amplia gama de funciones de Parquet. Algunas de sus principales características son:

Lectura y escritura de archivos Parquet

Lee y escribe fácilmente en archivos Parquet y otros archivos de datos.

Integración con Pandas y Dask

Trabaje sin problemas con Pandas DataFrames y Dask para el procesamiento paralelo.

Soporte de compresión

Admite varios algoritmos de compresión como gzip, snappy, brotli, lz4 y zstandard en archivos de datos.

Almacenamiento eficiente

Optimizado tanto para el almacenamiento como para la recuperación de grandes conjuntos de datos o archivos de datos utilizando el formato de archivo en columnas parquet y un archivo de metadatos que apunta al archivo.

Instalación

Puede instalarfastparquet usando pip:

pip install fastparquet

O usando conda:

conda install -c conda-forge fastparquet

conda install -c conda-forge fastparquet

Uso básico

He aquí un ejemplo sencillo para empezar a utilizar fastparquet.

Escribir un archivo Parquet

Puede escribir un Pandas DataFrame en un fichero Parquet:

import pandas as pd
import fastparquet
# Create a sample DataFrame
df = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'Los Angeles', 'Chicago']
}
# Write the DataFrame to single output file using single file path
df.to_parquet('example.parquet', engine='fastparquet')
# Display message
print("DataFrame successfully written to 'example.parquet'.")

import pandas as pd
import fastparquet
# Create a sample DataFrame
df = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'city': ['New York', 'Los Angeles', 'Chicago']
}
# Write the DataFrame to single output file using single file path
df.to_parquet('example.parquet', engine='fastparquet')
# Display message
print("DataFrame successfully written to 'example.parquet'.")

Salida

Lectura de un archivo Parquet

Puede leer un fichero Parquet en un DataFrame de Pandas:

import pandas as pd
import fastparquet
# Read a Parquet file
df = pd.read_parquet('example.parquet', engine='fastparquet')
# Display the DataFrame
print(df.head())

import pandas as pd
import fastparquet
# Read a Parquet file
df = pd.read_parquet('example.parquet', engine='fastparquet')
# Display the DataFrame
print(df.head())

Salida

Visualización de metadatos de archivos 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)

Salida

Funciones avanzadas

Uso de Dask para el procesamiento paralelo

fastparquet python se integra bien conDask para manejar grandes conjuntos de datos en paralelo:

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 for simple data types
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 for simple data types
print(result)

Personalización de la compresión

Puede especificar diferentes algoritmos de compresión al escribir archivos Parquet:

import pandas as pd
import fastparquet
# 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
import fastparquet
# 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')

Presentación de IronPDF

IronPDF es una robusta biblioteca de Python diseñada para generar, modificar y firmar digitalmente documentos PDF derivados de HTML, CSS, imágenes y JavaScript. Sobresale en rendimiento al tiempo que mantiene una huella de memoria mínima. Estas son sus principales características:

1. Conversión de HTML a PDF

Convierta archivos HTML, cadenas HTML y URL en documentos PDF con IronPDF. Por ejemplo, sin esfuerzoconvertir páginas web en PDF utilizando el renderizador de PDF de Chrome.

2. Soporte multiplataforma

Compatible con Python 3+ en Windows, Mac, Linux y varias plataformas en la nube. IronPDF también es accesible para entornos .NET, Java, Python y Node.js.

3. Edición y firma

Modifique las propiedades de los documentos, mejore la seguridad conprotección por contraseña y permisose integrarfirmas digitales en sus PDF con IronPDF.

4. Plantillas de página y configuración

Personaliza los PDFencabezados, pies de página, números de páginay márgenes ajustables. Admite diseños adaptables y tamaños de papel personalizados.

5. Cumplimiento de las normas

Cumple estándares PDF como PDF/A y PDF/UA. Maneja la codificación de caracteres UTF-8 y gestiona eficazmente activos como imágenes, hojas de estilo CSS y fuentes.

Generar documentos PDF con IronPDF y fastparquet

Requisitos previos de IronPDF for Python

1.IronPDF cuenta con .NET 6.0 como tecnología subyacente. Por lo tanto, asegúrese de queTiempo de ejecución de .NET 6.0 está instalado en su sistema.

2. Python 3.0+: Asegúrese de tener instalada la versión 3 o posterior de Python.

3. pip: Instalador de paquetes de Pythonpip para instalar el paquete IronPDF.

Instalación

# 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

Ejemplo de código

El siguiente ejemplo de código demuestra el uso conjunto de fastparquet y IronPDF en Python:

import pandas as pd
import fastparquet as fp
from ironpdf import *     
# Apply your license key
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)
renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
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>"
pdf = renderer.RenderHtmlAsPdf(content)
# Export to a file or Stream
pdf.SaveAs("Demo-FastParquet.pdf")

import pandas as pd
import fastparquet as fp
from ironpdf import *     
# Apply your license key
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)
renderer = ChromePdfRenderer()
# Create a PDF from a HTML string using Python
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>"
pdf = renderer.RenderHtmlAsPdf(content)
# Export to a file or Stream
pdf.SaveAs("Demo-FastParquet.pdf")

Código Explicación

Este fragmento de código muestra cómo utilizar varias bibliotecas de Python para manipular datos y generar un documento PDF a partir de contenido HTML.

1. Importación y configuración: sentencias fastparquet import y IronPDF import para la manipulación de datos, para la lectura y escritura de archivos Parquet y para la generación de PDF, respectivamente.

2. Establecer la clave de licencia: Establezca la clave de licencia para IronPDF, habilitando sus funciones.

3. Crear un DataFrame de muestra: Definir un DataFrame de muestra(`df\`) que contengan información sobre las personas(nombre, edad, ciudad).

4. Escribir DataFrame a Parquet: Escribir el DataFrame `df` en un fichero Parquet llamado `ejemplo.parquet``.

5. Lectura desde el archivo Parquet: Leer datos del archivo Parquet(\ejemplo.parquet) en un DataFrame(`df_read\`).

6. Generar PDF a partir de HTML: Inicializar una instancia de ChromePdfRenderer usando IronPDF.

7. Cadena HTML: Construye una cadena HTML(\Contenido) que incluye un encabezamiento(`

   `) y párrafos(`

   `) visualización del DataFrame original(`df\) y el DataFrame leído del archivo Parquet(\df_read\`).

8. `pdf = renderer.RenderHtmlAsPdf(contenido)`: Renderiza el contenido HTML(\Contenido) como documento PDF utilizando IronPDF.

9. `pdf.SaveAs("Demo-FastParquet.pdf")`: Guarda el documento PDF generado como `Demo-FastParquet.pdf``.

   Code muestra un código de ejemplo para FastParquet, y a continuación integra a la perfección las capacidades de procesamiento de datos con la generación de PDF, lo que lo hace útil para crear informes o documentos basados en datos almacenados en archivos parquet.

SALIDA

SALIDA PDF

Licencia IronPDF

IronPDF página.

Coloque la clave de licencia al principio del script antes de utilizarPaquete IronPDF:

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

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

Conclusión

fastparquet es una biblioteca potente y eficaz para trabajar con archivos parquet en Python. Su integración con Pandas y Dask lo convierte en una gran opción para manejar grandes conjuntos de datos en un flujo de trabajo de big data basado en Python. IronPDF es una robusta biblioteca de Python que facilita la creación, manipulación y representación de documentos PDF directamente desde aplicaciones Python. Simplifica tareas como la conversión de contenidos HTML en documentos PDF, la creación de formularios interactivos y la realización de diversas manipulaciones de PDF, como la fusión de archivos o la adición de marcas de agua. IronPDF se integra perfectamente con los marcos y entornos Python existentes, proporcionando a los desarrolladores una solución versátil para generar y personalizar documentos PDF de forma dinámica. Junto con los datos fastparquet e IronPDF, la manipulación del formato de archivo parquet y la generación de PDF pueden realizarse sin problemas.

IronPDF ofrece una completa documentación y ejemplos de código para ayudar a los desarrolladores a sacar el máximo partido de sus funciones. Para más información, consulte eldocumentación yejemplo de código páginas.