Einführung

*Fast-Parkett ist eine Python-Bibliothek zur Verarbeitung des Parquet-Dateiformats, das häufig in Big-Data-Workflows verwendet wird. Es lässt sich gut mit anderen Python-basierten Datenverarbeitungstools wie Dask und Pandas integrieren. Schauen wir uns die Funktionen an und sehen wir uns einige Codebeispiele an. Später in diesem Artikel werden wir auch etwas über IronPDFeine Bibliothek zur PDF-Erzeugung von IronSoftware.

Überblick über fastparquet

*Fast-Parkett ist effizient und unterstützt eine breite Palette von Parkettfunktionen. Einige der wichtigsten Merkmale sind:

Lesen und Schreiben von Parkettdateien

Einfaches Lesen von und Schreiben in Parkettdateien und anderen Datendateien.

Integration mit Pandas und Dask

Nahtlose Zusammenarbeit mit Pandas DataFrames und Dask für parallele Verarbeitung.

Unterstützung der Kompression

Unterstützt verschiedene Kompressionsalgorithmen wie gzip, snappy, brotli, lz4 und zstandard in Datendateien.

Effiziente Speicherung

Optimiert für die Speicherung und den Abruf großer Datensätze oder Datendateien unter Verwendung des kolumnaren Parquet-Dateiformats und einer auf die Datei verweisenden Metadaten-Datei.

Einrichtung

Sie können Folgendes installieren schnelles Parkett mit pip:

pip install fastparquet

Oder mit conda:

conda install -c conda-forge fastparquet

conda install -c conda-forge fastparquet

Grundlegende Verwendung

Hier ist ein einfaches Beispiel, um Ihnen den Einstieg in fastparquet zu erleichtern.

Schreiben einer Parkettdatei

Sie können einen Pandas DataFrame in eine Parquet-Datei schreiben:

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'.")

Ausgabe

Lesen einer Parkettdatei

Sie können eine Parquet-Datei in einen Pandas DataFrame einlesen:

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())

Ausgabe

Anzeige der Metadaten von Parkettdateien

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)

Ausgabe

Erweiterte Funktionen

Dask für die Parallelverarbeitung verwenden

fastparquet python integriert sich gut mit Dask für die parallele Verarbeitung großer Datenmengen:

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)

Komprimierung anpassen

Sie können beim Schreiben von Parkettdateien verschiedene Komprimierungsalgorithmen angeben:

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')

Einführung in IronPDF

IronPDF ist eine robuste Python-Bibliothek zum Erzeugen, Ändern und digitalen Signieren von PDF-Dokumenten, die aus HTML, CSS, Bildern und JavaScript abgeleitet sind. Es zeichnet sich durch hohe Leistung bei minimalem Speicherbedarf aus. Hier sind seine wichtigsten Merkmale:

1. Konvertierung von HTML in PDF

Konvertieren Sie mit IronPDF HTML-Dateien, HTML-Strings und URLs in PDF-Dokumente. Zum Beispiel, mühelos webseiten in PDFs umwandeln mit dem PDF-Renderer von Chrome.

2. Plattformübergreifende Unterstützung

Kompatibel mit Python 3+ unter Windows, Mac, Linux und verschiedenen Cloud-Plattformen. IronPDF ist auch für .NET-, Java-, Python- und Node.js-Umgebungen verfügbar.

3. Bearbeitung und Unterzeichnung

Ändern Sie Dokumenteigenschaften, verbessern Sie die Sicherheit mit passwortschutz und Berechtigungenund integrieren digitale Signaturen in Ihre PDFs mit IronPDF.

4. Seitenvorlagen und Einstellungen

Maßgeschneiderte PDFs mit benutzerdefinierten kopfzeilen, Fußzeilen, seitenzahlenund einstellbare Ränder. Es unterstützt responsive Layouts und passt sich benutzerdefinierten Papierformaten an.

5. Einhaltung von Normen

Entspricht den PDF-Standards wie PDF/A und PDF/UA. Es beherrscht die UTF-8-Zeichenkodierung und verwaltet Assets wie Bilder, CSS-Stylesheets und Schriftarten effektiv.

Erzeugen von PDF-Dokumenten mit IronPDF und fastparquet

Voraussetzungen für IronPDF for Python

1. IronPDF setzt auf .NET 6.0 als Basistechnologie. Bitte vergewissern Sie sich daher .NET 6.0-Laufzeit auf Ihrem System installiert ist.

2. Python 3.0+: Stellen Sie sicher, dass Sie Python Version 3 oder höher installiert haben.

3. pip: Python-Paket-Installationsprogramm pip für die Installation des IronPDF-Pakets.

Einrichtung

# 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

Code-Beispiel

Das folgende Codebeispiel demonstriert die Verwendung von fastparquet und IronPDF zusammen in 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")

Code Erläuterung

Dieses Codeschnipsel demonstriert, wie mehrere Python-Bibliotheken verwendet werden können, um Daten zu manipulieren und ein PDF-Dokument aus HTML-Inhalten zu erzeugen.

1. Imports und Setup: fastparquet import- und IronPDF import-Anweisungen zur Datenmanipulation, zum Lesen und Schreiben von Parquet-Dateien bzw. zur PDF-Erzeugung.

2. Einstellen des Lizenzschlüssels: Legen Sie den Lizenzschlüssel für IronPDF fest, um dessen Funktionen zu aktivieren.

3. Erstellen eines Muster-DataFrames: Definieren Sie einen Beispiel-DataFrame (`df`) die Informationen über Personen enthalten (name, Alter, Stadt).

4. DataFrame in Parquet schreiben: Schreiben des DataFrame `df` in eine Parquet-Datei mit dem Namen `Beispiel.parquet`.

5. Lesen aus Parquet-Datei: Lesen von Daten aus der Parquet-Datei (\"Beispiel-Parkett) zurück in einen DataFrame (`df_read`).

6. Erzeugen von PDF aus HTML: Initialisieren Sie eine ChromePdfRenderer-Instanz mit IronPDF.

7. HTML-Zeichenkette: Konstruieren Sie einen HTML-String (\"Inhalt) die eine Überschrift enthält (`

   `) und Paragraphen (`

   `) anzeige des ursprünglichen DataFrame (`df`) und der aus der Parquet-Datei gelesene DataFrame (`df_read`).

8. `pdf = renderer.RenderHtmlAsPdf(inhalt)`: Rendert den HTML-Inhalt (\"Inhalt) als PDF-Dokument mit IronPDF.

9. pdf.SaveAs("Demo-SchnellParkett.pdf")`: Speichert das erzeugte PDF-Dokument als "Demo-FastParquet.pdf".

   Code demonstriert einen Beispielcode für FastParquet, und dann integriert es nahtlos Datenverarbeitungsfunktionen mit PDF-Generierung, so dass es nützlich für die Erstellung von Berichten oder Dokumenten auf der Grundlage von Daten in Parkett-Dateien gespeichert.

AUSGABE

OUTPUT PDF

IronPDF-Lizenz

IronPDF seite.

Setzen Sie den Lizenzschlüssel an den Anfang des Skripts, bevor Sie IronPDF-Paket:

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

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

Schlussfolgerung

*Fast-Parkett ist eine leistungsfähige und effiziente Bibliothek für die Arbeit mit Parkettdateien in Python. Seine Integration mit Pandas und Dask macht es zu einer guten Wahl für die Verarbeitung großer Datenmengen in einem Python-basierten Big-Data-Workflow. IronPDF ist eine robuste Python-Bibliothek, die die Erstellung, Bearbeitung und Darstellung von PDF-Dokumenten direkt aus Python-Anwendungen ermöglicht. Es vereinfacht Aufgaben wie die Umwandlung von HTML-Inhalten in PDF-Dokumente, die Erstellung interaktiver Formulare und die Durchführung verschiedener PDF-Manipulationen wie das Zusammenführen von Dateien oder das Hinzufügen von Wasserzeichen. IronPDF lässt sich nahtlos in bestehende Python-Frameworks und -Umgebungen integrieren und bietet Entwicklern eine vielseitige Lösung für die dynamische Erstellung und Anpassung von PDF-Dokumenten. Zusammen mit fastparquet und IronPDF können die Daten im Parkettformat und die PDF-Erzeugung nahtlos verarbeitet werden.

IronPDF bietet eine umfassende Dokumentation und Code-Beispiele, um Entwicklern zu helfen, das Beste aus seinen Funktionen zu machen. Weitere Informationen finden Sie in der dokumentation und code-Beispiel seiten.