Pandas Read Excel: Excel-Dateien in Python importieren

Name

Soren Atelier

Updated on 9.2.2026

Excel-Dateien bleiben das gängigste Format für die Speicherung tabellarischer Daten in Geschäftsumgebungen, dennoch erzeugt ihr Import in Python für Analysen oft Reibung. Sie müssen mehrere Sheets, inkonsistente Datentypen, fehlende Werte und Speicherbeschränkungen handhaben – und dabei die Datenintegrität wahren. Die pandas-Funktion read_excel() löst diese Herausforderungen, aber nur, wenn Sie wissen, wie Sie ihre über 30 Parameter richtig konfigurieren.

Dieser Leitfaden zeigt Ihnen, wie Sie Excel-Dateien effizient in pandas DataFrames importieren, von einfachen Einzelsheet-Importen bis hin zu fortgeschrittenen Szenarien wie dem gleichzeitigen Lesen mehrerer Sheets, dem Umgang mit großen Dateien und der Behebung häufiger Fehler.

Grundlegende Verwendung von pandas read_excel()

Die einfachste Methode, eine Excel-Datei in einen pandas DataFrame einzulesen, erfordert nur den Dateipfad:

import pandas as pd
 
# Lese das erste Sheet einer Excel-Datei
df = pd.read_excel('data.xlsx')
print(df.head())

Dies liest standardmäßig das erste Sheet und behandelt die erste Zeile als Spaltenüberschriften. Die Funktion erkennt automatisch das Dateiformat (.xlsx oder .xls) und verwendet die entsprechende Engine.

Für Dateien in verschiedenen Verzeichnissen verwenden Sie absolute oder relative Pfade:

# Absoluter Pfad
df = pd.read_excel('/Users/username/Documents/sales_data.xlsx')
 
# Relativer Pfad
df = pd.read_excel('../data/sales_data.xlsx')

Die wichtigsten Parameter verstehen

Die Funktion read_excel() bietet umfassende Kontrolle darüber, wie Daten importiert werden. Hier ist eine Referenztabelle der wichtigsten Parameter:

Arbeiten mit mehreren Sheets

Ein bestimmtes Sheet lesen

Geben Sie Sheets nach Name oder Index an (0-basiert):

# Nach Sheet-Name lesen
df = pd.read_excel('financial_report.xlsx', sheet_name='Q1 Revenue')
 
# Nach Index lesen (0 = erstes Sheet)
df = pd.read_excel('financial_report.xlsx', sheet_name=0)

Mehrere Sheets gleichzeitig lesen

Übergeben Sie eine Liste von Sheet-Namen oder Indizes, um mehrere Sheets in ein Dictionary von DataFrames zu importieren:

# Mehrere spezifische Sheets lesen
sheets_dict = pd.read_excel('annual_report.xlsx',
                            sheet_name=['Q1', 'Q2', 'Q3', 'Q4'])
 
# Auf einzelne DataFrames zugreifen
q1_df = sheets_dict['Q1']
q2_df = sheets_dict['Q2']
 
print(f"Q1 shape: {q1_df.shape}")
print(f"Q2 shape: {q2_df.shape}")

Alle Sheets lesen

Verwenden Sie sheet_name=None, um jedes Sheet in der Arbeitsmappe zu importieren:

# Alle Sheets in ein Dictionary lesen
all_sheets = pd.read_excel('company_data.xlsx', sheet_name=None)
 
# Durch alle Sheets iterieren
for sheet_name, df in all_sheets.items():
    print(f"\nSheet: {sheet_name}")
    print(f"Shape: {df.shape}")
    print(f"Columns: {df.columns.tolist()}")

Dies ist besonders nützlich, wenn Sie mehrere Sheets mit ähnlichen Strukturen verarbeiten müssen:

# Alle Sheets in einen einzigen DataFrame kombinieren
all_sheets = pd.read_excel('monthly_sales.xlsx', sheet_name=None)
combined_df = pd.concat(all_sheets.values(), ignore_index=True)
print(f"Combined shape: {combined_df.shape}")

Datenimport mit Headern und Spalten steuern

Header-Zeilen angeben

Kontrollieren Sie, welche Zeile zu Spaltennamen wird:

# Überspringe erste 2 Zeilen, verwende Zeile 3 als Header
df = pd.read_excel('data.xlsx', header=2)
 
# Keine Header-Zeile - pandas vergibt numerische Spaltennamen
df = pd.read_excel('data.xlsx', header=None)
 
# Mehrstufige Spaltenüberschriften
df = pd.read_excel('data.xlsx', header=[0, 1])

Zeilen überspringen

Entfernen Sie unerwünschte Zeilen vom Anfang der Datei:

# Überspringe erste 3 Zeilen
df = pd.read_excel('data.xlsx', skiprows=3)
 
# Überspringe bestimmte Zeilen (0-indiziert)
df = pd.read_excel('data.xlsx', skiprows=[0, 2, 5])
 
# Überspringe Zeilen mit einer Funktion
df = pd.read_excel('data.xlsx', skiprows=lambda x: x % 2 == 0)  # Überspringe gerade Zeilen

Bestimmte Spalten auswählen

Importieren Sie nur die benötigten Spalten, um Speicher zu sparen:

# Spalten nach Buchstabenbereich auswählen
df = pd.read_excel('data.xlsx', usecols='A:D')
 
# Bestimmte Spalten nach Buchstaben auswählen
df = pd.read_excel('data.xlsx', usecols='A,C,E,G')
 
# Spalten nach Index auswählen
df = pd.read_excel('data.xlsx', usecols=[0, 2, 4, 6])
 
# Spalten nach Name auswählen
df = pd.read_excel('data.xlsx', usecols=['Name', 'Age', 'Salary'])
 
# Spalten mit einer Funktion auswählen
df = pd.read_excel('data.xlsx', usecols=lambda x: 'total' in x.lower())

Datentypspezifikation und -konvertierung

Spaltendatentypen festlegen

Definieren Sie Datentypen explizit, um automatische Inferenzfehler zu vermeiden:

# dtypes für mehrere Spalten angeben
df = pd.read_excel('customer_data.xlsx',
                   dtype={
                       'CustomerID': str,
                       'ZipCode': str,
                       'Age': int,
                       'Revenue': float
                   })
 
# Numerische IDs als Strings beibehalten, um führende Nullen zu erhalten
df = pd.read_excel('products.xlsx', dtype={'ProductID': str})

Umgang mit Datumsangaben

Datum-Spalten automatisch parsen:

# Einzelne Datumsspalte parsen
df = pd.read_excel('orders.xlsx', parse_dates=['OrderDate'])
 
# Mehrere Datumsspalten parsen
df = pd.read_excel('employee_data.xlsx',
                   parse_dates=['HireDate', 'TerminationDate'])
 
# Spalten zu einem einzelnen Datetime kombinieren
df = pd.read_excel('logs.xlsx',
                   parse_dates={'DateTime': ['Date', 'Time']})
 
# Ergebnis prüfen
print(df.dtypes)

Fehlende Werte verwalten

Kontrollieren Sie, wie pandas fehlende Daten identifiziert und behandelt:

# Benutzerdefinierte Indikatoren für fehlende Werte erkennen
df = pd.read_excel('survey_data.xlsx',
                   na_values=['NA', 'N/A', 'null', 'None', '-'])
 
# Verschiedene NA-Werte pro Spalte
df = pd.read_excel('mixed_data.xlsx',
                   na_values={
                       'Age': ['Unknown', 'N/A'],
                       'Salary': [0, -1, 'Not Disclosed']
                   })
 
# Standard-NA-Werte behalten und weitere hinzufügen
df = pd.read_excel('data.xlsx',
                   na_values=['Missing'],
                   keep_default_na=True)

Umgang mit großen Excel-Dateien

Excel-Dateien verbrauchen erheblichen Speicher, wenn sie vollständig in den RAM geladen werden. Verwenden Sie diese Strategien für große Datensätze:

Zeilen begrenzen

Lesen Sie nur die benötigten Zeilen:

# Erste 10.000 Zeilen lesen
df = pd.read_excel('large_file.xlsx', nrows=10000)
 
# Bestimmten Zeilenbereich mit skiprows und nrows lesen
df = pd.read_excel('large_file.xlsx', skiprows=1000, nrows=5000)

Konverter für Speichereffizienz verwenden

Wenden Sie Transformationen während des Imports an, um den Speicherbedarf zu reduzieren:

# Spalten während des Lesens konvertieren
def categorize_status(value):
    return 'Active' if value == 1 else 'Inactive'
 
df = pd.read_excel('users.xlsx',
                   converters={
                       'Status': categorize_status,
                       'Category': lambda x: x.lower().strip()
                   })

Sheets iterativ verarbeiten

Für Arbeitsmappen mit mehreren großen Sheets, verarbeiten Sie jeweils ein Sheet:

import pandas as pd
 
# Zuerst alle Sheet-Namen abrufen
xls = pd.ExcelFile('massive_workbook.xlsx')
sheet_names = xls.sheet_names
 
# Jedes Sheet separat verarbeiten
for sheet in sheet_names:
    df = pd.read_excel(xls, sheet_name=sheet, nrows=10000)
    # df hier verarbeiten
    result = df.describe()
    print(f"\n{sheet} Summary:\n{result}")

Alternative: openpyxl für Streaming verwenden

Für extrem große Dateien ziehen Sie in Betracht, Zeile für Zeile mit openpyxl zu lesen:

from openpyxl import load_workbook
 
# Arbeitsmappe im Nur-Lese-Modus laden
wb = load_workbook('huge_file.xlsx', read_only=True)
ws = wb['Sheet1']
 
# Zeilen iterativ verarbeiten
data = []
for row in ws.iter_rows(min_row=2, max_row=1000, values_only=True):
    data.append(row)
 
# In DataFrame konvertieren
df = pd.DataFrame(data, columns=['Col1', 'Col2', 'Col3'])
wb.close()

Excel-Engines verstehen

Pandas verwendet verschiedene Bibliotheken zum Lesen von Excel-Dateien, abhängig vom Format und installierten Paketen:

Engine explizit angeben:

# openpyxl-Engine erzwingen
df = pd.read_excel('data.xlsx', engine='openpyxl')
 
# Legacy .xls-Datei lesen
df = pd.read_excel('old_data.xls', engine='xlrd')
 
# Binäre Excel-Datei lesen
df = pd.read_excel('data.xlsb', engine='pyxlsb')

Pandas read_excel vs read_csv: Hauptunterschiede

Während beide Funktionen DataFrames erstellen, haben sie wichtige Unterschiede:

Empfehlung: Verwenden Sie read_csv() für großangelegte Datenverarbeitung und read_excel(), wenn Sie mit bestehenden Excel-Arbeitsmappen oder mehreren Sheets arbeiten müssen.

Excel-Daten sofort mit PyGWalker visualisieren

Nach dem Import von Excel-Daten mit pandas müssen Sie diese oft visuell erkunden. PyGWalker (opens in a new tab) verwandelt Ihren DataFrame in eine interaktive Tableau-ähnliche Visualisierungsoberfläche direkt in Ihrem Jupyter-Notebook – ohne dass Sie Plotting-Code schreiben müssen.

import pandas as pd
import pygwalker as pyg
 
# Excel-Daten lesen
df = pd.read_excel('sales_data.xlsx')
 
# Interaktive Visualisierung starten
pyg.walk(df)

Dies öffnet eine Drag-and-Drop-Oberfläche, in der Sie:

• Diagramme erstellen können, indem Sie Spalten zu visuellen Kanälen ziehen
• Sofort zwischen Diagrammtypen wechseln können (Balken, Linie, Scatter, Heatmap)
• Filter und Aggregationen interaktiv anwenden können
• Visualisierungen als Bilder oder Code exportieren können

PyGWalker ist besonders nützlich für explorative Datenanalyse nach dem Import von Excel-Dateien und ermöglicht es Ihnen, Datenverteilungen und Beziehungen zu verstehen, ohne matplotlib- oder seaborn-Code zu schreiben.

Häufige Fehler und Fehlerbehebung

ModuleNotFoundError: No module named 'openpyxl'

Dies ist der häufigste Fehler beim Lesen von .xlsx-Dateien:

ImportError: Missing optional dependency 'openpyxl'. Use pip or conda to install openpyxl.

Lösung: Installieren Sie die erforderliche Engine:

# openpyxl installieren
pip install openpyxl
 
# Oder alle Excel-Abhängigkeiten installieren
pip install pandas[excel]

XLRDError: Excel xlsx file; not supported

Wenn Sie diesen Fehler sehen, versucht xlrd eine .xlsx-Datei zu lesen (unterstützt nur .xls seit Version 2.0):

Lösung: Installieren Sie openpyxl oder geben Sie die Engine an:

df = pd.read_excel('data.xlsx', engine='openpyxl')

FileNotFoundError

Überprüfen Sie Ihren Dateipfad und das Arbeitsverzeichnis:

import os
 
# Aktuelles Verzeichnis ausgeben
print(os.getcwd())
 
# Dateien im Verzeichnis auflisten
print(os.listdir('.'))
 
# Absoluten Pfad verwenden
df = pd.read_excel('/absolute/path/to/file.xlsx')

Speicherfehler bei großen Dateien

Wenn pandas mit Speicherfehlern abstürzt:

# Speicher reduzieren durch Auswahl von Spalten
df = pd.read_excel('large_file.xlsx', usecols=['A', 'B', 'C'])
 
# Zeilen begrenzen
df = pd.read_excel('large_file.xlsx', nrows=50000)
 
# dtypes angeben, um Speicher zu reduzieren
df = pd.read_excel('large_file.xlsx',
                   dtype={'ID': 'int32', 'Category': 'category'})

ValueError: Excel file format cannot be determined

Dies tritt auf, wenn die Dateierweiterung nicht mit dem tatsächlichen Format übereinstimmt:

Lösung: Geben Sie die Engine explizit an oder benennen Sie die Datei mit der richtigen Erweiterung um:

# Verschiedene Engines ausprobieren
df = pd.read_excel('data.xlsx', engine='openpyxl')

Probleme beim Datum-Parsing

Excel speichert Datumsangaben als Seriennummern. Wenn Datumsangaben nicht korrekt geparst werden:

# Datum-Parsing erzwingen
df = pd.read_excel('data.xlsx', parse_dates=['DateColumn'])
 
# Manuelle Konvertierung
df['DateColumn'] = pd.to_datetime(df['DateColumn'])

Fortgeschrittene Techniken

Passwortgeschützte Dateien lesen

Während pandas passwortgeschützte Dateien nicht direkt unterstützt, verwenden Sie msoffcrypto-tool:

import msoffcrypto
import io
import pandas as pd
 
# Datei entschlüsseln
decrypted = io.BytesIO()
with open('protected.xlsx', 'rb') as f:
    file = msoffcrypto.OfficeFile(f)
    file.load_key(password='yourpassword')
    file.decrypt(decrypted)
 
# Entschlüsselte Datei lesen
df = pd.read_excel(decrypted)

read_excel mit Context Managern kombinieren

Für besseres Ressourcenmanagement:

from contextlib import closing
import pandas as pd
 
with closing(pd.ExcelFile('data.xlsx')) as xls:
    df1 = pd.read_excel(xls, sheet_name='Sheet1')
    df2 = pd.read_excel(xls, sheet_name='Sheet2')
    # Datei wird nach diesem Block automatisch geschlossen

Mit URLs arbeiten

Excel-Dateien direkt von URLs lesen:

url = 'https://example.com/data.xlsx'
df = pd.read_excel(url)

RunCell für Excel-Daten-Debugging verwenden

Wenn Sie mit komplexen Excel-Importen in Jupyter-Notebooks arbeiten, bietet RunCell (opens in a new tab) KI-gestützte Unterstützung für das Debuggen von Importfehlern, die Optimierung von Parametern und das Beheben von Datentypenproblemen. Der KI-Agent kann:

• Diagnostizieren, warum read_excel() Datumsangaben nicht korrekt parst
• Optimale dtype-Spezifikationen für Speichereffizienz vorschlagen
• Engine-Kompatibilitätsprobleme debuggen
• Bei der Fehlerbehebung von Encoding- und Formatierungsproblemen helfen

Dies ist besonders wertvoll beim Import unordentlicher realer Excel-Dateien mit inkonsistenter Formatierung oder komplexen Mehrblatt-Strukturen.

FAQ

Wie lese ich eine Excel-Datei ohne Header in pandas?

Setzen Sie header=None, um pandas mitzuteilen, dass die erste Zeile Daten und keine Spaltennamen sind. Pandas vergibt numerische Spaltennamen (0, 1, 2...):

df = pd.read_excel('data.xlsx', header=None)

Sie können dann die Spalten manuell umbenennen:

df.columns = ['Name', 'Age', 'Salary']

Kann pandas mehrere Excel-Dateien gleichzeitig lesen?

Ja, verwenden Sie eine Schleife oder List Comprehension, um mehrere Dateien zu lesen und zu verketten:

import pandas as pd
from glob import glob
 
# Alle Excel-Dateien in einem Verzeichnis lesen
files = glob('data/*.xlsx')
dfs = [pd.read_excel(f) for f in files]
combined_df = pd.concat(dfs, ignore_index=True)

Wie lese ich nur bestimmte Zeilen aus einer Excel-Datei?

Kombinieren Sie die Parameter skiprows und nrows:

# Zeilen 100-199 lesen (überspringe erste 100, lese nächste 100)
df = pd.read_excel('data.xlsx', skiprows=100, nrows=100)

Warum ist read_excel so viel langsamer als read_csv?

Excel-Dateien sind binäre Formate, die komplexes Parsing erfordern, während CSV-Dateien Klartext sind. Für große Datensätze konvertieren Sie Excel zuerst in CSV:

# Einmalige Konvertierung
df = pd.read_excel('large_file.xlsx')
df.to_csv('large_file.csv', index=False)
 
# Zukünftige Lesevorgänge verwenden CSV
df = pd.read_csv('large_file.csv')  # Viel schneller

Wie gehe ich mit verbundenen Zellen in Excel-Dateien um?

Pandas liest den Wert oben links von verbundenen Zellen und füllt den Rest mit NaN. Sie können diese Werte vorwärts füllen:

df = pd.read_excel('data.xlsx')
df['MergedColumn'] = df['MergedColumn'].fillna(method='ffill')

Fazit

Die Funktion pandas read_excel() bietet umfassende Kontrolle über den Import von Excel-Dateien in Python, von einfachen Einzelsheet-Importen bis hin zu komplexen Szenarien mit mehreren Sheets, benutzerdefinierten Datentypen und großer Dateihandhabung. Meistern Sie die Schlüsselparameter – sheet_name, usecols, dtype, parse_dates und skiprows – um Daten effizient und genau zu importieren.

Für die meisten Workflows genügt das grundlegende pd.read_excel('file.xlsx'), aber das Verständnis fortgeschrittener Optionen wie Engine-Auswahl, Konverterfunktionen und Speicheroptimierungstechniken wird kritisch, wenn Sie mit realen Geschäftsdaten arbeiten. Denken Sie daran, die entsprechende Engine zu installieren (openpyxl für .xlsx-Dateien) und erwägen Sie die Konvertierung großer Excel-Dateien in CSV für bessere Leistung.

Die Kombination aus pandas für den Datenimport, PyGWalker für sofortige Visualisierung und RunCell für Debugging schafft einen leistungsstarken Workflow für Excel-Datenanalyse in Python.