Seaborn Lineplot: Vollständiger Leitfaden zu Liniendiagrammen mit sns.lineplot()

Name: Soren Atelier

Updated on 11.2.2026

Liniendiagramme sind essenziell, um Trends, Zeitreihendaten und Beziehungen zwischen kontinuierlichen Variablen zu visualisieren. Doch das Erstellen von Liniendiagrammen in Publikationsqualität, die Erkenntnisse klar kommunizieren, erfordert oft umfangreiche matplotlib-Konfiguration und manuelles Styling. Data Scientists verlieren Stunden mit dem Feinjustieren von Linienfarben, dem Verwalten von Legends und dem Formatieren von Achsen, obwohl sie sich eigentlich auf die Analyse konzentrieren sollten.

Seaborns lineplot()-Funktion löst dieses Problem, indem sie eine High-Level-Schnittstelle für schöne Liniendiagramme mit minimalem Code bietet. Sie übernimmt automatisch statistische Aggregation, Konfidenzintervalle, Farbpaletten und visuelles Styling – und bleibt dabei für fortgeschrittene Anwendungsfälle sehr gut anpassbar.

Dieser Leitfaden deckt alles ab: von einfachen Line Plots bis zu fortgeschrittenen Multi-Series-Visualisierungen mit individuellem Styling. Du lernst, professionelle Charts zu erstellen, die deine Data Insights effektiv kommunizieren.

📚

Die Grundlagen von sns.lineplot() verstehen

Die Funktion sns.lineplot() erstellt Liniendiagramme aus pandas DataFrames oder Arrays. Sie aggregiert automatisch mehrere Beobachtungen pro x-Wert und zeigt standardmäßig Konfidenzintervalle an.

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
 
# Create sample data
df = pd.DataFrame({
    'time': range(10),
    'value': [1, 3, 2, 5, 4, 6, 5, 7, 6, 8]
})
 
# Basic lineplot
sns.lineplot(data=df, x='time', y='value')
plt.title('Basic Line Plot')
plt.show()

Das erzeugt ein sauberes Liniendiagramm mit automatischen Achsenbeschriftungen, die aus den Spaltennamen abgeleitet werden. Die Funktion übernimmt Datenformatierung, Skalierung und visuelles Styling ohne manuelle Konfiguration.

Zentrale Parameter und Syntax

Die Funktion sns.lineplot() akzeptiert Daten in mehreren Formaten und bietet umfangreiche Anpassungsmöglichkeiten:

sns.lineplot(
    data=None,      # DataFrame, array, or dict
    x=None,         # Column name or vector for x-axis
    y=None,         # Column name or vector for y-axis
    hue=None,       # Grouping variable for color
    size=None,      # Grouping variable for line width
    style=None,     # Grouping variable for line style
    palette=None,   # Color palette
    markers=False,  # Add markers to data points
    dashes=True,    # Use dashed lines for styles
    ci=95,          # Confidence interval (deprecated in newer versions)
    errorbar=('ci', 95),  # Error representation
    legend='auto',  # Legend display
    ax=None         # Matplotlib axes object
)

Beim Arbeiten mit DataFrames sorgt die Verwendung von Spaltennamen für die Parameter x und y für besser lesbaren Code:

# Create multi-observation dataset
data = pd.DataFrame({
    'day': [1, 2, 3, 1, 2, 3, 1, 2, 3],
    'sales': [100, 150, 120, 110, 145, 125, 105, 155, 130],
    'store': ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C']
})
 
# Plot with automatic aggregation
sns.lineplot(data=data, x='day', y='sales')
plt.title('Average Sales by Day (with 95% CI)')
plt.xlabel('Day of Week')
plt.ylabel('Sales ($)')
plt.show()

Die Funktion berechnet automatisch die durchschnittlichen Verkäufe pro Tag und zeigt Konfidenzintervalle als schattiertes Band um die Linie an.

Mehrere Linien mit Hue plotten

Der Parameter hue erstellt separate Linien für verschiedene Gruppen in deinen Daten und weist automatisch unterschiedliche Farben zu:

# Multiple stores on same plot
fig, ax = plt.subplots(figsize=(10, 6))
 
sns.lineplot(
    data=data,
    x='day',
    y='sales',
    hue='store',  # Separate line for each store
    palette='Set2'
)
 
plt.title('Sales Comparison Across Stores')
plt.xlabel('Day of Week')
plt.ylabel('Sales ($)')
plt.legend(title='Store', loc='upper left')
plt.show()

So entstehen drei farblich getrennte Linien inklusive automatisch erzeugter Legend. Der Parameter palette steuert das Farbschema.

Für komplexere Gruppierungsszenarien:

# Multiple grouping variables
customer_data = pd.DataFrame({
    'month': [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
    'revenue': [5000, 5500, 6000, 4800, 5200, 5800, 6200, 6800, 7200, 6000, 6500, 7000],
    'segment': ['Premium', 'Premium', 'Premium', 'Standard', 'Standard', 'Standard',
                'Premium', 'Premium', 'Premium', 'Standard', 'Standard', 'Standard'],
    'region': ['North', 'North', 'North', 'North', 'North', 'North',
               'South', 'South', 'South', 'South', 'South', 'South']
})
 
# Use hue for segment, style for region
sns.lineplot(
    data=customer_data,
    x='month',
    y='revenue',
    hue='segment',
    style='region',
    markers=True,
    dashes=False
)
 
plt.title('Revenue by Segment and Region')
plt.xlabel('Month')
plt.ylabel('Revenue ($)')
plt.show()

Linienstile mit dem Style-Parameter anpassen

Der Parameter style variiert die Darstellung der Linie über unterschiedliche Strichmuster oder Linientypen:

# Temperature data with different sensors
temp_data = pd.DataFrame({
    'hour': list(range(24)) * 3,
    'temperature': [15, 14, 13, 12, 12, 13, 15, 17, 19, 21, 23, 24,
                   25, 26, 25, 24, 22, 20, 18, 17, 16, 15, 15, 14] * 3,
    'sensor': ['Sensor_A'] * 24 + ['Sensor_B'] * 24 + ['Sensor_C'] * 24,
    'location': ['Indoor'] * 24 + ['Outdoor'] * 24 + ['Basement'] * 24
})
 
# Add some variation
import numpy as np
np.random.seed(42)
temp_data['temperature'] = temp_data['temperature'] + np.random.normal(0, 1, len(temp_data))
 
fig, ax = plt.subplots(figsize=(12, 6))
 
sns.lineplot(
    data=temp_data,
    x='hour',
    y='temperature',
    hue='location',
    style='location',
    markers=True,
    dashes=True,
    palette='tab10'
)
 
plt.title('24-Hour Temperature Monitoring')
plt.xlabel('Hour of Day')
plt.ylabel('Temperature (°C)')
plt.legend(title='Location')
plt.grid(True, alpha=0.3)
plt.show()

Unterschiedliche Linienstile helfen dabei, Gruppen auch im Graustufendruck zu unterscheiden oder die Barrierefreiheit zu verbessern.

Marker zu Datenpunkten hinzufügen

Marker heben einzelne Datenpunkte entlang der Linie hervor – nützlich bei spärlichen Daten oder um bestimmte Beobachtungen zu betonen:

# Quarterly earnings data
earnings = pd.DataFrame({
    'quarter': ['Q1', 'Q2', 'Q3', 'Q4'] * 3,
    'earnings': [2.1, 2.3, 2.5, 2.4, 2.2, 2.4, 2.6, 2.7, 2.3, 2.5, 2.8, 2.9],
    'year': ['2023'] * 4 + ['2024'] * 4 + ['2025'] * 4
})
 
sns.lineplot(
    data=earnings,
    x='quarter',
    y='earnings',
    hue='year',
    markers=True,
    marker='o',  # Specific marker style
    markersize=8,
    linewidth=2.5,
    palette='deep'
)
 
plt.title('Quarterly Earnings per Share')
plt.xlabel('Quarter')
plt.ylabel('EPS ($)')
plt.ylim(2.0, 3.0)
plt.legend(title='Year')
plt.grid(True, alpha=0.3)
plt.show()

Du kannst Marker-Stile pro Gruppe festlegen:

# Custom markers for different groups
sns.lineplot(
    data=earnings,
    x='quarter',
    y='earnings',
    hue='year',
    style='year',
    markers=['o', 's', '^'],  # Different marker per year
    markersize=10,
    dashes=False
)
 
plt.title('Earnings Trend with Distinct Markers')
plt.show()

Mit Konfidenzintervallen und Fehlerbändern arbeiten

Seaborn berechnet automatisch Konfidenzintervalle, wenn pro x-Wert mehrere Beobachtungen existieren. Diese statistische Aggregation hilft, Unsicherheit in den Daten zu kommunizieren:

# Experimental data with replicates
experiment = pd.DataFrame({
    'concentration': [0.1, 0.5, 1.0, 2.0, 5.0] * 10,
    'response': np.random.lognormal(mean=[1, 1.5, 2, 2.5, 3] * 10, sigma=0.3),
    'replicate': list(range(10)) * 5
})
 
fig, axes = plt.subplots(1, 3, figsize=(15, 4))
 
# 95% confidence interval (default)
sns.lineplot(data=experiment, x='concentration', y='response',
             errorbar=('ci', 95), ax=axes[0])
axes[0].set_title('95% Confidence Interval')
 
# Standard deviation
sns.lineplot(data=experiment, x='concentration', y='response',
             errorbar='sd', ax=axes[1])
axes[1].set_title('Standard Deviation')
 
# No error bars
sns.lineplot(data=experiment, x='concentration', y='response',
             errorbar=None, ax=axes[2])
axes[2].set_title('No Error Bars')
 
plt.tight_layout()
plt.show()

Der Parameter errorbar unterstützt mehrere Darstellungen:

('ci', 95): 95%-Konfidenzintervall
('pi', 95): 95%-Prognoseintervall
'sd': Standardabweichung
'se': Standardfehler
('pi', 50): Interquartilsabstand
None: Keine Fehlerdarstellung

Farben mit Paletten anpassen

Der Parameter palette steuert Linienfarben über benannte Paletten oder eigene Farblisten:

# Stock price comparison
stocks = pd.DataFrame({
    'date': pd.date_range('2025-01-01', periods=60),
    'price': np.random.randn(60).cumsum() + 100,
    'ticker': ['AAPL'] * 60
})
 
stocks = pd.concat([
    stocks,
    pd.DataFrame({
        'date': pd.date_range('2025-01-01', periods=60),
        'price': np.random.randn(60).cumsum() + 150,
        'ticker': ['GOOGL'] * 60
    }),
    pd.DataFrame({
        'date': pd.date_range('2025-01-01', periods=60),
        'price': np.random.randn(60).cumsum() + 200,
        'ticker': ['MSFT'] * 60
    })
])
 
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
# Built-in palette
sns.lineplot(data=stocks, x='date', y='price', hue='ticker',
             palette='Set1', ax=axes[0, 0])
axes[0, 0].set_title('Set1 Palette')
 
# Custom colors
custom_colors = {'AAPL': '#FF6B6B', 'GOOGL': '#4ECDC4', 'MSFT': '#45B7D1'}
sns.lineplot(data=stocks, x='date', y='price', hue='ticker',
             palette=custom_colors, ax=axes[0, 1])
axes[0, 1].set_title('Custom Color Mapping')
 
# Colorblind-safe palette
sns.lineplot(data=stocks, x='date', y='price', hue='ticker',
             palette='colorblind', ax=axes[[... truncated ...])