Importieren einer Excel-Datei in eine Datenbanktabelle mit Python

In der heutigen datengesteuerten Welt ist die effiziente Handhabung und Verarbeitung von Daten eine wesentliche Aufgabe für jede Organisation oder Einzelperson. Pythonbietet mit seinem reichhaltigen Ökosystem an Bibliotheken leistungsstarke Werkzeuge für die Datenmanipulation und -verwaltung, wie z. B. die Bibliothek import pandas. Ein häufiges Szenario ist die Notwendigkeit, Daten zu extrahieren oder zu importieren ausExcel tabellenkalkulationen und Speichern oder Einfügen von Daten in eine Datenbank zur weiteren Analyse oder Integration mit anderen Systemen. In diesem Tutorial wird gezeigt, wie man ein Python-Skript erstellt, das diesen Prozess automatisiert und es ermöglicht, Daten nahtlos aus Excel-Dateien zu lesen und in eine Datenbank einzufügen. Am Ende dieses Lehrgangs werden Sie in der Lage sein, Datenmigrationsaufgaben effizient zu bewältigen. Fangen wir an!

Importieren einer Excel-Datei in eine Datenbanktabelle mit Python

1. Beginnen Sie mit der Installation der IronXL-Bibliothek.

2. Laden Sie Ihre Excel-Datei mit IronXL in den Speicher.

3. Laden Sie das Tabellenblatt, mit dem Sie arbeiten möchten.

4. Wählen Sie den genauen Datenbereich aus, den Sie importieren möchten.

5. Stellen Sie mit Python eine Verbindung zu einer beliebigen Datenbank her, z. B. SQLite oder eine MySQL-Datenbank.

6. Erstellen Sie eine neue Tabelle in Ihrer SQLite-Datenbank, um die importierten Daten aufzunehmen.

7. Fügen Sie die ausgewählten Zeilen aus der Excel-Datei in die neu erstellte SQLite-Tabelle ein.

8. Abrufen und Auswählen von Daten aus der erstellten SQLite-Tabelle zur weiteren Analyse oder Verarbeitung.

   In diesem Lernprogramm werden wir Folgendes verwendenIronXL, eine Python-Bibliothek, die für ihre Effizienz bei der Bearbeitung von Excel-Dateien bekannt ist. Durch die Integration von IronXL in unser Skript stellen wir die nahtlose Extraktion von Daten aus Excel-Tabellen sicher und ermöglichen ein reibungsloses Einfügen in Datenbanken zur weiteren Analyse und Verarbeitung.

Was ist IronXL?

IronXL ist eine von Iron Software entwickelte Python-Bibliothek, die robuste Funktionen fürlesen, erzeugung vonund die Bearbeitung von Excel-Dateien direkt in Python-Anwendungen. IronXL zeichnet sich vor allem dadurch aus, dass es unabhängig von der Installation von Microsoft Excel ist, was den Einsatz in unterschiedlichen Umgebungen vereinfacht. Mit IronXL profitieren die Entwickler von:

Plattformübergreifende Unterstützung: Genießen Sie den nahtlosen Betrieb auf Windows-, macOS-, Linux-, Docker-, Azure- und AWS-Plattformen und gewährleisten Sie die Anpassungsfähigkeit an verschiedene Entwicklungskonfigurationen.

Datenimport und -export: Einfache Handhabung des Datenimports aus XLS-, XLSX-, CSV- und TSV-Dateien, mit der Flexibilität, Arbeitsblätter in diese Formate und sogar in JSON zu exportieren, um die Interoperabilität zu verbessern.

Verschlüsselungsfunktionen: Sorgen Sie für Datensicherheit, indem Sie die Verschlüsselungsfunktionen von IronXL nutzen, die den Schutz von XLSX-, XLSM- und XLTX-Dateien mit Passwörtern ermöglichen.

Formeln und Neuberechnungen: Mühelos mit Excel arbeitenformelnmit dem zusätzlichen Vorteil, dass bei jeder Bearbeitung eines Blattes eine automatische Neuberechnung erfolgt, die Genauigkeit und Zuverlässigkeit bei der Datenbearbeitung gewährleistet.

Cell Styling: Passen Sie das Erscheinungsbild der einzelnen Zellen an, indem Sie die Schriftartstilegröße, Hintergrundmuster, Rahmen und Ausrichtung, um die visuelle Präsentation Ihrer Excel-Dokumente zu verbessern.

Breite Palette an Dokumentenformaten: Mit der Unterstützung verschiedener Formate, darunter XLS, XLSX, XLST, XLSM, CSV und TSV, ermöglicht IronXL Entwicklern die einfache und effiziente Verarbeitung von Daten in einer Vielzahl von Szenarien.

Lassen Sie uns nun mit der Installation von IronXL beginnen.

Schritt 1: IronXL-Bibliothek installieren

Der allererste Schritt ist die Installation der IronXL-Bibliothek. Führen Sie den folgenden Befehl aus, um IronXL in der Eingabeaufforderung zu installieren.

pip install IronXL

pip install IronXL

Schritt 2: Excel-Arbeitsmappe laden

Der nächste Schritt besteht darin, die Excel-Datei zu laden. Wir werden die folgende Excel-Datei für diesen Lehrgang verwenden.

Mit dem folgenden Code wird die vorhandene Excel-Datei in den Speicher geladen.

from ironxl import *     # Supported for XLSX, XLS, XLSM, XLTX, CSV, and TSV
License.LicenseKey = "IRONSUITE.ABC.XYZ.COM.15796-DEPLOYMENT.TRIAL-5X63V4.TRIAL.EXPIRES.27.MAY.2024";
workbook = WorkBook.Load("sample_excel.xlsx")

from ironxl import *     # Supported for XLSX, XLS, XLSM, XLTX, CSV, and TSV
License.LicenseKey = "IRONSUITE.ABC.XYZ.COM.15796-DEPLOYMENT.TRIAL-5X63V4.TRIAL.EXPIRES.27.MAY.2024";
workbook = WorkBook.Load("sample_excel.xlsx")

Der obige Python-Codeausschnitt demonstriert das Laden einer Excel-Arbeitsmappe mit dem Namen "sample_excel.xlsx" unter Verwendung der IronXL-Bibliothek. Zunächst wird das erforderliche Python-Modul aus IronXL importiert. Anschließend wird ein Lizenzschlüssel zugewiesen, der die Nutzung der Bibliothek bestätigt. Sie können Ihren kostenlosen Lizenzschlüssel von derIronXL-Website. Schließlich wird die Methode Load verwendet, um die angegebene Excel-Arbeitsmappe zu öffnen und in den Speicher zu laden. Dies ermöglicht eine nachträgliche programmatische Bearbeitung des Inhalts, z. B. das Lesen von Daten, die Änderung von Zellwerten oder die Anwendung von Formatierungen.

Schritt 3: Arbeitsblatt auswählen

Um mit IronXL ein Arbeitsblatt in einer Excel-Arbeitsmappe auszuwählen, können Sie den Index oder den Namen des Arbeitsblatts angeben.

worksheet = workbook.WorkSheets[0]

worksheet = workbook.WorkSheets[0]

Diese Zeile wählt das erste Arbeitsblatt in der geladenen Excel-Arbeitsmappe aus und ordnet es der Variablen "Arbeitsblatt" zu, so dass nachfolgende Operationen auf diesem speziellen Arbeitsblatt innerhalb der Arbeitsmappe ausgeführt werden können. Damit werden Excel-Daten aus einem Excel-Blatt in eine Arbeitsblattvariable geladen.

Schritt 4: Öffnen Sie die Datenbankverbindung

In diesem Lernprogramm verwenden wir eine SQLite-Datenbank anstelle eines MySQL-Datenbank-Servers. Um Datenbankoperationen zu starten, wird zunächst eine Verbindung zur Datenbank hergestellt.

import sqlite3
# Connect to SQLite database (or create it if it doesn't exist)
conn = sqlite3.connect('data.db')

import sqlite3
# Connect to SQLite database (or create it if it doesn't exist)
conn = sqlite3.connect('data.db')

Die obige Zeile stellt eine Verbindung zu einer SQLite-Datenbank namens "data.db" her. Wenn die angegebene Datenbank nicht existiert, wird sie automatisch erstellt. Diese Verbindung ermöglicht die spätere Interaktion mit der SQLite-Datenbank, z. B. das Ausführen von Abfragen und die Durchführung von Datenmanipulationsoperationen.

Schritt 5: Eine Tabelle erstellen

Der nächste Schritt besteht darin, eine Datenbanktabelle in der Datenbank zu erstellen, in die wir Daten aus einer Excel-Datei importieren werden. Um eine Tabelle in der SQLite-Datenbank zu erstellen, können Sie eine SQL-Anweisung über das Verbindungsobjekt ausführen.

cursor = conn.cursor() // database objects
cursor.execute('''CREATE TABLE IF NOT EXISTS customer ( id Number,
            FirstName TEXT,
                    LastName TEXT,
                    Gender TEXT,
            Country TEXT,
            Age Number
                )''')

cursor = conn.cursor() // database objects
cursor.execute('''CREATE TABLE IF NOT EXISTS customer ( id Number,
            FirstName TEXT,
                    LastName TEXT,
                    Gender TEXT,
            Country TEXT,
            Age Number
                )''')

Das obige Codeschnipsel initialisiert ein Cursor-Objekt zur Ausführung von SQL-Befehlen innerhalb der SQLite-Datenbankverbindung. Es wird eine Tabelle namens "Kunde" mit den Spalten "id", "Vorname", "Nachname", "Geschlecht", "Land" und "Alter" erstellt. Die Tabelle wird erstellt, wenn sie noch nicht existiert, wobei die angegebenen Spaltendatentypen beachtet werden.

Schritt 6: Importieren von Daten in die Datenbank mit Python

Jetzt fügen wir Daten in unsere neu erstellte Tabelle ein. Wir werden eine Excel-Datei importieren und ihre Daten in die SQLite-Datenbank einfügen.

for i in range(2, 11):
    values_tuple = (
        worksheet[f"A{i}"].StringValue,
        worksheet[f"B{i}"].StringValue,
        worksheet[f"C{i}"].StringValue,
        worksheet[f"D{i}"].StringValue,
        worksheet[f"E{i}"].StringValue,
        worksheet[f"F{i}"].StringValue
    )
    cursor.execute("INSERT INTO customer VALUES (?, ?, ?, ?, ?, ?)", values_tuple)
conn.commit()

for i in range(2, 11):
    values_tuple = (
        worksheet[f"A{i}"].StringValue,
        worksheet[f"B{i}"].StringValue,
        worksheet[f"C{i}"].StringValue,
        worksheet[f"D{i}"].StringValue,
        worksheet[f"E{i}"].StringValue,
        worksheet[f"F{i}"].StringValue
    )
    cursor.execute("INSERT INTO customer VALUES (?, ?, ?, ?, ?, ?)", values_tuple)
conn.commit()

Der obige Code durchläuft die Zeilen 2 bis 10 im Excel-Arbeitsblatt und extrahiert Werte aus den Spalten A bis F für jede Zeile. Diese Werte werden in einem Tupel gespeichert, das die Daten darstellt, die in die Tabelle "Kunde" eingefügt werden sollen. Der Cursor führt dann einen SQL INSERT-Befehl aus und nimmt das Wertetupel in die Tabelle auf. Dieser Vorgang wird für jede Zeile wiederholt, wodurch die Daten aus der Excel-Datei in die SQLite-Datenbank importiert werden. Schließlich wird conn.commit() schreibt die Transaktion fest und stellt sicher, dass die Änderungen gespeichert und in der Datenbank erhalten bleiben.

Schritt 7: Lesen von Daten aus der Datenbank

Um zu überprüfen, ob die Daten korrekt eingefügt wurden, können Sie mit einer SELECT-Abfrage Daten aus der Tabelle "Kunde" in der SQLite-Datenbank lesen. Zum Beispiel:

cursor.execute("SELECT * FROM customer")
# Fetch all rows from the result set
rows = cursor.fetchall()
# Print the rows
for row in rows:
    print(row)
conn.close()

cursor.execute("SELECT * FROM customer")
# Fetch all rows from the result set
rows = cursor.fetchall()
# Print the rows
for row in rows:
    print(row)
conn.close()

Der obige Code führt eine SELECT-Abfrage auf die Tabelle "customer" in der SQLite-Datenbank aus und ruft alle Zeilen ab. Die abgerufenen Zeilen werden in der Variablen 'rows' mit Hilfe des Befehls fetchall gespeichert() methode. Dann wird jede Zeile iterativ gedruckt, wobei die in die Tabelle "Kunde" eingegebenen Daten angezeigt werden. Schließlich wird die Datenbankverbindung mit dem Befehl close() methode zur Freigabe von Ressourcen.

Der vollständige Code lautet wie folgt:

import sqlite3
from ironxl import *     # Supported for XLSX, XLS, XLSM, XLTX, CSV, and TSV
License.LicenseKey = "IRONSUITE.ABC.XYZ.COM.15796-DEPLOYMENT.TRIAL-5X63V4.TRIAL.EXPIRES.27.MAY.2024";
workbook = WorkBook.Load("sample_excel.xlsx")
# Select worksheet at index 0
worksheet = workbook.WorkSheets[0]
# Connect to SQLite database (or create it if it doesn't exist)
conn = sqlite3.connect('data.db')
cursor = conn.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS customer ( id Number,
                    FirstName TEXT,
                    LastName TEXT,
                    Gender TEXT,
                    Country TEXT,
                    Age Number
                )''')
cursor.execute("DELETE FROM customer")
for i in range(2, 11):
    values_tuple = (
        worksheet[f"A{i}"].StringValue,
        worksheet[f"B{i}"].StringValue,
        worksheet[f"C{i}"].StringValue,
        worksheet[f"D{i}"].StringValue,
        worksheet[f"E{i}"].StringValue,
        worksheet[f"F{i}"].StringValue
    )
    cursor.execute("INSERT INTO customer VALUES (?, ?, ?, ?, ?, ?)", values_tuple)
conn.commit()  
cursor.execute("SELECT * FROM customer")
# Fetch all rows from the result set
rows = cursor.fetchall()
# Print the rows
for row in rows:
    print(row)
conn.close()

import sqlite3
from ironxl import *     # Supported for XLSX, XLS, XLSM, XLTX, CSV, and TSV
License.LicenseKey = "IRONSUITE.ABC.XYZ.COM.15796-DEPLOYMENT.TRIAL-5X63V4.TRIAL.EXPIRES.27.MAY.2024";
workbook = WorkBook.Load("sample_excel.xlsx")
# Select worksheet at index 0
worksheet = workbook.WorkSheets[0]
# Connect to SQLite database (or create it if it doesn't exist)
conn = sqlite3.connect('data.db')
cursor = conn.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS customer ( id Number,
                    FirstName TEXT,
                    LastName TEXT,
                    Gender TEXT,
                    Country TEXT,
                    Age Number
                )''')
cursor.execute("DELETE FROM customer")
for i in range(2, 11):
    values_tuple = (
        worksheet[f"A{i}"].StringValue,
        worksheet[f"B{i}"].StringValue,
        worksheet[f"C{i}"].StringValue,
        worksheet[f"D{i}"].StringValue,
        worksheet[f"E{i}"].StringValue,
        worksheet[f"F{i}"].StringValue
    )
    cursor.execute("INSERT INTO customer VALUES (?, ?, ?, ?, ?, ?)", values_tuple)
conn.commit()  
cursor.execute("SELECT * FROM customer")
# Fetch all rows from the result set
rows = cursor.fetchall()
# Print the rows
for row in rows:
    print(row)
conn.close()

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass dieses Tutorial einen automatisierten Ansatz zurlesedaten schöpft sein volles Potenzial für die Datenverwaltung aus. Nutzen Sie die Leistungsfähigkeit von Python und IronXL, um Ihre Datenverarbeitungsabläufe zu optimieren und Ihre Projekte mit Zuversicht voranzutreiben.