# Pandas DataFrame: In Python Tabellen schnell und übersichtlich manipulieren!

Der Pandas DataFrame ist eine Python Datenstruktur, mit der man Tabellen erstellen und manipulieren kann. Wir erklären Ihnen den Aufbau der Datenstruktur sowie ihre wichtigsten Methoden und Eigenschaften.

## Wie funktionieren Pandas DataFrames?

Pandas DataFrames sind das Herzstück der [Python-Pandas](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-pandas/)-Bibliothek und ermöglichen eine effiziente und flexible Datenanalyse in Python. Ein Pandas DataFrame ist eine **zweidimensionale tabellarische Datenstruktur** mit **nummerierten Zeilen und beschrifteten Spalten**. Diese Struktur ermöglicht es, Daten in einer leicht verständlichen und manipulierbaren Form zu organisieren, ähnlich wie bei Tabellenkalkulationsprogrammen wie Excel oder [LibreOffice](https://de.libreoffice.org/ "Zur LibreOffice-Startseite"). Jede Spalte in einem DataFrame kann unterschiedliche [Python-Datentypen](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-data-types/) enthalten, was bedeutet, dass ein DataFrame **heterogene Daten** speichern kann – beispielsweise numerische Werte, Zeichenketten und Booleans in einer einzigen Tabelle.

Tipp Pandas DataFrames basieren auf NumPy-Arrays, was eine effiziente Handhabung von Daten und Berechnung von Werten ermöglicht. Allerdings unterscheiden sich Pandas DataFrames in einigen Punkten von [NumPy](https://numpy.org/ "Zur NumPy-Startseite")-Datenstrukturen, zum Beispiel in Ihrer Heterogenität und Ihrer Anzahl an Dimensionen. Aus diesem Grund eignen sich NumPy-Datenstrukturen für die Manipulation riesiger Mengen an numerischen Werten und Pandas Datenstrukturen eher für die allgemeine Datenmanipulation.

### Aufbau von Pandas DataFrames

Ein DataFrame besteht aus drei Hauptkomponenten: den Daten selbst, den Zeilenindizes und den Spaltennamen. Der Zeilenindex (oder einfach Index) dient als eindeutiger Bezeichner für jede Zeile. Standardmäßig werden Zeilen mit numerischen Werten indexiert, allerdings können diese durch Strings ersetzt werden. Beachten Sie, dass Pandas DataFrames **null-indexiert** sind, also dass die Indizes bei 0 anfangen.

[![Bild: Der Aufbau eines Pandas DataFrames](https://www.ionos.de/digitalguide/fileadmin/_processed_/0/2/csm_pandas-dataframe-aufbau_3c011a76bc.webp "Der Aufbau eines Pandas DataFrames")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Schaubilder/pandas-dataframe-aufbau.png) Pandas DataFrames sind tabellarisch aufgebaut und daher sehr ähnlich zu Excel- oder SQL-Tabellen.  Hinweis Obwohl Pandas DataFrames zu den beliebtesten und nützlichsten Python-Datenstrukturen gehören, sind sie kein offizieller Teil der Basissprache und müssen immer **extra eingebunden** werden. Dies geschieht mittels der Zeile `import pandas` oder `from pandas import DataFrame` am Anfang Ihrer Datei. Alternativ können Sie `import pandas as pd` nutzen, falls Sie das Modul mit einem kürzeren Namen (in diesem Fall „pd“) referenzieren möchten.

## Der Umgang mit Pandas DataFrames

Pandas DataFrames bieten eine Vielzahl von Techniken und Methoden, die es ermöglichen, Daten effizient zu bearbeiten, zu analysieren und zu visualisieren. Im Folgenden lernen Sie einige der wichtigsten Konzepte und Methoden zur Datenmanipulation mit Pandas DataFrames kennen.

### Pandas DataFrame erstellen

Falls Sie Ihre gewünschten Daten schon in einer [Python-Liste](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-list/) oder [Python-Dictionary](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-dictionary/) gespeichert haben, können Sie sehr leicht daraus einen DataFrame erstellen. Dafür müssen Sie nur die existierende Datenstruktur dem DataFrame-Konstruktor `pandas.DataFrame([Daten])` als Argument übergeben. Wie Pandas Ihre Daten interpretiert, hängt allerdings davon ab, welche Datenstruktur Sie dem Konstruktor übergeben. So können Sie aus einer Python-Liste einen Pandas DataFrame erstellen:

```python
import pandas
liste = ["Ahmed", "Beatrice", "Candice", "Donovan", "Elisabeth", "Frank"]
df = pandas.DataFrame(liste)
print(df)
# Ausgabe:
#            0
# 0     Ahmed
# 1      Beatrice
# 2     Candice
# 3    Donovan
# 4    Elisabeth
# 5  Frank
```

Wie Sie im obigen Beispiel sehen können, kann man mit einfachen Listen nur DataFrames mit einer **einzelnen, unbeschrifteten Spalte** erstellen. Aus diesem Grund empfiehlt es sich, DataFrames aus **Dictionarys zu erstellen, die Listen enthalten**. Dabei werden die Schlüssel als Spaltennamen und die Listen als die zugehörigen Daten interpretiert. Das folgende Beispiel dient zur Veranschaulichung:

```python
import pandas
daten = {
    'Name': ['Arthur', 'Bruno', 'Christoph'],
    'Alter': [34, 30, 55],
    'Gehalt': [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(daten)
print(df)
# Ausgabe:
#         Name  Alter   Gehalt
# 0     Arthur     34  75000.0
# 1      Bruno     30  60000.5
# 2  Christoph     55  90000.3
```

Mit dieser Methode hat der DataFrame sofort das erwünschte Format und die erwünschten Überschriften. Falls Sie sich aber nicht auf die eingebauten Python-Datenstrukturen verlassen möchten, können Sie Ihre Daten auch **aus einer externen Quelle laden**, etwa einer CSV-Datei oder einer [SQL](https://www.ionos.de/digitalguide/server/knowhow/was-ist-sql/)-Datenbank. Dafür müssen Sie nur die passende Pandas-Funktion aufrufen:

```python
import pandas
import sqlalchemy
# DataFrame von CSV:
csv = pandas.read_csv("csv-dateien/daten.csv")
# DataFrame von SQL:
engine = create_engine('postgresql://benutzername:passwort@localhost:5432/meine_datenbank')
sql = pandas.read_sql_query('SELECT * FROM tabelle', engine)
```

Die DataFrames `csv` und `sql` aus dem obigen Beispiel enthalten nun jeweils alle Daten aus der Datei `daten.csv` und der SQL-Tabelle `tabelle`. Sie können bei der Erstellung eines DataFrames aus einer externen Quelle auch zusätzliche Details spezifizieren, zum Beispiel ob die numerischen Indizes im DataFrame inkludiert werden sollen oder nicht. Genaueres zu den zusätzlichen Argumenten der beiden Funktionen können Sie auf der [offiziellen Pandas-DataFrame-Dokumentationsseite](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) nachlesen.

Tipp Um einen Pandas DataFrame aus einer SQL-Tabelle zu erstellen, müssen Sie Pandas in Zusammenhang mit einem Python-SQL-Modul wie *SQLAlchemy* verwenden. Bauen Sie mittels Ihres gewählten SQL-Moduls eine Verbindung zur Datenbank auf und übergeben Sie diese an `read_sql_query()`.

### Pandas DataFrames: Daten anzeigen

Mit Pandas DataFrames können Sie sich nicht nur die gesamte Tabelle anzeigen lassen, sondern auch einzelne Zeil und Spalten. Darüber hinaus können Sie aussuchen, welche Zeilen und Spalten Sie sehen möchten. Das folgende Beispiel zeigt, wie Sie sich individuelle oder mehrere Zeilen bzw. Spalten anzeigen lassen können:

```python
# 0-te Zeile ausgeben
print(df.loc[0])
# Zeilen 3 bis 6 ausgeben
print(df.loc[3:6])
# Zeilen 3 und 6 ausgeben
print(df.loc[[3, 6]])
# Spalte „Beruf“ ausgeben
print(df["Beruf"])
# Spalten „Beruf“ und „Alter“ ausgeben
print(df[["Beruf", "Alter"]])
# Auswahl mehrerer Zeilen und Spalten
print(df.loc[[3, 6], ['Beruf', 'Alter']])
```

Wie im Beispiel zu sehen ist, nutzt man beim Referenzieren einer Spalte nur den Spaltennamen in einfachen Klammern, wie bei Python Dictionarys. Dahingegen nutzt man beim Referenzieren einer Zeile immer das Attribut `loc`. Mit `loc` kann man auch logische Bedingungen verwenden, um Daten zu filtrieren. Dies sehen Sie im folgenden Code-Block, in dem nur Zeilen ausgegeben werden, in denen der Wert für „Alter“ größer ist als 30:

```python
print(df.loc[df['Alter'] > 30])
```

Man kann aber auch das Attribut `iloc` nutzen, um Zeilen und Spalten **basierend auf ihrer Position im DataFrame** auszuwählen. So kann man sich beispielsweise die Zelle ausgeben lassen, die sich in der dritten Zeile und der vierten Spalte befindet:

```python
print(df.iloc[3, 4])
# Ausgabe:
# Hamburg
print(df.iloc[[3, 4, 6], 4])
# Ausgabe:
# 3    Hamburg
# 4    München
# 6    Saarbrücken
```

### Pandas DataFrames: Über Zeilen iterieren

Bei der Bearbeitung von Daten in Python muss man sehr häufig über die Zeilen eines Pandas DataFrames iterieren, um beispielsweise dieselbe Operation auf allen Daten anzuwenden. Pandas bietet für diesen Zweck zwei verschiedene DataFrame-Methoden an: `itertuples()` und `iterrows()`. Beide Methoden haben ihre Vorteile und Nachteile hinsichtlich **Performance und Nutzerfreundlichkeit**.

Die Methode `iterrows()` gibt für jede Zeile im DataFrame einen **Tupel aus Index und Series** zurück. Eine Series ist eine weitere Pandas- bzw. NumPy-Datenstruktur, die in vielen Punkten sehr ähnlich zu einer Python-Liste ist, aber bessere Performance bietet. Der Zugriff auf individuelle Elemente in der Series erfolgt mit dem **Spaltennamen**, was den Umgang mit den Daten um einiges erleichtert.

Obwohl Pandas Series wesentlich effizienter sind als Python-Listen, hat diese Datenstruktur immer noch ein gewisses Performance-Overhead. Deshalb ist die Methode `itertuples()` vor allem bei **sehr großen DataFrames** zu empfehlen. Im Gegensatz zu `iterrows()` gibt `itertuples()` die **gesamte Zeile inklusive Index** als Tupel zurück, die wesentlich performanter als Series sind. Bei Tupeln wird mittels eines Punkts auf individuelle Elemente zugegriffen, wie bei Attributen eines Objekts.

Noch ein wichtiger Unterschied zwischen Series und Tupeln ist, dass **Tupel nicht *mutable* (veränderbar) sind**. Will man also mittels `itertuples()` über ein DataFrame iterieren und Werte ändern, muss man mit dem `at`-Attribut und dem Index des Tupels den DataFrame referenzieren. Dieses Attribut funktioniert sehr ähnlich wie `loc`. Folgendes Beispiel dient zur Veranschaulichung der Unterschiede zwischen `iterrows()` und `itertuples()`:

```python
import pandas
df = pandas.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Alter': [25, 30, 35],
    'Gehalt': [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Gehalt'] += 1000
        print(f"Index: {index}, Alter: {row['Alter']}, Gehalt: {row['Gehalt']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Gehalt'] += 1000 # Wert mittels at[] direkt im DataFrame ändern
        print(f"Index: {tup.Index}, Alter: {tup.Alter}, Gehalt: {df.loc[tup.Index, 'Gehalt']}")
# Beide Schleifen haben dieselbe Ausgabe
```


This is a markdown version of: [https://www.ionos.de/digitalguide/websites/web-entwicklung/python-pandas-dataframe/](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-pandas-dataframe/) for AI/LLM consumption.