Die Visualisierung von CSV-Daten mit Pandas ist eine wichtige Technik, um Datenanalyse und Entscheidungsfindung schnell und effizient zu gestalten. Durch die visuelle Darstellung von Daten können Trends und Muster leicht erkannt werden, was sie in der Geschäftsanalyse, der wissenschaftlichen Forschung und akademischen Projekten weit verbreitet macht. In diesem Artikel werden wir mit den grundlegenden Operationen beginnen, um CSV-Daten mit Pandas zu laden, und dann zeigen, wie man diese mit Bibliotheken wie Matplotlib oder Seaborn auf interessante und leicht verständliche Weise visualisiert. Nutzen Sie diesen Artikel, um Ihre Fähigkeiten in der Datenanalyse mit Python zu verbessern.
Laden von CSV-Dateien und Überprüfung der Datenübersicht
Mit Pandas können Sie CSV-Dateien effizient laden und mit der Datenanalyse beginnen. Im Folgenden zeigen wir, wie Sie eine CSV-Datei laden und die grundlegenden Informationen der Daten überprüfen.
Laden einer CSV-Datei
Verwenden Sie die read_csv()-Funktion von Pandas, um eine CSV-Datei zu laden. Zum Beispiel, um eine Datei namens data.csv zu laden, verwenden Sie den folgenden Code:
import pandas as pd
# CSV-Datei laden
df = pd.read_csv('data.csv')
# Erste Zeilen des DataFrames anzeigen
print(df.head())Mit diesem Code wird die CSV-Daten in einem Pandas DataFrame gespeichert, und die ersten 5 Zeilen der Daten können angezeigt werden.
Überprüfung der Datenübersicht
Um die Struktur der geladenen Daten sowie grundlegende statistische Informationen zu überprüfen, können Sie die folgenden Methoden verwenden.
- Überprüfen der Anzahl der Zeilen und Spalten
print(df.shape)
# Ausgabe: (Zeilenanzahl, Spaltenanzahl)- Überprüfen von Datentypen und fehlenden Werten
print(df.info())- Überprüfen von grundlegenden statistischen Kennzahlen
print(df.describe())- Überprüfen bestimmter Spalten
print(df['Spaltenname'].unique()) # Zeigt die einzigartigen Werte der Spalte
print(df['Spaltenname'].value_counts()) # Zählt die Häufigkeit der WerteMit diesen Methoden können Sie ein erstes Verständnis für den Inhalt der Daten gewinnen und sich auf den nächsten Visualisierungsschritt vorbereiten.
Erstellen grundlegender Diagramme mit Matplotlib
Durch die Kombination von Pandas und Matplotlib können CSV-Daten einfach visualisiert werden. Hier zeigen wir, wie man grundlegende Diagramme erstellt.
Matplotlib Setup
Zuerst müssen Sie Matplotlib importieren. Durch die Verwendung des pyplot-Moduls können Sie Diagramme schnell erstellen.
import matplotlib.pyplot as plt
# Bereits geladenen DataFrame df verwenden
df = pd.read_csv('data.csv')Erstellen eines Liniendiagramms
Ein Liniendiagramm ist nützlich, um zeitabhängige oder fortlaufende Daten darzustellen.
# Daten für die x-Achse "Datum" und für die y-Achse "Umsatz" plotten
plt.plot(df['Datum'], df['Umsatz'])
plt.title('Umsatzentwicklung')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.xticks(rotation=45) # Dreht die x-Achsen-Beschriftungen
plt.show()Erstellen eines Balkendiagramms
Balkendiagramme sind nützlich, um Werte nach Kategorien zu visualisieren.
# Umsatz nach Produktkategorie aggregieren und als Balkendiagramm darstellen
category_sales = df.groupby('Kategorie')['Umsatz'].sum()
category_sales.plot(kind='bar', color='skyblue')
plt.title('Umsatz nach Kategorie')
plt.xlabel('Kategorie')
plt.ylabel('Umsatz')
plt.show()Erstellen eines Streudiagramms
Streudiagramme eignen sich hervorragend, um die Korrelation zwischen zwei Variablen zu visualisieren.
# Korrelation zwischen Preis und Umsatz plotten
plt.scatter(df['Preis'], df['Umsatz'], alpha=0.7, color='green')
plt.title('Preis und Umsatz Korrelation')
plt.xlabel('Preis')
plt.ylabel('Umsatz')
plt.show()Erstellen eines Histogramms
Ein Histogramm ist hilfreich, um die Verteilung der Daten zu untersuchen.
# Verteilung der Umsatzdaten plotten
df['Umsatz'].plot(kind='hist', bins=20, color='orange', edgecolor='black')
plt.title('Umsatzverteilung')
plt.xlabel('Umsatz')
plt.ylabel('Häufigkeit')
plt.show()Mit diesen Diagrammen können Sie die Eigenschaften der Daten visuell verstehen. Im nächsten Schritt zeigen wir, wie man fortgeschrittene Visualisierungen mit Seaborn erstellt.
Erweiterte Plots mit Seaborn
Seaborn ist eine Bibliothek, die zusammen mit Pandas und Matplotlib verwendet werden kann, um hochwertige Diagramme einfach zu erstellen. Komplexe Diagramme und Stile können intuitiv erstellt werden. In diesem Abschnitt zeigen wir, wie man fortgeschrittene Visualisierungen mit Seaborn erstellt.
Seaborn Setup
Zuerst importieren wir Seaborn und stellen den gewünschten Stil ein.
import seaborn as sns
# Stil einstellen
sns.set(style="whitegrid")
df = pd.read_csv('data.csv') # Daten ladenVisualisierung von Kategoriedaten: Boxplot
Um die Verteilung von Daten nach Kategorien zu visualisieren, ist ein Boxplot hilfreich.
# Verteilung des Umsatzes nach Kategorie visualisieren
sns.boxplot(x='Kategorie', y='Umsatz', data=df, palette='pastel')
plt.title('Umsatzverteilung nach Kategorie')
plt.xlabel('Kategorie')
plt.ylabel('Umsatz')
plt.show()Visualisierung von Korrelationen: Streudiagramm mit Regressionslinie
Mit regplot in Seaborn können Sie eine Regressionslinie zu einem Streudiagramm hinzufügen.
# Korrelation zwischen Preis und Umsatz plotten
sns.regplot(x='Preis', y='Umsatz', data=df, scatter_kws={'alpha':0.6}, line_kws={'color':'red'})
plt.title('Preis und Umsatz Korrelation')
plt.xlabel('Preis')
plt.ylabel('Umsatz')
plt.show()Datenverteilung Visualisierung: Heatmap
Um die Korrelationsmatrix von Daten zu visualisieren, ist eine Heatmap nützlich.
# Korrelationsmatrix berechnen
correlation_matrix = df.corr()
# Heatmap erstellen
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Korrelationsmatrix Heatmap')
plt.show()Kategorische und numerische Beziehungen: Violinplot
Ein Violinplot zeigt die Verteilung von Daten nach Kategorien auf elegante Weise.
# Umsatzverteilung nach Kategorie plotten
sns.violinplot(x='Kategorie', y='Umsatz', data=df, palette='muted', inner='quartile')
plt.title('Umsatzverteilung nach Kategorie (Violinplot)')
plt.xlabel('Kategorie')
plt.ylabel('Umsatz')
plt.show()Datenhäufigkeit visualisieren: Countplot
Ein Countplot ist nützlich, um die Häufigkeit von Kategorien darzustellen.
# Häufigkeit der Produktkategorien plotten
sns.countplot(x='Kategorie', data=df, palette='viridis')
plt.title('Häufigkeit der Produktkategorien')
plt.xlabel('Kategorie')
plt.ylabel('Häufigkeit')
plt.show()Mit den raffinierten Diagrammen von Seaborn können Sie tiefere Einblicke in Ihre Daten gewinnen. Im nächsten Schritt zeigen wir, wie man bestimmte Spalten extrahiert und diese visualisiert.
Visualisierung von extrahierten Daten aus bestimmten Spalten
Bei der Datenanalyse ist es oft wichtig, spezifische Spalten oder Daten basierend auf bestimmten Bedingungen zu extrahieren und zu visualisieren. Hier zeigen wir, wie man mit Pandas Daten filtert und geeignete Diagramme erstellt.
Extrahieren von bestimmten Spalten und Erstellen von Diagrammen
Wenn Sie sich auf eine bestimmte Spalte konzentrieren und die Daten visualisieren möchten, können Sie die Spaltennamen im DataFrame angeben, um die Daten herauszuziehen.
# Umsatzdaten nur als Histogramm anzeigen
df['Umsatz'].plot(kind='hist', bins=15, color='skyblue', edgecolor='black')
plt.title('Umsatzverteilung')
plt.xlabel('Umsatz')
plt.ylabel('Häufigkeit')
plt.show()Visualisierung von Korrelationen mit mehreren Spalten
Wählen Sie mehrere Spalten aus, um die Korrelationen visuell darzustellen.
# Korrelation zwischen Umsatz und Preis als Streudiagramm anzeigen
plt.scatter(df['Preis'], df['Umsatz'], color='green', alpha=0.6)
plt.title('Preis und Umsatz Korrelation')
plt.xlabel('Preis')
plt.ylabel('Umsatz')
plt.show()Visualisierung von Daten nach Bedingungen
Durch das Extrahieren von Daten anhand bestimmter Bedingungen und deren Visualisierung können Sie bestimmte Datenmuster detailliert analysieren.
# Daten mit Umsatz über 1000 extrahieren und plotten
high_sales = df[df['Umsatz'] >= 1000]
plt.plot(high_sales['Datum'], high_sales['Umsatz'], marker='o', color='orange')
plt.title('Umsatz über 1000 nach Datum')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.xticks(rotation=45)
plt.show()Gruppierte Daten aggregieren und visualisieren
Gruppieren Sie Daten nach Kategorien oder bestimmten Attributen und visualisieren Sie die Ergebnisse.
# Durchschnittlichen Umsatz nach Produktkategorie berechnen
category_avg_sales = df.groupby('Kategorie')['Umsatz'].mean()
# Als Balkendiagramm anzeigen
category_avg_sales.plot(kind='bar', color='coral')
plt.title('Durchschnittlicher Umsatz nach Kategorie')
plt.xlabel('Kategorie')
plt.ylabel('Durchschnittlicher Umsatz')
plt.show()Daten mit mehreren Bedingungen extrahieren und visualisieren
Durch die Angabe mehrerer Bedingungen können Sie die Daten weiter eingrenzen und visualisieren.
# Daten extrahieren, bei denen Umsatz über 1000 und Preis unter 500 liegt
filtered_data = df[(df['Umsatz'] >= 1000) & (df['Preis'] < 500)]
# Als Streudiagramm visualisieren
plt.scatter(filtered_data['Preis'], filtered_data['Umsatz'], color='purple', alpha=0.7)
plt.title('Umsatz über 1000 und Preis unter 500 Korrelation')
plt.xlabel('Preis')
plt.ylabel('Umsatz')
plt.show()Durch diese Methoden können Sie die Daten analysieren und wichtige Muster entdecken, indem Sie sich auf bestimmte Spalten und Bedingungen konzentrieren. Im nächsten Schritt zeigen wir, wie man Zeitreihendaten visualisiert.
Visualisierung von Zeitreihendaten
Zeitreihendaten sind entscheidend für die Analyse von Trends und Saisonalitäten über die Zeit. Hier zeigen wir, wie man Zeitreihendaten mit Pandas und Visualisierungsbibliotheken effektiv darstellt.
Vorbereitung von Zeitreihendaten
Zuerst müssen Sie die Zeitspalte in das datetime-Format von Pandas konvertieren. Dadurch können Sie die Funktionen von Pandas für Zeitreihen nutzen.
# Datumsspalte in datetime-Format konvertieren
df['Datum'] = pd.to_datetime(df['Datum'])
# DataFrame nach Datum sortieren
df = df.sort_values('Datum')
# Datum als Index setzen (optional)
df.set_index('Datum', inplace=True)Plotten einer einzelnen Zeitreihe
Visualisieren Sie Zeitreihendaten mit einem Liniendiagramm.
# Umsatzdaten plotten
df['Umsatz'].plot(figsize=(10, 5), color='blue', linewidth=2)
plt.title('Umsatzzeitreihe')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.grid(True)
plt.show()Vergleich von mehreren Zeitreihen
Vergleichen Sie mehrere Zeitreihen, indem Sie sie im selben Diagramm übereinander legen.
# Umsatz und Gewinn gleichzeitig plotten
df[['Umsatz', 'Gewinn']].plot(figsize=(10, 5), linewidth=2)
plt.title('Umsatz und Gewinn im Zeitverlauf')
plt.xlabel('Datum')
plt.ylabel('Betrag')
plt.legend(['Umsatz', 'Gewinn'])
plt.grid(True)
plt.show()Analyse von Saisonalität und Trends
Wenn Zeitreihendaten Saisonalität oder Trends enthalten, können diese zerlegt und analysiert werden.
from statsmodels.tsa.seasonal import seasonal_decompose
# Umsatzdaten saisonal zerlegen
decomposition = seasonal_decompose(df['Umsatz'], model='additive', period=12)
# Die einzelnen Komponenten (Trend, Saisonalität, Residuen) plotten
decomposition.plot()
plt.show()Plotten von Daten für einen bestimmten Zeitraum
Extrahieren und plotten Sie Daten für einen bestimmten Zeitraum.
# Daten für das Jahr 2023 extrahieren und plotten
df_2023 = df['2023']
df_2023['Umsatz'].plot(figsize=(10, 5), color='green', linewidth=2)
plt.title('Umsatz 2023')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.grid(True)
plt.show()Anpassen der Visualisierung
Fügen Sie Marker oder Annotationen hinzu, um Zeitreihendiagramme hervorzuheben.
# Marker zu den Umsatzdaten hinzufügen
plt.plot(df.index, df['Umsatz'], marker='o', color='red', linewidth=2)
plt.title('Umsatzzeitreihe (mit Markern)')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.grid(True)
# Annotation zu einem bestimmten Datum hinzufügen
peak_date = df['Umsatz'].idxmax() # Datum des höchsten Umsatzes
peak_value = df['Umsatz'].max()
plt.annotate(f'Höchster Umsatz: {
peak_value}', xy=(peak_date, peak_value), xytext=(peak_date, peak_value + 100),
arrowprops=dict(facecolor='black', arrowstyle='->'), fontsize=10)
plt.show()Interaktive Zeitreihen-Diagramme
Erstellen Sie interaktive Diagramme mit Bibliotheken wie Plotly.
import plotly.express as px
# Interaktives Zeitreihen-Diagramm erstellen
fig = px.line(df.reset_index(), x='Datum', y='Umsatz', title='Umsatzzeitreihe')
fig.show()Mit diesen Methoden können Sie Zeitreihendaten effektiv visualisieren und Trends sowie Saisonalitäten erkennen. Als nächstes erklären wir, wie man mehrere Diagramme gleichzeitig anzeigt.
Mehrere Diagramme gleichzeitig plotten
Bei der Datenanalyse kann es hilfreich sein, mehrere Diagramme gleichzeitig darzustellen, um die Daten aus verschiedenen Perspektiven zu vergleichen. Hier zeigen wir, wie man mit Matplotlib und Seaborn mehrere Diagramme gleichzeitig plottet.
Mehrere Diagramme mit Matplotlib zeichnen
Mit subplot in Matplotlib können Sie mehrere Diagramme in einer Abbildung erstellen.
import matplotlib.pyplot as plt
# Diagramme in einem 2x2-Raster anordnen
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
# Diagramm 1: Umsatzzeitreihe
axes[0, 0].plot(df.index, df['Umsatz'], color='blue', linewidth=2)
axes[0, 0].set_title('Umsatzzeitreihe')
axes[0, 0].set_xlabel('Datum')
axes[0, 0].set_ylabel('Umsatz')
# Diagramm 2: Gewinnzeitreihe
axes[0, 1].plot(df.index, df['Gewinn'], color='green', linewidth=2)
axes[0, 1].set_title('Gewinnzeitreihe')
axes[0, 1].set_xlabel('Datum')
axes[0, 1].set_ylabel('Gewinn')
# Diagramm 3: Umsatzverteilung (Histogramm)
axes[1, 0].hist(df['Umsatz'], bins=15, color='orange', edgecolor='black')
axes[1, 0].set_title('Umsatzverteilung')
axes[1, 0].set_xlabel('Umsatz')
axes[1, 0].set_ylabel('Häufigkeit')
# Diagramm 4: Korrelation zwischen Preis und Umsatz (Streudiagramm)
axes[1, 1].scatter(df['Preis'], df['Umsatz'], color='purple', alpha=0.7)
axes[1, 1].set_title('Preis und Umsatz Korrelation')
axes[1, 1].set_xlabel('Preis')
axes[1, 1].set_ylabel('Umsatz')
# Layout anpassen
plt.tight_layout()
plt.show()Mehrere Diagramme mit Seaborn zeichnen
Mit FacetGrid in Seaborn können Sie Daten nach Kategorien aufteilen und mehrere Diagramme zeichnen.
import seaborn as sns
# Umsatzzeitreihe nach Kategorie plotten
g = sns.FacetGrid(df, col="Kategorie", col_wrap=3, height=4)
g.map(sns.lineplot, "Datum", "Umsatz")
g.set_titles("{col_name}")
g.set_axis_labels("Datum", "Umsatz")
plt.show()Verschiedene Diagramme in einer Abbildung übereinander zeichnen
Mit Matplotlib können Sie verschiedene Diagrammtypen in einer einzigen Abbildung übereinander legen, um Daten zu vergleichen.
fig, ax1 = plt.subplots(figsize=(10, 6))
# Umsatz als Liniendiagramm plotten
ax1.plot(df.index, df['Umsatz'], color='blue', label='Umsatz')
ax1.set_xlabel('Datum')
ax1.set_ylabel('Umsatz', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')
# Gewinn als Balkendiagramm darüber legen
ax2 = ax1.twinx() # Zweite y-Achse erstellen
ax2.bar(df.index, df['Gewinn'], color='orange', alpha=0.6, label='Gewinn')
ax2.set_ylabel('Gewinn', color='orange')
ax2.tick_params(axis='y', labelcolor='orange')
# Titel und Legende hinzufügen
fig.suptitle('Vergleich von Umsatz und Gewinn')
fig.legend(loc='upper left', bbox_to_anchor=(0.1, 0.9))
plt.show()Einzelne Diagramme speichern
Speichern Sie jedes Diagramm separat, indem Sie savefig() für jedes Diagramm aufrufen.
# Umsatzzeitreihe speichern
df['Umsatz'].plot()
plt.title('Umsatzzeitreihe')
plt.savefig('sales_trend.png')
plt.clf() # Aktuelles Diagramm löschen
# Umsatzverteilung speichern
df['Umsatz'].plot(kind='hist', bins=15, color='orange', edgecolor='black')
plt.title('Umsatzverteilung')
plt.savefig('sales_distribution.png')
plt.clf()Interaktive Diagramme speichern
Interaktive Diagramme, die mit Plotly erstellt wurden, können im HTML-Format gespeichert werden.
import plotly.express as px
# Interaktives Umsatzdiagramm
fig = px.line(df.reset_index(), x='Datum', y='Umsatz', title='Umsatzzeitreihe')
# Als HTML-Datei speichern
fig.write_html('interactive_sales_plot.html')Mit diesen Methoden können Sie mehrere Diagramme gleichzeitig zeichnen und die verschiedenen Perspektiven auf Ihre Daten kombinieren. Im nächsten Schritt erklären wir, wie man Diagramme anpasst.
Anpassung von Diagrammen (Farben, Stil, Annotationen usw.)
Die Anpassung von Diagrammen durch Farben, Stil oder Annotationen ist entscheidend, um die Lesbarkeit und Informationsdichte zu erhöhen. Hier zeigen wir, wie man Diagramme mit Matplotlib anpassen kann.
Ändern von Farben und Stilen
Durch das Anpassen der Farben und Stile von Diagrammen können Sie deren Lesbarkeit verbessern.
import matplotlib.pyplot as plt
# Grundlegende Anpassungen
plt.plot(df.index, df['Umsatz'], color='blue', linestyle='--', linewidth=2, label='Umsatz')
plt.plot(df.index, df['Gewinn'], color='green', linestyle='-', linewidth=2, label='Gewinn')
# Titel und Achsenbeschriftungen
plt.title('Umsatz und Gewinn im Zeitverlauf', fontsize=16, fontweight='bold')
plt.xlabel('Datum', fontsize=12)
plt.ylabel('Betrag', fontsize=12)
# Legende hinzufügen
plt.legend(fontsize=10, loc='upper left')
# Gitter hinzufügen
plt.grid(color='gray', linestyle=':', linewidth=0.5)
plt.show()Anpassung von Schriftarten und Größen
Die Änderung der Schriftgröße und des Schriftstils kann die Lesbarkeit der Diagramme erhöhen.
# Schriftgröße für alle Elemente ändern
plt.rcParams.update({'font.size': 12})
# Spezielle Elemente anpassen
plt.title('Angepasster Titel', fontsize=16, fontweight='bold')
plt.xlabel('Datum', fontsize=12, fontstyle='italic')
plt.ylabel('Umsatz', fontsize=12, fontstyle='italic')Hinzufügen von Annotationen
Fügen Sie Annotationen hinzu, um bestimmte Datenpunkte hervorzuheben.
# Höchsten Umsatz als Annotation anzeigen
peak_date = df['Umsatz'].idxmax()
peak_value = df['Umsatz'].max()
plt.plot(df.index, df['Umsatz'], color='blue')
plt.annotate(f'Höchstwert: {peak_value}',
xy=(peak_date, peak_value),
xytext=(peak_date, peak_value + 500),
arrowprops=dict(facecolor='red', arrowstyle='->'),
fontsize=10, color='darkred')
plt.title('Umsatz mit Annotationen anzeigen')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.grid(True)
plt.show()Verwendung von Farbskalen
Mit Farbskalen können Sie die Farben je nach Wert der Daten ändern.
# Farbskala auf das Streudiagramm der Umsätze anwenden
plt.scatter(df['Preis'], df['Umsatz'], c=df['Umsatz'], cmap='viridis', alpha=0.8)
plt.title('Preis und Umsatz (mit Farbskala)')
plt.xlabel('Preis')
plt.ylabel('Umsatz')
plt.colorbar(label='Umsatz')
plt.show()Anpassung des Layouts von Subplots
Passen Sie das Layout von mehreren Diagrammen an, um die Lesbarkeit zu verbessern.
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
# Diagramme zeichnen
axes[0, 0].plot(df.index, df['Umsatz'], color='blue')
axes[0, 0].set_title('Umsatzentwicklung')
axes[0, 1].plot(df.index, df['Gewinn'], color='green')
axes[0, 1].set_title('Gewinnentwicklung')
axes[1, 0].hist(df['Umsatz'], bins=15, color='orange')
axes[1, 0].set_title('Umsatzverteilung')
axes[1, 1].scatter(df['Preis'], df['Umsatz'], color='purple', alpha=0.7)
axes[1, 1].set_title('Preis und Umsatz Korrelation')
# Layout anpassen
plt.tight_layout()
plt.show()Ändern des Diagrammthemas
Mit Seaborn können Sie das Thema ändern, um den Stil des gesamten Diagramms anzupassen.
import seaborn as sns
# Thema einstellen
sns.set_theme(style="whitegrid", palette="muted")
# Umsatzzeitreihe plotten
sns.lineplot(x=df.index, y=df['Umsatz'], color='blue', label='Umsatz')
sns.lineplot(x=df.index, y=df['Gewinn'], color='green', label='Gewinn')
plt.title('Umsatz und Gewinn im Zeitverlauf (mit Thema)')
plt.xlabel('Datum')
plt.ylabel('Betrag')
plt.legend()
plt.show()Speichern von Diagrammen
Speichern Sie Ihre erstellten Diagramme als Bilddateien.
# Diagramm speichern
plt.plot(df.index, df['Umsatz'], color='blue', label='Umsatz')
plt.title('Umsatzentwicklung')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.legend()
plt.savefig('sales_trend.png', dpi=300, bbox_inches='tight') # Speichern in hoher Auflösung
plt.show()Durch die Kombination dieser Anpassungsmethoden können Sie visuell ansprechende Diagramme erstellen. Im nächsten Abschnitt erklären wir, wie Sie Ihre visualisierten Daten speichern können.
Speichern von visualisierten Daten (Bilddateiausgabe)
Es ist wichtig, die visualisierten Diagramme als Bilddateien zu speichern, um die Analyseergebnisse zu teilen oder in Berichten zu verwenden. In diesem Abschnitt zeigen wir die grundlegende Methode zum Speichern von Diagrammen mit Matplotlib und einige Anpassungsoptionen.
Grundlegende Speicheroptionen
Verwenden Sie die savefig()-Funktion von Matplotlib, um ein Diagramm als Bilddatei zu speichern. Hier ist ein einfaches Beispiel.
import matplotlib.pyplot as plt
# Diagramm erstellen
plt.plot(df.index, df['Umsatz'], color='blue', label='Umsatz')
plt.title('Umsatzentwicklung')
plt.xlabel('Datum')
plt.ylabel('Umsatz')
plt.legend()
# Als Bild speichern
plt.savefig('sales_trend.png')
plt.show()
Mit diesem Code wird das Diagramm als sales_trend.png im PNG-Format gespeichert.
Speichern in verschiedenen Bildformaten
Matplotlib unterstützt nicht nur das PNG-Format, sondern auch andere Formate wie JPEG, PDF und SVG.
# Speichern im JPEG-Format
plt.savefig('sales_trend.jpg', format='jpg')
# Speichern im PDF-Format
plt.savefig('sales_trend.pdf', format='pdf')
# Speichern im SVG-Format
plt.savefig('sales_trend.svg', format='svg')Einstellen der Auflösung (DPI)
Durch das Festlegen der Auflösung können Sie Bilder von höherer Qualität speichern.
# Speichern in hoher Auflösung (300 DPI)
plt.savefig('sales_trend_high_res.png', dpi=300)Anpassen der Ränder
Standardmäßig enthält das Diagramm umgebende Ränder. Um diese zu reduzieren, verwenden Sie bbox_inches='tight'.
# Ränder entfernen und speichern
plt.savefig('sales_trend_tight.png', bbox_inches='tight')Speichern mehrerer Diagramme
Speichern Sie mehrere Diagramme, indem Sie jedes Diagramm separat speichern.
# Diagramm 1: Umsatz
plt.plot(df.index, df['Umsatz'], color='blue')
plt.title('Umsatzentwicklung')
plt.savefig('sales_plot.png')
plt.clf() # Aktuelles Diagramm löschen
# Diagramm 2: Gewinn
plt.plot(df.index, df['Gewinn'], color='green')
plt.title('Gewinnentwicklung')
plt.savefig('profit_plot.png')
plt.clf()Speichern interaktiver Diagramme
Mit Plotly erstellte interaktive Diagramme können im HTML-Format gespeichert werden.
import plotly.express as px
# Interaktives Diagramm erstellen
fig = px.line(df.reset_index(), x='Datum', y='Umsatz', title='Umsatzzeitreihe')
# Als HTML-Datei speichern
fig.write_html('interactive_sales_plot.html')Überprüfung nach dem Speichern
Nach dem Speichern eines Diagramms können Sie es in Python schnell öffnen und überprüfen.
from PIL import Image
# Gespeichertes Bild öffnen
img = Image.open('sales_trend.png')
img.show()Mit diesen Methoden können Sie Ihre Analyseergebnisse sicher speichern und für die Präsentation oder das Teilen vorbereiten. Abschließend fassen wir die wichtigsten Punkte zusammen.
Zusammenfassung
In diesem Artikel haben wir detailliert erklärt, wie man CSV-Daten mit der Python-Bibliothek Pandas visualisiert. Wir haben von der Datenvorbereitung bis hin zur Erstellung von Diagrammen, der Visualisierung von Zeitreihendaten, der Anzeige mehrerer Diagramme gleichzeitig und der Anpassung sowie Speicherung von Diagrammen viele wichtige Themen behandelt.
Die Visualisierung von Daten ist eine entscheidende Fähigkeit, um Informationen klar zu vermitteln. Durch die Kombination von Pandas, Matplotlib und Seaborn können Sie Datenmuster und -trends schnell erkennen. Außerdem können Sie Ihre Analyseergebnisse effektiv speichern und teilen, indem Sie interaktive Diagramme oder Bilder verwenden.
Nutzen Sie diese Methoden für eine effizientere Datenanalyse und -präsentation.