Altair in Python Tutorial: Datenvisualisierungen

Aussagekräftige, leicht verständliche Diagramme zu erstellen, ist entscheidend, wenn du als Data Scientist erfolgreich sein willst. Visualisierungen helfen dir, die Geschichte in deinen Daten zu erzählen. Sie machen Zusammenhänge sichtbar und zeigen Muster, die das menschliche Auge erkennt, die sich aber nicht allein in Zahlen ausdrücken lassen. Und weißt du, was für die Datenanalyse noch besser ist als statische Grafiken? Interaktive Visualisierungen!

Für Einsteiger wirkt das oft einschüchternd. Python und R bieten jedoch eine breite Palette an Tools und Tricks, die dich dabei unterstützen. In diesem Tutorial lernst du Altair kennen. Mit Altair erstellst du mit nur wenigen Zeilen Code schnell aussagekräftige, elegante und wirkungsvolle Visualisierungen. Also los geht’s!

What is Altair?

Altair ist eine Python-Bibliothek für statistische Visualisierung. Sie ist deklarativ aufgebaut (darauf kommen wir gleich zurück). Altair basiert auf Vega und Vega-Lite — Visualisierungssprachen, mit denen du das Aussehen und das interaktive Verhalten einer Visualisierung in einem JSON-Format beschreiben kannst.

Imperative vs. Declarative APIs

Wie erwähnt, gibt es in Python bereits eine ganze Reihe hervorragender Bibliotheken für Datenvisualisierung, viele unterstützen auch Interaktivität. Was also macht Altair besonders?

Die Antwort liegt in der deklarativen Arbeitsweise im Gegensatz zu imperativen APIs.

Bei imperativen APIs richtest du deinen Fokus auf das „Wie“ statt auf das „Was“. Du musst also eher an den Code denken, der die Visualisierung erzeugt, und einzelne Plot-Schritte manuell festlegen — Achsengrenzen, Größe, Drehung, Legenden usw.

Als Data Scientist kannst du dich mit Altair stärker auf deine Daten konzentrieren — verstehen, analysieren, visualisieren — statt auf den Code. Du definierst die Daten und das erwartete Ergebnis (wie die Visualisierung aussehen soll), und Altair übernimmt die nötigen Schritte automatisch.

Installation

In diesem Tutorial nutzen wir Beispieldatensätze aus den Vega Datasets. Um Altair zusammen mit den Vega Datasets zu installieren, gib Folgendes in der Konsole ein:

$ pip install altair vega_datasets

Wenn du den Paketmanager conda verwendest, lautet der entsprechende Befehl:

$ conda install -c conda-forge altair vega_datasets

Danach wechselst du in dein Jupyter Notebook und importierst Altair. Mehr zu Jupyter Notebooks findest du in DataCamps Jupyter Notebook Definitive Guide.

Daten

Jetzt, da Altair und die Vega Datasets installiert sind, laden wir Daten. Starte mit folgenden Imports:

import pandas as pd
import altair as alt

Why import Pandas?

Altair arbeitet intern mit dem Pandas DataFrame. Das heißt, du kannst Daten in Altair so manipulieren, wie du es mit dem Pandas-DataFrame gewohnt bist.

Auch wenn Altair Daten intern als Pandas DataFrame speichert, gibt es mehrere Möglichkeiten, Daten zu übergeben:

• als Pandas DataFrame
• als Data- oder verwandtes Objekt (z. B. UrlData, InlineData, NamedData)
• als URL-String, der auf eine JSON- oder CSV-Datei zeigt
• als Objekt mit geo_interface (z. B. Geopandas GeoDataFrame, Shapely-Geometrien, GeoJSON-Objekte)

Movies-Datensatz

In diesem Tutorial arbeiten wir mit dem Movies-Datensatz aus den Vega Datasets. Dieser und ähnliche Filmdatensätze sind in der Data-Science-Community beliebt, etwa für Empfehlungssysteme. Wir bleiben hier jedoch bei der explorativen Analyse mit Visualisierungen in Altair.

Der Datensatz enthält Filminformationen wie Titel, Einspielergebnis in den USA und weltweit, Produktionsbudget, Genre, Bewertungen von IMDB und Rotten Tomatoes und mehr. Wir verwenden nicht alle Spalten, sondern nur einige, um das Arbeiten mit Altair kennenzulernen.

Holen wir uns den Datensatz und machen eine kurze Analyse, um ihn besser zu verstehen.

# Importing the Vega Dataset
from vega_datasets import data as vega_data

movies_df = pd.read_json(vega_data.movies.url)

# Checking the type of data that we get
print("movies_df is of the type: ", type(movies_df))

print("movies_df: ", movies_df.shape)

movies_df is of the type:  <class 'pandas.core.frame.DataFrame'>
movies_df:  (3201, 16)

Wie du siehst, ist movies_df ein Pandas DataFrame mit 3201 Filmen (Zeilen) und 16 Merkmalen (Spalten). Schauen wir in die Daten.

movies_df.head(5)

Die Spalten lauten:

movies_df.columns

Index(['Title', 'US_Gross', 'Worldwide_Gross', 'US_DVD_Sales',
       'Production_Budget', 'Release_Date', 'MPAA_Rating', 'Running_Time_min',
       'Distributor', 'Source', 'Major_Genre', 'Creative_Type', 'Director',
       'Rotten_Tomatoes_Rating', 'IMDB_Rating', 'IMDB_Votes'],
      dtype='object')

Als Nächstes wandeln wir mit to_datetime in pandas die Spalte Release_Date in ein echtes Datum um und extrahieren daraus die Jahreszahl. Diese neue Spalte nutzen wir später in den Visualisierungen.

def extract_year(value):
    return pd.to_datetime(value, format='%b %d %Y').year

movies_df["Year"] = movies_df["Release_Date"].apply(extract_year)

Wenn du dir jetzt die Spalten ansiehst, findest du eine neue Spalte Year mit dem jeweiligen Erscheinungsjahr des Films.

movies_df.columns

Index(['Title', 'US_Gross', 'Worldwide_Gross', 'US_DVD_Sales',
       'Production_Budget', 'Release_Date', 'MPAA_Rating', 'Running_Time_min',
       'Distributor', 'Source', 'Major_Genre', 'Creative_Type', 'Director',
       'Rotten_Tomatoes_Rating', 'IMDB_Rating', 'IMDB_Votes', 'Year'],
      dtype='object')

Bevor wir die ersten Grafiken erstellen, führe diesen Code aus:

alt.renderers.enable('notebook')

RendererRegistry.enable('notebook')

Damit rendert Altair die Grafiken direkt im Jupyter Notebook, sodass du die Ergebnisse sofort siehst. Wenn etwas hakt, hilft die Altair-Troubleshooting-Seite.

Für den ersten Blick in die Daten ist es spannend zu sehen, wie das Produktionsbudget (Production_Budget) mit den weltweiten Einnahmen (Worldwide_Gross) zusammenhängt. Diese Werte legen wir auf die X- und Y-Achse.

Der Datensatz ist relativ groß — unser Fokus liegt aber auf Altair. Daher arbeiten wir zunächst mit einem Teil der Daten. Prüfen wir, wie viele Filme es pro Jahr gibt, und wählen ein Jahr aus, auf das wir uns konzentrieren.

movies_df["Year"].value_counts()

2006    220
2005    210
2002    208
2004    192
2000    188
       ...
1943      1
2015      1
2027      1
2037      1
1928      1
Name: Year, Length: 91, dtype: int64

Wir konzentrieren uns auf das Jahr 2000 und erstellen ein neues DataFrame movies_2000 nur mit Filmen aus diesem Jahr. Es sollte 188 Zeilen haben.

movies_2000 = movies_df[movies_df["Year"] == 2000]
movies_2000.shape

(188, 17)

Jetzt bauen wir unsere erste Visualisierung. Dazu ein kurzer Blick auf Altairs Aufbau.

Charts

Charts sind das zentrale Objekt in Altair und nehmen ein einziges Argument entgegen — ein DataFrame. Ein Chart wird so definiert:

alt.Chart(DataFrame)

Allein macht der Chart noch nichts außer die Datenquelle festzulegen. Danach musst du angeben, was mit den Daten passieren soll. Hier kommen die Marks ins Spiel.

Marks

Mit Marks legst du fest, wie die Daten im Plot dargestellt werden. Altair bietet unter anderem diese grundlegenden Marks:

Für unseren Plot soll jeder Datenpunkt als Punkt (Kreis) erscheinen. Also schreiben wir:

alt.Chart(DataFrame).mark_point()

Encodings

Nachdem klar ist, welche Daten wie dargestellt werden, bestimmst du, wo sie erscheinen — also Positionen, Größe, Farbe usw. Das passiert über Encodings:

alt.Chart(DataFrame).mark_point().encode()

Setzen wir alles zusammen und erstellen unsere erste Visualisierung:

alt.Chart(movies_2000).mark_point().encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross')
)

<vega.vegalite.VegaLite at 0x11709a1d0>

Schon stark, oder? Mit wenig Aufwand und etwas Terminologie haben wir einen Plot, der das Verhältnis von Budget zu weltweiten Einnahmen für die Filme des Jahres 2000 zeigt.

Machen wir die Grafik spannender. Statt alle Punkte gleich groß darzustellen, skalieren wir die Punktgröße mit US_Gross. Dafür nutzen wir das Feature Size. Je größer der Kreis, desto höher die US-Einspielergebnisse. Außerdem füllen wir die Punkte farbig, indem wir ein Argument an mark_point() übergeben.

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross')
)

<vega.vegalite.VegaLite at 0x117cce790>

Jetzt sehen wir die Budgets und die US-Einnahmen auf einen Blick — in nur vier Zeilen Code. Was fehlt? Farbe!

Aber nicht irgendeine Farbe. Wir nutzen eine weitere Information aus dem Datensatz: Major_Genre. Jede Filmkategorie bekommt ihre eigene Farbe über das Feature Color, und mit OpacityValue fügen wir Transparenz hinzu.

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7)
)

<vega.vegalite.VegaLite at 0x118e3ff50>

Das ist schon gut — aber da geht noch mehr. Idealerweise könnten wir uns frei im Plot bewegen und Details zum jeweiligen Film sehen. Genau das ermöglicht Tooltip…

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title'),
               alt.Tooltip('Production_Budget'),
               alt.Tooltip('Worldwide_Gross'),
               alt.Tooltip('US_Gross')
              ]
)

<vega.vegalite.VegaLite at 0x118e3ff90>

Ziemlich cool, oder? Aber wir gehen noch einen Schritt weiter. Der Grund, warum wir Altair nutzen wollten, war Interaktivität. Tooltip sorgt bereits für Interaktion beim Überfahren der Punkte. Jetzt fügen wir zusätzlich die einfache Funktion interactive() hinzu…

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title'),
               alt.Tooltip('Production_Budget'),
               alt.Tooltip('Worldwide_Gross'),
               alt.Tooltip('US_Gross')
              ]
).interactive()

<vega.vegalite.VegaLite at 0x118e3c750>

Mit dieser kleinen Erweiterung kannst du bereits in Bereiche hineinzoomen — die Achsen passen sich automatisch an, damit du dich auf den interessanten Ausschnitt konzentrieren kannst. Darüber hinaus gibt es viele weitere interaktive Möglichkeiten. Schauen wir uns eine davon an…

Wir haben nun einen starken Plot. Holen wir alle Datenpunkte rein. Aber alle Punkte in einer einzigen Grafik wären zu viel. Außerdem wollen wir sie unbedingt nach dem zuvor erzeugten Year trennen. Dafür nutzen wir eine erweiterte Selection.

select_year = alt.selection_single(
    name='Select', fields=['Year'], init={'Year': 1928},
    bind=alt.binding_range(min=1928, max=2046, step=10)
)

alt.Chart(movies_df).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title:N'),
               alt.Tooltip('Production_Budget:Q'),
               alt.Tooltip('Worldwide_Gross:Q'),
               alt.Tooltip('US_Gross:Q')
              ]
).add_selection(select_year).transform_filter(select_year)

<vega.vegalite.VegaLite at 0x117cd4cd0>

Wir fügen also mit add_selection die Single-Selection select_year hinzu und wenden mit transform_filter() den Filter tatsächlich auf den Plot an.

Ist dir die weitere Neuerung im Code aufgefallen? Das „Q“ und „N“ im Tooltip. Damit legst du den Datentyp fest: N = Nominal (kategorisch), Q = Quantitativ (numerisch), O = Ordinal (geordnet) oder T = Temporal (Zeitpunkte oder -intervalle).

Prüfe das älteste und das jüngste Jahr im Datensatz.

print("The oldest year is: ", movies_df["Year"].min())
print("The latest year is: ", movies_df["Year"].max())

The oldest year is:  1928
The latest year is:  2046

Wie du siehst, gibt es zwischen 1928 und 1967 nur wenige Filme. Und nach 2018 sind keine Daten erfasst — schon gar nicht bis 2046. Mit binding_range() kannst du den gültigen Jahresbereich und die Schrittweite festlegen.

In realen Projekten sind solche Befunde wichtig und können auf Fehler bei der Datenerhebung oder -verarbeitung hindeuten. Du musst solche Abweichungen sauber behandeln — ein zentraler Schritt in der Datenvorbereitung. Eine Einführung findest du in Data Preparation with pandas.

Passen wir die Jahre an — und damit ist unsere finale Visualisierung fertig…

select_year = alt.selection_single(
    name='Select', fields=['Year'], init={'Year': 1968},
    bind=alt.binding_range(min=1968, max=2008, step=10)
)

alt.Chart(movies_df).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title:N'),
               alt.Tooltip('Production_Budget:Q'),
               alt.Tooltip('Worldwide_Gross:Q'),
               alt.Tooltip('US_Gross:Q')
              ]
).add_selection(select_year).transform_filter(select_year)

<vega.vegalite.VegaLite at 0x1180cda10>

In diesem Tutorial hast du Altair kennengelernt. Du hast gesehen, wie du mit wenigen Zeilen Code schöne, interaktive Plots erstellst, die die Geschichte in deinen Daten wirkungsvoll erzählen. Dieses Tutorial zeigt die Stärke und das Potenzial von Altair. Mehr erfährst du auf der offiziellen Website.