Sollten Sie einen Fehler beim Laden der Pandas Bibliothek erhalten, installieren Sie diese bitte mit dem folgenden Befehl:

!pip install pandas

Alternativ können Sie Pandas auch über die Anaconda-Distribution installieren. Eine Anleitung wie man Bibliotheken in Python über Anaconda installiert finden Sie hier.

# Importieren der Pandas Bibliothek
import pandas as pd

# Erstellen eines DataFrames
df = pd.DataFrame(data=[["Anna", 28, "Berlin"],
                        ["Ben", 32, "Hamburg"],
                        ["Chris", 25, "München"]], 
                  columns=["Name","Alter", "Stadt"])

print(df)

Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.
Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.
    Name  Alter    Stadt
0   Anna     28   Berlin
1    Ben     32  Hamburg
2  Chris     25  München

Ein DataFrame ist eine zweidimensionale Datenstruktur, ähnlich wie eine Tabelle in einer relationalen Datenbank oder eine Excel-Tabelle. Es besteht aus Zeilen und Spalten, wobei jede Spalte einen bestimmten Datentyp (int, float, str usw.) haben kann.

Ein DataFrame ist das zentrale Element der Pandas-Bibliothek und wird häufig für Datenmanipulation und Datenanalyse verwendet. Es ermöglicht eine effiziente Speicherung und Manipulation von strukturierten Daten und bietet Funktionen zum schnellen Überblick, zum Filtern nach Bedingungen und zur Berechnung von Statistiken.

Um einen DataFrame in Pandas zu erstellen, müssen wir zuerst die Pandas-Bibliothek importieren. Dies geschieht mit dem Befehl import pandas as pd. Die Abkürzung pd ist eine Konvention und ermöglicht es uns, auf die Funktionen von Pandas zuzugreifen, indem wir pd statt pandas schreiben.

# Importieren der Pandas-Bibliothek
import pandas as pd

Es gibt verschiedene Möglichkeiten, einen DataFrame zu erstellen. Eine der einfachsten ist die Verwendung einer Liste von Listen, wobei jede innere Liste eine Zeile im DataFrame repräsentiert.

# Erstellen eines DataFrame aus einer Liste von Listen
data = [['Alex', 10], ['Bob', 12], ['Clarke', 13]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)

In diesem Beispiel erstellen wir einen DataFrame mit den Spalten 'Name' und 'Age'. Jede innere Liste in der Liste data wird zu einer Zeile im DataFrame.

Eine weitere Möglichkeit, einen DataFrame zu erstellen, ist die Verwendung eines Dictionaries. Die Schlüssel des Dictionaries werden zu den Spaltennamen und die Werte zu den Daten in den Spalten.

# Erstellen eines DataFrame aus einem Dictionary
data = {'Name': ['Tom', 'Nick', 'John'], 'Age': [20, 21, 19]}
df = pd.DataFrame(data)
print(df)

In diesem Beispiel erstellen wir einen DataFrame mit den gleichen Spalten 'Name' und 'Age', aber diesmal aus einem Dictionary.

Es ist auch möglich, einen DataFrame aus einer externen Datei zu erstellen, wie einer CSV-Datei oder einer Excel-Datei. Dazu verwenden wir die Funktionen pd.read_csv() oder pd.read_excel().

# Erstellen eines DataFrame aus einer CSV-Datei
df = pd.read_csv('file.csv')
print(df)

In diesem Beispiel lesen wir eine CSV-Datei und erstellen einen DataFrame aus ihren Daten. Der Pfad zur Datei kann relativ zum aktuellen Arbeitsverzeichnis oder absolut sein.

Zusammenfassend lässt sich sagen, dass das Erstellen eines DataFrame in Pandas ein grundlegender Schritt in der Datenanalyse ist. Es gibt verschiedene Möglichkeiten, einen DataFrame zu erstellen, je nachdem, woher die Daten kommen und in welchem Format sie vorliegen.

# Importieren der Pandas-Bibliothek
import pandas as pd

# Erstellen eines DataFrame aus einer Liste von Listen
data = [['Alex', 10], ['Bob', 12], ['Clarke', 13]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)

     Name  Age
0    Alex   10
1     Bob   12
2  Clarke   13

# Erstellen eines DataFrame aus einem Dictionary
data = {'Name': ['Tom', 'Nick', 'John'], 'Age': [20, 21, 19]}
df = pd.DataFrame(data)
print(df)

   Name  Age
0   Tom   20
1  Nick   21
2  John   19

# Erstellen eines DataFrame aus einer CSV-Datei
df = pd.read_csv('file.csv')
print(df)

  StudentIn   Note  Bestanden
0       Max    1.3       True
1      Lena    1.3       True
2     Peter    4.0       True
3      Hans    5.0      False

Erstellen Sie einen DataFrame aus dem folgenden Dictionary. Die Schlüssel sollen die Spaltennamen und die Werte die Daten in den Spalten sein.

autos = {'Marke': ['VW', 'BMW', 'Mercedes', 'Audi'], 'Modell': ['Golf', '3er', 'C-Klasse', 'A4'], 'Preis': [20000, 30000, 40000, 35000]}

# Musterlösung

# Importieren der Pandas-Bibliothek
import pandas as pd

# Dictionary
autos = {}

# Erstellen eines DataFrame aus dem Dictionary
df = pd.DataFrame(autos)

# Ausgabe des DataFrame
print(df)

      Marke    Modell  Preis
0        VW      Golf  20000
1       BMW       3er  30000
2  Mercedes  C-Klasse  40000
3      Audi        A4  35000

Es gibt verschiedene Methoden, um auf Daten in einem DataFrame zuzugreifen. Eine der einfachsten Methoden ist die direkte Auswahl einer Spalte durch ihren Namen. Angenommen, wir haben einen DataFrame df, der eine Spalte namens "A" enthält. Dann können wir auf diese Spalte zugreifen, indem wir df['A'] schreiben.

import pandas as pd

# DataFrame erstellen
data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}
df = pd.DataFrame(data)

# Zugriff auf Spalte 'A'
print(df['A'])

Pandas bietet zwei leistungsfähige Methoden zur Datenabfrage und -selektion: loc und iloc.

• loc: Diese Methode wird verwendet, um auf einen Datensatz durch seinen Label-basierten Index zuzugreifen. Sie ermöglicht auch die Auswahl von Daten basierend auf booleschen Bedingungen.

# Zugriff auf die erste Zeile mit loc
print(df.loc[0])

• iloc: Diese Methode ermöglicht den Zugriff auf einen Datensatz durch seinen integer-basierten Index, unabhängig von den Labels.

# Zugriff auf die erste Zeile mit iloc
print(df.iloc[0])

df = pd.DataFrame(data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]},
                  index = ["eins", "zwei", "drei"])

print(df)

print("-"*10)

print(df.loc["eins"])

print("-"*10)

print(df.iloc[0])

      A  B  C
eins  1  4  7
zwei  2  5  8
drei  3  6  9
----------
A    1
B    4
C    7
Name: eins, dtype: int64
----------
A    1
B    4
C    7
Name: eins, dtype: int64

Mit loc und iloc können wir auch zeilen- und spaltenbasierte Selektionen durchführen. Angenommen, wir möchten die erste Zeile und die erste Spalte unseres DataFrames auswählen. Mit loc würden wir schreiben df.loc[0, 'A'] und mit iloc df.iloc[0, 0].

# Zeilen- und spaltenbasierte Selektion mit loc
print(df.loc[0, 'A'])

# Zeilen- und spaltenbasierte Selektion mit iloc
print(df.iloc[0, 0])

df = pd.DataFrame(data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]},
                  index = ["eins", "zwei", "drei"])

print(df)

print("-"*10)

print(df.loc["eins", "A"])

print("-"*10)

print(df.iloc[0, 0])

      A  B  C
eins  1  4  7
zwei  2  5  8
drei  3  6  9
----------
1
----------
1

Erstellen Sie einen DataFrame mit den Namen und Alter von fünf Personen. Der DataFrame sollte zwei Spalten ("Name" und "Alter") und fünf Zeilen haben. Greifen Sie dann auf die Spalte "Alter" zu und zeigen Sie das Alter der dritten Person an.

# Musterlösung

import pandas as pd

# DataFrame erstellen
data = 
df = pd.DataFrame(data)

# Zugriff auf Spalte 'Alter'
print(df['Alter'])

# Alter der dritten Person anzeigen
print(df.loc[])

0    23
1    25
2    22
3    24
4    26
Name: Alter, dtype: int64
22

​## Manipulation von DataFrame-Daten

• Hinzufügen von Spalten: Neue Spalten können durch Zuweisung eines neuen Spaltennamens und eines Wertes oder einer Liste von Werten hinzugefügt werden.
• Entfernen von Spalten: Die Methode drop() wird verwendet, um Spalten zu entfernen. Sie benötigt den Namen der Spalte und die Achseninformation (axis=1 für Spalten).
• Modifizieren von Spalten: Spalten können direkt überschrieben oder durch eine Funktion verändert werden.
• Hinzufügen von Zeilen: Die Methode append() wird verwendet, um Zeilen hinzuzufügen.
• Entfernen von Zeilen: Die Methode drop() wird verwendet, um Zeilen zu entfernen. Sie benötigt den Index der Zeile und die Achseninformation (axis=0 für Zeilen).
• Umstrukturieren von Daten: Funktionen wie pivot(), melt(), stack() und unstack() ermöglichen das Umstrukturieren von Daten in verschiedene Formate.
• Wichtigkeit der Datenmanipulation: Die Kenntnis dieser Methoden ist essentiell, um Daten effektiv für die Analyse vorzubereiten.

Pandas DataFrames sind äußerst flexibel und erlauben eine Vielzahl von Manipulationen. Diese Manipulationen sind essentiell, um Daten in die gewünschte Form zu bringen, bevor sie analysiert werden. In diesem Abschnitt werden wir uns auf das Hinzufügen, Entfernen und Modifizieren von Spalten und Zeilen in einem DataFrame konzentrieren. Darüber hinaus werden wir auch das Umstrukturieren von Datenstrukturen behandeln.

Hinzufügen von Spalten

Das Hinzufügen von Spalten zu einem DataFrame ist einfach und intuitiv. Sie können eine neue Spalte hinzufügen, indem Sie einen neuen Spaltennamen als Index verwenden und ihm einen Wert oder eine Liste von Werten zuweisen.

import pandas as pd

# DataFrame erstellen
df = pd.DataFrame({
   'A': [1, 2, 3],
   'B': [4, 5, 6]
})

# Neue Spalte hinzufügen
df['C'] = [7, 8, 9]

print(df)

Das Entfernen von Spalten ist ebenso einfach. Die Methode drop() kann verwendet werden, um Spalten zu entfernen. Sie benötigen den Namen der Spalte und die Achseninformation (axis=1 für Spalten).

# Spalte entfernen
df = df.drop('C', axis=1)

print(df)

# DataFrame erstellen
df = pd.DataFrame({
   'A': [1, 2, 3],
   'B': [4, 5, 6],
   'C': [7, 8, 9]
})

# Spalte C entfernen
df = df.drop("C", axis = 1)

df

   A  B
0  1  4
1  2  5
2  3  6

# Alternativ inplace Bearbeitung des DataFrames
df.drop("B", axis = 1, inplace = True)
df

   A
0  1
1  2
2  3

Spalten können auch modifiziert werden, indem sie direkt überschrieben oder durch eine Funktion verändert werden.

# Spalte modifizieren
df['A'] = df['A'] * 2

print(df)

# DataFrame erstellen
df = pd.DataFrame({
   'A': [1, 2, 3],
   'B': [4, 5, 6],
   'C': [7, 8, 9]
})

# Spalte modifizieren
df['A'] = df['A'] * 2

df

   A  B  C
0  2  4  7
1  4  5  8
2  6  6  9

Zeilen können mit der Methode append() hinzugefügt werden. Um Zeilen zu entfernen, verwenden Sie die Methode drop() mit dem Index der Zeile und der Achseninformation (axis=0 für Zeilen).

# Zeile hinzufügen
new_row = pd.Series([10, 11], index=['A', 'B'])
df = df.append(new_row, ignore_index=True)

# Zeile entfernen
df = df.drop(2, axis=0)

print(df)

# DataFrame erstellen
df = pd.DataFrame({
   'A': [1, 2, 3],
   'B': [4, 5, 6],
   'C': [7, 8, 9]
})

# Zeile entfernen
df = df.drop(2, axis=0)

df

   A  B  C
0  1  4  7
1  2  5  8

Pandas bietet auch Funktionen zum Umstrukturieren von Daten, wie pivot() für die Erstellung einer Pivot-Tabelle, melt() zum Umwandeln von Spalten in Zeilen und stack()=/=unstack() zum Stapeln oder Entstapeln von Daten.

# Pivot-Tabelle erstellen
pivot_df = df.pivot(index='A', columns='B', values='C')

print(pivot_df)

# Beispiel DataFrame erstellen
df = pd.DataFrame({
    'Date': ['2021-01-01', '2021-01-01', '2021-01-02', '2021-01-02'],
    'Product': ['A', 'B', 'A', 'B'],
    'Sales': [10, 15, 20, 25]
})

print(df)

print("-"*10)

# Pivot-Tabelle erstellen
pivot_df = df.pivot(index='Date', columns='Product', values='Sales')

print(pivot_df)

         Date Product  Sales
0  2021-01-01       A     10
1  2021-01-01       B     15
2  2021-01-02       A     20
3  2021-01-02       B     25
----------
Product      A   B
Date              
2021-01-01  10  15
2021-01-02  20  25

Erstellen Sie einen DataFrame mit den Namen und Alter von fünf Personen. Fügen Sie eine Spalte hinzu, die das Alter in Monaten anzeigt. Entfernen Sie anschließend die Spalte mit dem Alter in Jahren.

import pandas as pd

# DataFrame erstellen
df = pd.DataFrame({
   'Name': ['Anna', 'Ben', 'Chris', 'Diana', 'Eli'],
   'Alter': [25, 30, 35, 40, 45]
})

# Spalte hinzufügen
df['Alter_in_Monaten'] = 

# Spalte entfernen
df = 

print(df)

    Name  Alter  Alter_in_Monaten Käsekuchen
0   Anna     25               300       Käse
1    Ben     30               360       Käse
2  Chris     35               420       Käse
3  Diana     40               480       Käse
4    Eli     45               540       Käse

​## Filtern und Sortieren von Daten

• Filtern von Daten: Auswahl spezifischer Daten aus einem DataFrame, die bestimmten Kriterien entsprechen.

  • Bedingte Abfragen in Pandas ermöglichen das Filtern von Daten.
  • Beispiel: Auswahl aller Personen in einem DataFrame, die älter als 20 Jahre sind.

• Sortieren von Daten: Anzeige der Daten in einer bestimmten Reihenfolge.

  • Die Methode sort_values() in Pandas ermöglicht das Sortieren eines DataFrame nach einer oder mehreren Spalten.
  • Daten können in aufsteigender oder absteigender Reihenfolge sortiert werden.

• Wichtigkeit des Filterns und Sortierens: Beide Operationen sind wesentliche Bestandteile der Datenanalyse.

  • Filtern ermöglicht die Extraktion spezifischer Daten.
  • Sortieren ermöglicht die Anzeige der Daten in einer sinnvollen Reihenfolge.
  • Pandas bietet effiziente und einfache Methoden für beide Aufgaben

Das Filtern von Daten ermöglicht es uns, spezifische Daten aus einem DataFrame auszuwählen, die bestimmten Kriterien entsprechen. In Pandas können wir dies durch bedingte Abfragen erreichen.

Angenommen, wir haben einen DataFrame df mit den Spalten 'Name', 'Alter' und 'Stadt'. Wenn wir nur die Daten der Personen anzeigen möchten, die älter als 20 Jahre sind, können wir die folgende bedingte Abfrage verwenden:

df_filtered = df[df['Alter'] > 20]
print(df_filtered)

In diesem Code erstellen wir einen neuen DataFrame df_filtered, der nur die Zeilen aus df enthält, bei denen das Alter größer als 20 ist.

data = {"Name":["Alice","Bob"],
       "Alter":[23,32],
       "Stadt":["Berlin","Köln"]}

df = pd.DataFrame(data)

print(df)

print("-"*10)

df_filtered = df[df["Alter"] > 25]

print(df_filtered)

    Name  Alter   Stadt
0  Alice     23  Berlin
1    Bob     32    Köln
----------
  Name  Alter Stadt
1  Bob     32  Köln

Das Sortieren von Daten ist eine weitere wichtige Funktion, die es uns ermöglicht, die Daten in einer bestimmten Reihenfolge anzuzeigen. In Pandas können wir die Methode sort_values() verwenden, um einen DataFrame nach einer oder mehreren Spalten zu sortieren.

Angenommen, wir möchten unseren DataFrame df nach dem Alter in aufsteigender Reihenfolge sortieren. Wir können dies mit dem folgenden Code erreichen:

df_sorted = df.sort_values('Alter')
print(df_sorted)

In diesem Code erstellen wir einen neuen DataFrame df_sorted, der alle Zeilen aus df enthält, sortiert nach dem Alter in aufsteigender Reihenfolge.

Es ist auch möglich, die Daten in absteigender Reihenfolge zu sortieren, indem wir den Parameter ascending=False setzen:

df_sorted_desc = df.sort_values('Alter', ascending=False)
print(df_sorted_desc)

In diesem Code erstellen wir einen neuen DataFrame df_sorted_desc, der alle Zeilen aus df enthält, sortiert nach dem Alter in absteigender Reihenfolge.

data = {"Name":["Alice","Bob"],
       "Alter":[23,32],
       "Stadt":["Berlin","Köln"]}

df = pd.DataFrame(data)

print(df)

print("-"*10)

df_sorted = df.sort_values('Alter', ascending=False)

print(df_sorted)

    Name  Alter   Stadt
0  Alice     23  Berlin
1    Bob     32    Köln
----------
    Name  Alter   Stadt
1    Bob     32    Köln
0  Alice     23  Berlin

Erstellen Sie einen DataFrame mit den folgenden Daten und filtern Sie alle Zeilen heraus, in denen der Preis über 20 liegt. Sortieren Sie dann absteigend und geben sie das DataFrame aus.

# Importieren der Pandas Bibliothek
import pandas as pd

# Erstellen des DataFrames
df = pd.DataFrame({
    'Produkt': [],
    'Preis': []
})

# Filtern der Zeilen, in denen der Preis über 20 liegt
df_filtered = 

# Sortieren, absteigend nach Preis
df_sorted = 

# Ausgabe des DateFrames
print(df_sorted)

   Produkt  Preis
3   Dattel     30
2  Kirsche     25
4    Birne     22

Pandas stellt eine Reihe von Methoden zur Verfügung, um grundlegende statistische Analysen auf einem DataFrame durchzuführen. Dazu gehören Funktionen zur Berechnung des Durchschnitts (mean()), des Medians (median()), der Summe (sum()), des Maximums (max()) und des Minimums (min()). Diese Funktionen können auf das gesamte DataFrame oder auf einzelne Spalten angewendet werden.

Angenommen, wir haben den folgenden DataFrame:

import pandas as pd

# DataFrame erstellen
df = pd.DataFrame({
    "Alter": [23, 24, 22, 25, 27, 23, 25, 24],
    "Gehalt": [3500, 4000, 3000, 4500, 4000, 3500, 4000, 4500]
})

print(df)

Wir können die durchschnittlichen Werte für jede Spalte berechnen, indem wir die mean() Funktion verwenden:

# Durchschnitt berechnen
durchschnitt = df.mean()
print(durchschnitt)

import pandas as pd

# DataFrame erstellen
df = pd.DataFrame({
    "Alter": [23, 24, 22, 25, 27, 23, 25, 24],
    "Gehalt": [3500, 4000, 3000, 4500, 4000, 3500, 4000, 4500]
})

# Durchschnitt berechnen
durchschnitt = df.mean()
print(durchschnitt)

Alter       24.125
Gehalt    3875.000
dtype: float64

# Maximum berechnen
maximum = df.max()
print(maximum)

Alter       27
Gehalt    4500
dtype: int64

# Minimum berechen
minimum = df.min()
print(minimum)

Alter       22
Gehalt    3000
dtype: int64

# Summe berechnen
summe = df.sum()
print(summe)

Alter       193
Gehalt    31000
dtype: int64

Ein weiterer wichtiger Aspekt der statistischen Analyse ist das Gruppieren und Aggregieren von Daten. Mit der groupby() Funktion in Pandas können wir Daten basierend auf bestimmten Kriterien gruppieren und dann Aggregationsfunktionen auf diese Gruppen anwenden.

Angenommen, wir haben einen zusätzlichen DataFrame, der die Abteilung für jeden Mitarbeiter enthält:

# DataFrame erstellen
df = pd.DataFrame({
    "Abteilung": ["Marketing", "Vertrieb", "Marketing", "Vertrieb", "Marketing", "Vertrieb", "Marketing", "Vertrieb"],
    "Alter": [23, 24, 22, 25, 27, 23, 25, 24],
    "Gehalt": [3500, 4000, 3000, 4500, 4000, 3500, 4000, 4500]
})

print(df)

Wir können die Daten nach Abteilung gruppieren und das durchschnittliche Gehalt in jeder Abteilung berechnen:

# Daten gruppieren und Durchschnitt berechnen
gruppierte_daten = df.groupby("Abteilung").mean()
print(gruppierte_daten)

Erstellen Sie einen DataFrame mit den folgenden Daten:

Namen = ['Anna', 'Ben', 'Carla', 'Daniel', 'Eva', 'Frank']
Alter = [23, 24, 22, 25, 27, 23]
Gehalt = [3500, 4000, 3000, 4500, 4000, 3500]
Abteilung = ['Marketing', 'Vertrieb', 'Marketing', 'Vertrieb', 'Marketing', 'Vertrieb']

Berechnen Sie das Durchschnittsalter und das durchschnittliche Gehalt aller Mitarbeiter. Berechnen Sie die Werte auch je Abteilung.

import pandas as pd

# Daten erstellen
data = 

# DataFrame erstellen
df = pd.DataFrame(data)

# Durchschnittsalter und durchschnittliches Gehalt berechnen
durchschnitt_alter = 
durchschnitt_gehalt = 

print("Durchschnittsalter: ", durchschnitt_alter)
print("Durchschnittsgehalt: ", durchschnitt_gehalt)

Durchschnittsalter:  27.5
Durchschnittsgehalt:  3750.0

# Dataframe nach Abteilung aggregieren

df_abt = 

# Durchschnittsalter und durchschnittliches Gehalt berechnen
durchschnitt_alter_abt = df_abt['Alter'].mean()
durchschnitt_gehalt_abt = df_abt['Gehalt'].mean()

print("Durchschnittsalter: ", durchschnitt_alter_abt)
print("Durchschnittsgehalt: ", durchschnitt_gehalt_abt)

Durchschnittsalter:  Abteilung
Marketing    31.0
Vertrieb     24.0
Name: Alter, dtype: float64
Durchschnittsgehalt:  Abteilung
Marketing    3500.0
Vertrieb     4000.0
Name: Gehalt, dtype: float64

In der realen Welt sind Daten oft unvollständig oder fehlerhaft. Pandas bietet mehrere Funktionen, um mit fehlenden Daten umzugehen. Die Funktionen isnull() und notnull() können verwendet werden, um zu überprüfen, ob in einem DataFrame fehlende Werte vorhanden sind.

import pandas as pd
import numpy as np

# Erstellen eines DataFrame mit fehlenden Werten
df = pd.DataFrame({'A': [1, 2, np.nan],
                   'B': [5, np.nan, np.nan],
                   'C': [1, 2, 3]})

print(df.isnull())  # Gibt einen DataFrame mit Booleans zurück, die anzeigen, wo die Werte fehlen

Die Funktion dropna() kann verwendet werden, um Zeilen oder Spalten mit fehlenden Werten zu entfernen, während die Funktion fillna() verwendet werden kann, um fehlende Werte durch einen bestimmten Wert zu ersetzen.

print(df.dropna())  # Entfernt alle Zeilen mit fehlenden Werten
print(df.fillna(value='FILL VALUE'))  # Ersetzt alle fehlenden Werte durch 'FILL VALUE'

Pandas wurde ursprünglich für die Finanzindustrie entwickelt, daher bietet es umfangreiche Funktionen für die Arbeit mit Zeitreihendaten. Mit Pandas können Sie Daten resampeln, um sie in eine andere Frequenz umzuwandeln (z.B. von täglich zu monatlich), Zeitstempel erstellen und mit Zeitzonen arbeiten.

# Erstellen eines Datumsbereichs
dates = pd.date_range('20200101', periods=6)

# Erstellen eines DataFrame mit den Daten als Index
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))

print(df)

Pandas ermöglicht es Ihnen, bedingte Operationen auf DataFrames durchzuführen, ähnlich wie Sie es in Excel tun würden. Sie können beispielsweise eine neue Spalte erstellen, die auf den Werten anderer Spalten basiert.

# Erstellen eines DataFrame
df = pd.DataFrame({'A': [1, 2, 3, 4],
                   'B': [10, 20, 30, 40],
                   'C': ['Apple', 'Banana', 'Cherry', 'Date']})

# Erstellen einer neuen Spalte basierend auf einer Bedingung
df['D'] = np.where(df['A'] > 2, 'large', 'small')

print(df)

Erstellen Sie einen einfachen Plot der die Form eines W hat. Verwenden Sie die Funktionen plot() und show() von Matplotlib.

Erstellen Sie eine Figure mit 4 Subplots (2x2) und fügen Sie jedem Subplot einen Titel hinzu. Verwenden Sie die Funktion plt.subplots() um die Figure und die Axes zu erstellen. Verwenden Sie die Funktion ax.set_title() um den Titel zu setzen.

Sollten Ihre Title in die Axes hineinragen, können Sie die Methode tight_layout() auf Ihr Figure Objekt anwenden (bspw. fig.tight_layout()).

Ein Linienplot ist eine der einfachsten Arten von Plots, die Sie erstellen können. Es ist besonders nützlich, um Trends über die Zeit darzustellen. Hier ist ein einfaches Beispiel, wie man einen Linienplot erstellt:

import matplotlib.pyplot as plt

# Daten für die x- und y-Achse
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# Erstellen des Plots
plt.plot(x, y)

# Anzeigen des Plots
plt.show()

In diesem Code erstellen wir zuerst Daten für die x- und y-Achse. Dann verwenden wir die Funktion plot() von Matplotlib, um einen Linienplot zu erstellen. Schließlich verwenden wir show(), um den Plot anzuzeigen.

import matplotlib.pyplot as plt

# Daten für die x- und y-Achse
x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

# Erstellen des Plots
plt.plot(x, y)

# Anzeigen des Plots
plt.show()

Ein Balkendiagramm ist nützlich, um kategoriale Daten darzustellen. Hier ist ein einfaches Beispiel, wie man ein Balkendiagramm erstellt:

import matplotlib.pyplot as plt

# Daten für die x- und y-Achse
x = ['A', 'B', 'C', 'D', 'E']
y = [3, 7, 2, 5, 8]

# Erstellen des Plots
plt.bar(x, y)

# Anzeigen des Plots
plt.show()

In diesem Code erstellen wir zuerst Daten für die x- und y-Achse. Dann verwenden wir die Funktion bar() von Matplotlib, um ein Balkendiagramm zu erstellen. Schließlich verwenden wir show(), um den Plot anzuzeigen.

import matplotlib.pyplot as plt

# Daten für die x- und y-Achse
x = ['A', 'B', 'C', 'D', 'E']
y = [3, 7, 2, 5, 8]

# Erstellen des Plots
plt.bar(x, y)

# Anzeigen des Plots
plt.show()

Die Achsen eines Plots definieren den Bereich der Daten, der dargestellt wird. Manchmal möchten wir vielleicht den Bereich der Achsen anpassen, um bestimmte Aspekte unserer Daten hervorzuheben. Mit Matplotlib können wir die Funktionen xlim() und ylim() verwenden, um die Grenzen der x- und y-Achsen einzustellen.

import matplotlib.pyplot as plt
import numpy as np

# Daten generieren
x = np.linspace(0, 6, 100) # 100 Werte von 0 bis 6 generieren
y = np.sin(x) # Sinus-Funktion

# Plot erstellen
plt.plot(x, y)

# Achsen anpassen
plt.xlim(-1, 7)
plt.ylim(-1.5, 1.5)

# Plot anzeigen
plt.show()

In diesem Beispiel haben wir den Bereich der x-Achse auf -1 bis 7 und den der y-Achse auf -1.5 bis 1.5 beschränkt.

import matplotlib.pyplot as plt
import numpy as np

# Daten generieren
x = np.linspace(0, 6, 100) # 100 Werte von 0 bis 6 generieren
y = np.sin(x) # Sinus-Funktion

# Plot erstellen
plt.plot(x, y)

# Achsen anpassen
plt.xlim(-1, 7)
plt.ylim(-1.5, 1.5)

# Plot anzeigen
plt.show()

Beschriftungen sind ein wichtiger Bestandteil einer Datenvisualisierung, da sie den Betrachtern helfen, die dargestellten Daten zu verstehen. Matplotlib bietet Funktionen zum Hinzufügen von Titeln (title()), Achsenlabels (xlabel() und ylabel()) und Legenden (legend()).

# Daten generieren
x = np.linspace(0, 6, 100) # 100 Werte von 0 bis 6 generieren
y = np.sin(x) # Sinus-Funktion

# Plot erstellen
plt.plot(x, y)

# Achsen anpassen
plt.xlim(-1, 7)
plt.ylim(-1.5, 1.5)

# Beschriftungen hinzufügen
plt.title('Sinusfunktion')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.legend()

# Plot anzeigen
plt.show()

In diesem Beispiel haben wir einen Titel, Achsenlabels und eine Legende zu unserem Plot hinzugefügt. Die Legende verwendet das Label, das wir beim Erstellen des Plots angegeben haben.

# Daten generieren
x = np.linspace(0, 6, 100) # 100 Werte von 0 bis 6 generieren
y = np.sin(x) # Sinus-Funktion

# Plot erstellen
plt.plot(x, y)

# Achsen anpassen
plt.xlim(-1, 7)
plt.ylim(-1.5, 1.5)

# Beschriftungen hinzufügen
plt.title('Sinusfunktion') # Titel
plt.xlabel('x') # Beschriftung x-Achse
plt.ylabel('sin(x)') # Beschriftung y-Achse
plt.legend(['sin(x)']) # Legende

# Plot anzeigen
plt.show()

Ein Histogramm ist ein Diagramm, das die Häufigkeitsverteilung eines Datensatzes darstellt. Es ist ein effektives Werkzeug, um die Verteilung von Daten zu visualisieren. In Matplotlib können wir die Funktion hist() verwenden, um ein Histogramm zu erstellen.

import matplotlib.pyplot as plt
import numpy as np

# Erstellen Sie zufällige Daten
data = np.random.randn(1000)

# Erstellen Sie ein Histogramm
plt.hist(data, bins=30, alpha=0.5, color='g')
plt.show()

In diesem Code erstellen wir zunächst einen Datensatz mit 1000 zufälligen Werten. Dann verwenden wir die Funktion hist(), um ein Histogramm zu erstellen. Der Parameter bins bestimmt die Anzahl der Intervalle, in die die Daten aufgeteilt werden, und alpha bestimmt die Transparenz der Balken.

# Histogramm erstellen

# Erstellen Sie zufällige Daten
data = np.random.randn(1000)

# Erstellen Sie ein Histogramm
plt.hist(data, bins=30, alpha=0.5, color='g')
plt.show()

Ein Scatter-Plot ist ein Diagramm, das Punkte auf einem Koordinatensystem darstellt. Es ist nützlich, um die Beziehung zwischen zwei Variablen zu visualisieren. In Matplotlib können wir die Funktion scatter() verwenden, um ein Scatter-Plot zu erstellen.

# Erstellen Sie zufällige Daten
x = np.random.randn(100)
y = np.random.randn(100)

# Erstellen Sie ein Scatter-Plot
plt.scatter(x, y, alpha=0.5)
plt.show()

In diesem Code erstellen wir zwei Datensätze x und y mit jeweils 100 zufälligen Werten. Dann verwenden wir die Funktion scatter(), um ein Scatter-Plot zu erstellen.

# Scatter Plot erstellen

# Erstellen Sie zufällige Daten
x = np.random.randn(100)
y = np.random.randn(100)

# Erstellen Sie ein Scatter-Plot
plt.scatter(x, y, alpha=0.5)
plt.show()

Erstellen Sie ein Histogramm für einen Datensatz, der 5000 zufällige Werte enthält. Verwenden Sie 50 Balken (bins) und stellen Sie das Histogramm in der Farbe Blau dar.

Nutzen Sie für die Datengenerierung die Methode randn() aus np.random np.random.randn() und übergeben Sie die Anzal der Werte als Parameter.

Erstellen Sie ein Scatter-Plot für zwei Datensätze, die jeweils 200 zufällige Werte enthalten. Stellen Sie die Punkte in der Farbe Rot dar.

Nutzen Sie für die Datengenerierung die Methode randn() aus np.random np.random.randn() und übergeben Sie die Anzal der Werte als Parameter.

Pandas DataFrames haben eine eingebaute plot() Funktion, die eine einfache Schnittstelle zur Erstellung von Diagrammen bietet. Die plot() Funktion ist eine Wrapper-Funktion um die Matplotlib pyplot.plot() Funktion, die eine flexible Schnittstelle für die Erstellung aller Arten von Plots bietet.

Hier ist ein einfaches Beispiel, wie man ein Liniendiagramm aus einem DataFrame erstellt:

import pandas as pd
import matplotlib.pyplot as plt

# Erstellen eines einfachen DataFrame
data = {'Jahr': [2015, 2016, 2017, 2018, 2019],
        'Verkauf': [200, 250, 330, 350, 370]}
df = pd.DataFrame(data)

# Erstellen eines Liniendiagramms
df.plot(x='Jahr', y='Verkauf', kind='line')
plt.show()

In diesem Beispiel erstellen wir zuerst einen DataFrame mit zwei Spalten: 'Jahr' und 'Verkauf'. Dann rufen wir die plot() Funktion auf dem DataFrame auf und geben die Spaltennamen für die x- und y-Achsen an. Der Parameter kind bestimmt den Typ des Diagramms, in diesem Fall ein Liniendiagramm.

import pandas as pd
import matplotlib.pyplot as plt

# Erstellen eines einfachen DataFrame
data = {'Jahr': [2015, 2016, 2017, 2018, 2019],
        'Verkauf': [200, 250, 330, 350, 370]}
df = pd.DataFrame(data)

# Erstellen eines Liniendiagramms
df.plot(x='Jahr', y='Verkauf', kind='line')
plt.show()

Die plot() Funktion bietet viele Optionen zur Anpassung des Aussehens des Diagramms. Wir können zum Beispiel die Farbe und den Stil der Linie ändern, Gitterlinien hinzufügen und die Achsenbeschriftungen anpassen.

# Anpassen des Diagramms
df.plot(x='Jahr', y='Verkauf', kind='line', color='red', linestyle='--', grid=True)
plt.title('Verkauf über die Jahre')
plt.xlabel('Jahr')
plt.ylabel('Verkauf')
plt.show()

In diesem Beispiel haben wir die Farbe der Linie auf Rot und den Linienstil auf gestrichelt geändert. Wir haben auch Gitterlinien hinzugefügt und die Achsenbeschriftungen mit den Funktionen title(), xlabel() und ylabel() von Matplotlib eingestellt.

df.plot(x='Jahr', y='Verkauf', kind='line', color='red', linestyle='--', grid=True)
plt.title('Verkauf über die Jahre')
plt.xlabel('Jahr')
plt.ylabel('Verkauf')
plt.show()

Die Farbe ist ein wichtiger Aspekt bei der Gestaltung von Plots. Sie kann verwendet werden, um unterschiedliche Kategorien von Daten zu unterscheiden, die Aufmerksamkeit auf bestimmte Datenpunkte zu lenken oder einfach nur um den Plot ästhetisch ansprechender zu machen. In Matplotlib können wir die Farbe von fast jedem Element eines Plots ändern, einschließlich Linien, Balken, Hintergrund, Text usw.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y, color='red')  # Ändert die Farbe der Linie in Rot
plt.show()

Neben der Farbe können wir auch den Stil der Linien in einem Plot ändern. Matplotlib bietet verschiedene Linienstile, einschließlich durchgezogener, gestrichelter, gepunkteter Linien und mehr.

plt.plot(x, y, linestyle='--')  # Ändert den Linienstil in gestrichelt
plt.show()

Die Schriftart von Textelementen in einem Plot, wie Titel, Achsenbeschriftungen und Legenden, kann ebenfalls angepasst werden. Wir können die Schriftart, Schriftgröße, Schriftfarbe und andere Aspekte ändern.

plt.plot(x, y)
plt.title('Sinuswelle', fontsize=20, color='blue')  # Ändert die Schriftgröße und Farbe des Titels
plt.show()

Matplotlib bietet eine Reihe von vordefinierten Stylesheets, die wir verwenden können, um das Aussehen unserer Plots schnell zu ändern. Ein Stylesheet definiert eine Reihe von Stileinstellungen, einschließlich Farben, Linienstile, Hintergrundfarbe und mehr.

plt.style.use('ggplot')  # Verwendet das 'ggplot' Stylesheet
plt.plot(x, y)
plt.show()

Wir können auch unser eigenes Stylesheet erstellen und es für konsistente Darstellungen in unseren Plots verwenden. Dies ist besonders nützlich, wenn wir eine bestimmte Stilrichtlinie für alle unsere Plots beibehalten möchten.

Erstellen Sie ein interaktives Scatter-Plot mit zufällig generierten Datenpunkten. Aktivieren Sie den interaktiven Modus und zeigen Sie das Diagramm an.

Matplotlib bietet Funktionen für das 3D-Plotting, die es uns ermöglichen, dreidimensionale Diagramme zu erstellen. Dies kann besonders nützlich sein, wenn wir Daten mit mehr als zwei Dimensionen visualisieren möchten.

Um ein 3D-Diagramm zu erstellen, müssen wir zunächst eine Instanz der Axes3D-Klasse erstellen. Dies kann durch Hinzufügen des Schlüsselwortarguments projection'3d'= zur add_subplot-Methode erreicht werden.

import matplotlib.pyplot as plt
import numpy as np

fig = plt.figure()

# Erstellen einer 3D-Achse
ax = fig.add_subplot(111, projection='3d')

# Daten für 3D-Plot
z = np.linspace(0, 1, 100)
x = z * np.sin(25 * z)
y = z * np.cos(25 * z)

ax.plot(x, y, z)
plt.show()

Matplotlib bietet auch Unterstützung für animierte Diagramme. Mit der FuncAnimation-Klasse können wir eine Funktion definieren, die bei jedem Frame der Animation aufgerufen wird.

import matplotlib.animation as animation

fig, ax = plt.subplots()

x = np.arange(0, 2*np.pi, 0.01)
line, = ax.plot(x, np.sin(x))

def animate(i):
    line.set_ydata(np.sin(x + i/50))  # update the data.
    return line,

ani = animation.FuncAnimation(
    fig, animate, interval=20, blit=True, save_count=50)

plt.show()

Mit Subplots können wir mehrere Diagramme in einer einzigen Figur darstellen. Dies kann nützlich sein, wenn wir mehrere verwandte Datenreihen haben, die wir vergleichen möchten.

# Erstellen einer Figur und Subplots
fig, axs = plt.subplots(2)

# Daten für die Plots
x = np.linspace(0, 2 * np.pi, 400)
y1 = np.sin(x)
y2 = np.cos(x)

# Erstellen der Plots
axs[0].plot(x, y1)
axs[1].plot(x, y2)

plt.show()

Erstellen Sie einen Plot mit den folgenden Anforderungen:

• Der Plot soll eine Sinus-Funktion im Bereich von 0 bis 10 darstellen.
• Der Plot soll eine Cosinus-Funktion im Bereich von 0 bis 10 darstellen.
• Die Linie der Sinus-Funktion soll in der Farbe Rot dargestellt werden.
• Die Linie der Cosinus-Funktion soll in der Farbe Blau dargestellt werden.
• Der Plot soll einen Titel und Achsenbeschriftungen haben.
• Der Plot soll eine Legende enthalten.
• Der Plot soll angezeigt werden.

Erstellen Sie einen Plot mit den folgenden Anforderungen:

• Der Plot soll eine zufällige Verteilung von 1000 Werten darstellen.
• Der Plot soll als Histogramm dargestellt werden.
• Der Plot soll 30 Bins enthalten.
• Der Plot soll in der Farbe Grün dargestellt werden.
• Der Plot soll einen Titel und Achsenbeschriftungen haben.
• Der Plot soll eine Legende enthalten.
• Der Plot soll angezeigt werden.

Erstellen Sie einen Plot mit den folgenden Anforderungen:

• Der Plot soll eine Verteilung von 100 Werten darstellen.
• Die Werte sollen aus einer externen Datei data.csv geladen werden.
• Der Plot soll als Scatter-Plot dargestellt werden.
• Die Punkte sollen in der Farbe Schwarz dargestellt werden.
• Die Punkte sollen eine Transparenz von 0.5 haben.
• Der Plot soll einen Titel und Achsenbeschriftungen haben.
• Der Plot soll eine Legende enthalten.
• Der Plot soll angezeigt werden.

Erstellen Sie einen Plot mit den folgenden Anforderungen:

• Der Plot soll eine zufällige Verteilung von 1000 normalverteilten Werten darstellen.
• Der Plot soll als Boxplot dargestellt werden.
• Der Plot soll horizontale Boxen enthalten.
• Der Plot soll farbige Boxen enthalten.
• Der Plot soll einen Titel und Achsenbeschriftungen haben.
• Der Plot soll eine Legende enthalten.
• Der Plot soll angezeigt werden.

Führen Sie alle vier Plots zu einer einzigen Figure zusammen und zeigen Sie diese an.