Daten mit Python und Tableau visualisieren: Tutorial

Warum Python mit Tableau nutzen

Tableau bietet mehrere Möglichkeiten, Datenfelder zu erweitern und neue zu erstellen. Über berechnete Felder kannst du arithmetische, logische, räumliche und prädiktive Funktionen ausführen. Tableau ist ein leistungsstarkes Business-Intelligence-(BI)-Tool, hat aber auch Grenzen – hier kommt Python ins Spiel.  

Python ist in der Datencommunity eine der beliebtesten Programmiersprachen. Du kannst damit Daten extrahieren, bereinigen, verarbeiten und komplexe statistische Funktionen anwenden. Außerdem stehen dir Frameworks für Machine Learning, Datenorchestrierung, Multiprocessing und umfangreiche Bibliotheken zur Verfügung – für nahezu jede Aufgabe. 

Python ist eine vielseitige Sprache. In Kombination mit Tableau gibt sie uns die Freiheit, auch sehr komplexe Aufgaben zu lösen. In diesem Tutorial nutzen wir Python zum Extrahieren und Bereinigen der Daten. Anschließend visualisieren wir die bereinigten Daten in Tableau.

Wir verwenden Tabpy hier nicht, um einen Tableau-Python-Server aufzusetzen und Skripte direkt in Tableau auszuführen. Stattdessen extrahieren und bereinigen wir die Daten zuerst in Python (Jupyter Notebook) und erstellen danach interaktive Visualisierungen in Tableau. 

Goodreads Data Viz | Tableau Public

Dieses Tutorial führt dich Code-basiert Schritt für Schritt durch die Goodreads API und die Erstellung komplexer Visualisierungen in Tableau. Über den Link unten findest du den Code und das Tableau-Dashboard. 

• DataLab-Workbook

• Tableau Public

Datenaufnahme und -verarbeitung mit Python

Im ersten Teil greifen wir mit der Goodreads API auf öffentliche Daten zu. Wir konzentrieren uns auf das Nutzerprofil und wandeln es in ein lesbares pandas-DataFrame um. Anschließend bereinigen wir die Daten und exportieren sie als CSV-Datei. 

Erste Schritte

Wir verwenden DataLab, um den Python-Code auszuführen. Es bringt die wichtigsten Python-Pakete für Data-Science-Aufgaben bereits mit. 

Wenn du neu in Python bist und die Umgebung lokal einrichten möchtest, installiere Anaconda. Damit bekommst du Python, Jupyter Notebook und die nötigen Python-Pakete. 

Bevor wir loslegen, müssen wir noch das Paket xmltodict installieren, da es nicht Teil des DataLab- oder Anaconda-Stacks ist. Wir nutzen dafür `pip`.

Hinweis: Das `!`-Präfix funktioniert nur in Jupyter Notebooks. Es erlaubt den Zugriff auf das Terminal direkt in der Codezelle. 

!pip install xmltodict

>>> Collecting xmltodict
>>>   Using cached xmltodict-0.13.0-py2.py3-none-any.whl (10.0 kB)
>>> Installing collected packages: xmltodict
>>> Successfully installed xmltodict-0.13.0

Im nächsten Schritt importieren wir die benötigten Pakete. 

import pandas as pd
import xmltodict
import urllib.request

Das Profil-URL parsen

Um Nutzerdaten zu extrahieren, benötigen wir sowohl die User-ID als auch den Nutzernamen. In diesem Abschnitt parsen wir den Profil-Link des Nutzers (Abid). 

Hinweis: Du kannst den Link eines Freundes oder deinen eigenen verwenden und das Skript ausführen. 

1. Wir extrahieren die user_id, indem wir nur die Ziffern aus dem Link filtern – Ergebnis: „73376016“. 
2. Für den user_name teilen wir den String an der user_id und anschließend an dem Bindestrich „-“ und ersetzen „-“ durch ein Leerzeichen. So erhalten wir „abid“.
3. Zum Schluss verketten wir user_id und user_name. Diese eindeutige ID verwenden wir im nächsten Schritt, um auf Nutzerdaten zuzugreifen.

Goodread_profile = "https://www.goodreads.com/user/show/73376016-abid"

user_id = ''.join(filter(lambda i: i.isdigit(), Goodread_profile))
user_name = Goodread_profile.split(user_id, 1)[1].split('-', 1)[1].replace('-', ' ')
user_id_name = user_id+'-'+user_name

print(user_id_name)

>>> 73376016-abid

Goodreads-Daten extrahieren

Ende 2020 hat Goodreads die Bereitstellung der Entwickler-API eingestellt. Den vollständigen Hinweis findest du hier. Um das zu umgehen, nutzen wir API-Keys aus älteren Projekten wie der streamlit_goodreads_app. Das Projekt erklärt, wie man per API auf Goodreads-Nutzerdaten zugreift. 

Alternativ bietet Goodreads den Download als CSV ohne API-Key an. Das ist jedoch auf den jeweiligen Nutzer beschränkt und liefert keine Echtzeitdaten. 

Wir erstellen Funktionen, die user_id_name, version, shelf, per_page und apiKey entgegennehmen. 

• apiKey: Zugriff auf die öffentlichen Daten
• version: Legt den Datentyp bzw. die Version fest.
• shelf: Nutzer haben mehrere „Shelves“ – meist read, to-read und currently-reading.
• per_page: Anzahl der Bucheinträge pro Seite

Die Funktion nimmt diese Eingaben, baut die URL zusammen und lädt die Daten mit urllib.request herunter. Die Antwort kommt im XML-Format. 

apiKey = "ZRnySx6awjQuExO9tKEJXw"
version = "2"
shelf = "read"
per_page = "200"

def get_user_data(user_id, apiKey, version, shelf, per_page):
    api_url_base = "https://www.goodreads.com/review/list"
    final_url = (
        api_url_base
        + user_id
        + ".xml?key="
        + apiKey
        + "&v="
        + version
        + "&shelf="
        + shelf
        + "&per_page="
        + per_page
    )
    contents = urllib.request.urlopen(final_url).read()
    return contents
contents = get_user_data(user_id_name,apiKey,version, shelf, per_page)
print(contents[0:100])


>>> b'<?xml version="1.0" encoding="UTF-8"?>\n<GoodreadsResponse>\n  <Request>\n    <authentication>true</aut'

XML in JSON umwandeln

Unsere Ausgangsdaten liegen als XML vor. Es gibt keinen direkten Weg, sie in eine strukturierte Tabelle zu überführen. Deshalb wandeln wir sie mit dem Python-Paket xmltodict in JSON um. 

Die XML-Daten werden in ein verschachteltes JSON transformiert. Um den ersten Eintrag der Buchrezensionen anzuzeigen, greifen wir mit eckigen Klammern auf die verschachtelten Strukturen zu. 

Du kannst mit den Metadaten experimentieren und weitere Optionen erkunden – in diesem Tutorial konzentrieren wir uns auf die Rezensionsdaten der Nutzer.  

contents_json = xmltodict.parse(contents)
print(contents_json["GoodreadsResponse"]["reviews"]["review"][:1])

>>> [{'id': '4626706284', 'book': {'id': {'@type': 'integer', '#text': '57771224'}, 'isbn': '1250809606', 'isbn13': '9781250809605', 'text_reviews_count': {'@type': 'integer', '#text': '150'}, 'uri': 'kca://book/amzn1.gr.book.v3.tcNoY0o7ErAhczdQ', 'title': 'Good Intentions', 'title_without_series': 'Good Intentions', 'image_url': .........

JSON in ein pandas-DataFrame umwandeln 

Für die Umwandlung von JSON in ein pandas-DataFrame nutzen wir json_normalize. Die Review-Daten liegen auf der dritten Ebene; wir greifen daher auf GoodreadsResponse, reviews und review zu.

Bevor wir das DataFrame anzeigen, filtern wir irrelevante Einträge heraus, indem wir Bücher ohne gefüllte Spalte date_updated entfernen. 

Lerne verschiedene Wege, CSVs, Tabellenkalkulationen, JSON, SQL-Datenbanken und APIs mit pandas einzulesen – im Kurs Streamlined Data Ingestion with pandas. 

df = pd.json_normalize(contents_json["GoodreadsResponse"]["reviews"]["review"])
df = df[df["date_updated"].notnull()]
df.head()

Datenbereinigung

Das rohe DataFrame ist bereits recht aufgeräumt, aber wir wollen die Spaltenanzahl weiter reduzieren. 

Aktuell gibt es 61 Spalten.

df.shape
(200, 61)

Lassen wir die komplett leeren Spalten weg. 

df.dropna(axis=1, how='all', inplace=True)
df.shape
(200, 58)

Wir haben erfolgreich 3 Spalten mit fehlenden Werten entfernt.

Jetzt sehen wir uns mit `df.columns` alle Spaltennamen an und wählen die relevantesten aus. 

final_df = df[
    [
        "rating",
        "started_at",
        "read_at",
        "date_added",
        "book.title",
        "book.average_rating",
        'book.ratings_count',
        "book.publication_year",
        "book.authors.author.name"
    ]
]
final_df.head()

Das finale DataFrame wirkt nun schlank und enthält alle relevanten Felder. 

CSV exportieren

Zum Schluss exportieren wir das DataFrame als CSV, das mit Tableau kompatibel ist. Übergib in to_csv den Dateinamen inklusive Endung und setze den Index-Parameter auf False, damit kein Index mitgeschrieben wird. 

final_df.to_csv("abid_goodreads_clean_data.csv",index=False)

Die CSV-Datei erscheint im aktuellen Verzeichnis.

Goodreads Clean CSV File

Du kannst dir auch das Jupyter Notebook ansehen: Data Ingestion using Goodreads API. Es hilft beim Debuggen und wenn du den Python-Teil überspringen willst, kannst du über Copy & Edit die Datei kopieren und das Skript ausführen. 

Datenvisualisierung in Tableau

Im zweiten Teil erstellen wir aus den bereinigten Daten einfache und komplexe Visualisierungen in Tableau. Ziel ist es, interaktive Diagramme zu bauen, die das Leseverhalten der Nutzerin bzw. des Nutzers sichtbar machen. 

Daten verbinden

Verbinde die CSV über die Option Text und wähle die Datei abid_goodreads_clean_data.csv. Ändere danach die Datentypen der Felder Started At, Read At und Date Added auf Datum & Uhrzeit, wie unten gezeigt. 

Hinweis: Es ist sinnvoll, Datentypen gleich zu Beginn korrekt zu setzen.  

Daten verbinden und Datentypen anpassen

Histogramm der Bewertungen

Hier erstellen wir ein Histogramm der Buchbewertungen. 

• Ziehe das Feld Rating auf das Rows-Regal. 

Histogramm der Nutzerbewertungen – Teil 1

• Klicke auf Show Me, um die Vorlagen zu öffnen. Wandle das Balkendiagramm in ein Histogramm um, indem du Histogram auswählst.

Histogramm der Nutzerbewertungen – Teil 2

• Die Rating-Achse hat Tickmarks im 0,5er-Abstand. Ändere das, indem du die untere Achse rechtsklickst und Edit Axis wählst. Unter Tick Marks stellst du Major Tick Marks auf Fixed. Achte darauf, dass Tick Origin 0 ist und das Tick Interval 1.

Histogramm der Nutzerbewertungen – Teil 3

• Optimiere das Histogramm, indem du Achsenbeschriftungen bereinigst, Farben und Rahmen der Balken änderst und Datenlabels hinzufügst. Die Optionen findest du im Marks-Bereich links in der Mitte. 

Histogramm der Nutzerbewertungen – Teil 4

Der Nutzer vergibt meist Bewertungen zwischen 3 und 4. Nullen stehen für Bücher ohne Bewertung. 

Liniendiagramm

So erstellst du ein Liniendiagramm:

1. Ziehe Book.Publication Year auf Rows und Columns.
2. Ändere das Feld unter Rows per Rechtsklick auf Measure > Count. 
3. Stelle das Feld unter Columns per Rechtsklick auf Dimensions um.
4. Wechsle im Marks-Bereich über das Dropdown von „Automatic“ auf Line. 
5. Bereinige die Achsenbeschriftungen, passe das Diagramm an, füge einen Titel hinzu und entferne Nullwerte.
   
   

Liniendiagramm: Erscheinungsjahr der Bücher

Der Nutzer hat einige ältere Bücher gelesen, interessiert sich aber besonders für Titel aus den Jahren 2015 bis 2020. 

Wenn dir das zu viel auf einmal ist und du die Grundlagen von Tableau lernen möchtest, hilft dir das Tableau Tutorial for Beginners von Eugenia Anello. 

Boxplot

So erstellst du einen Box-and-Whisker-Plot:

1. Ziehe Books.Ratings Count auf Rows und ändere es von Discrete auf Continuous. 
2. Ziehe Books.Ratings Count zusätzlich auf Detail im Marks-Bereich und stelle es von Measure auf Dimension um.
3. Öffne Show Me und wähle den Boxplot. 
4. Verschiebe das Feld von Rows nach Columns, um es horizontal auszurichten. 
5. Zum Schluss geht es um Feinschliff: Größe erhöhen, Farbe anpassen, Titel hinzufügen und die Achse in „Popularity“ umbenennen.

Boxplot: Anzahl der Bewertungen pro Buch

Offenbar liest der Nutzer eher weniger populäre Bücher – mit einigen Ausnahmen. Das deutet auf einen eigenen Geschmack hin, der sich am Inhalt orientiert, nicht an Popularität. 

Bubble-Plot

Wir haben bereits einfache, aussagekräftige Visualisierungen gebaut. Jetzt wird es komplexer: Wir erstellen ein berechnetes Feld, bearbeiten Bins und kombinieren mehrere Ebenen.

Im Bubble-Plot geben die Labels an, wie viele Tage ein Buch zum Lesen gebraucht hat, und die Blasengröße zeigt die Häufigkeit an. Ein Dauerfeld haben wir nicht – das leiten wir aus Started At und Read At ab.

Erstelle zuerst ein berechnetes Feld über den Pfeil im Data-Bereich mit Create Calculated Field. 

Berechnetes Feld erstellen

Im neuen Fenster:

1. Benenne den Titel in „Read Duration“ um.
2. Nutze die Funktion DATEDIFF, um die Differenz zwischen Read At und Started At zu berechnen.
3. Der erste Parameter der Funktion muss „day“ sein.
4. Ziehe die Felder in eckigen Klammern als zweiten und dritten Parameter hinein oder tippe sie ein. 

Read Duration in Days

Das Feld Read Duration ist kontinuierlich. Um Packed Bubbles zu erstellen, teilen wir es in Bins (Intervalle) auf. 

1. Ziehe das neue Feld `Read Duration` auf das Rows-Regal.
2. Klicke auf Show Me und wähle Histogram. Tableau erstellt automatisch ein Bin-Feld.

Bin-Feld erstellt 

1. Klicke mit rechts auf das neue Feld Read Duration (bin) und wähle die Read Duration in Days-Option.
2. Setze die Size of Bins auf 10. So entstehen feinere Intervalle – eine bessere Basis für Packed Bubbles. 

Bins bearbeiten

Die Vorarbeit ist erledigt – jetzt ernten wir die Früchte. 

1. Für die Grundvisualisierung: Klicke auf Show Me und wähle Packed Bubbles. Du siehst nun einfarbige Kreise in unterschiedlichen Größen. 
2. Für Farbe ziehst du Read Duration auf Color im Marks-Bereich. 
3. Ändere das Farbfeld per Rechtsklick auf Measure > Count (Distinct). So erhält jedes Bin bzw. Label eine eigene Farbe. 

Einfarbige Packed Bubbles

1. Klicke im Marks-Bereich auf Color und wähle Edit Colors… > Sunrise-Sunset Diverging. Wähle den Farbverlauf, der dir am besten gefällt. 
2. Zum Schluss geht es wieder um den Feinschliff: Optik, Lesbarkeit und Aussage so abstimmen, dass die Botschaft klar rüberkommt.

Packed-Bubbles-Plot 

Die meisten Bücher waren in weniger als einem Tag ausgelesen. Es gibt ein paar Ausreißer über 300 Tagen. 

Du kannst diese Visualisierungen auch in einem Dashboard kombinieren. Hier lernst du Schritt für Schritt, wie du ein Tableau-Dashboard erstellst.

Fazit

In diesem Tutorial hast du gesehen, warum Python in Kombination mit Tableau so wertvoll ist. Im ersten Teil haben wir Goodreads-Nutzerdaten per Entwickler-API extrahiert und XML in ein sauberes, strukturiertes pandas-DataFrame überführt. Im zweiten Teil haben wir daraus einfache und komplexe Visualisierungen gebaut. 

Die Kombination aus Python und Tableau eröffnet völlig neue Möglichkeiten: Datenpipelines integrieren, Machine-Learning-Modelle einbinden, komplexe statistische Analysen fahren – vieles, was in Tableau allein nicht machbar ist. 

Du kannst den Python-Code kostenlos in DataLab ausführen – alle nötigen Pakete sind enthalten. Für die Visualisierung haben wir die kostenlose Version Tableau Public genutzt.

Wenn du neu in Python bist und Syntax sowie Funktionen fundiert lernen willst, schau dir den Kurs Introduction to Data Science in Python an. Die Grundlagen der Tableau-Visualisierung und -Anpassung vertiefst du im Tableau Fundamentals-Lernpfad. Er umfasst 5 Kurse – von der Einführung in Tableau über Datenanalyse und interaktive Dashboards bis zur Arbeit mit mehreren Datenquellen.