JSON- und HTML-Daten in pandas importieren

Einführung

Das Importieren von Daten ist einer der wichtigsten und allerersten Schritte bei jeder datenbezogenen Aufgabe. Daten korrekt zu laden, ist eine unverzichtbare Kompetenz für alle angehenden Data Scientists.

Daten liegen in vielen Formaten vor. Du solltest nicht nur wissen, wie du verschiedene Formate importierst, sondern auch, wie du sie analysierst und aufbereitest, um daraus verwertbare Erkenntnisse zu gewinnen.

pandas ist eine Open-Source-Python-Bibliothek, die einfach zu verwenden ist, hohe Performance bietet und Werkzeuge zur Datenanalyse für diverse Datenformate mitbringt.

Sie ermöglicht dir, unterschiedliche Formate wie CSV, JSON, Excel, Pickle usw. zu lesen. Deine Daten werden zeilen- und spaltenbasiert tabellarisch dargestellt – so sind sie übersichtlich und gut präsentierbar.

pandas stellt Daten in einem DataFrame dar und bietet umfangreiche Funktionen für Datenanalyse und -manipulation. Sobald du mit den pandas-Funktionen Struktur in deine Daten gebracht hast, kannst du sie zum Analysieren, Forecasten, Klassifizieren und vielem mehr nutzen!

pandas stellt für Ein- und Ausgabe eine API mit einer Reihe von übergeordneten reader- und writer-Funktionen bereit. Der Reader wird über pandas.read_json() aufgerufen und gibt ein pandas-Objekt zurück. Der Writer wird als Objektmethode pandas.to_json() verwendet.

Ein DataFrame hat also eine Reader- und eine Writer-Funktion. Über den Reader liest du verschiedene Datenformate ein, über den Writer speicherst du Daten in einem gewünschten Format.

Nachfolgend siehst du Formate, die ein DataFrame unterstützt. Befindet sich deine Quelle in einem dieser Formate, kannst du sie mit pandas laden und bei Bedarf in ein anderes Format schreiben.

Im heutigen Tutorial arbeitest du mit einigen der genannten Formate: JSON, HTML und Pickle.

Hinweis: Sieh dir dieses Tutorial an, um zu lernen, wie du CSV-Dateien mit pandas einliest.

JSON-Daten laden

JSON, JavaScript Object Notation, ist ein textbasiertes Serialisierungsformat für den Datenaustausch. JSON ist leicht zu lesen und zu schreiben. Es basiert auf einem Teil der JavaScript-Programmiersprache, nutzt aber Konventionen, die auch in Python und vielen anderen Sprachen geläufig sind.

JSON dient häufig zur Speicherung unstrukturierter Daten, mit denen relationale Datenbanken schwer umgehen können. JSON macht Daten für Maschinen gut lesbar.

JSON basiert im Wesentlichen auf zwei Strukturen:

• Eine Sammlung aus Schlüssel/Wert-Paaren. In Python nennt man ein solches Paar ein Dictionary; der key ist eindeutig, die Werte müssen es nicht sein.

• Eine geordnete Liste von Werten. Diese kann wiederum eine Liste von Listen sein. Listen in Python enthalten Werte wie Strings, Integer usw.

Schauen wir uns an, wie du JSON-Daten auf verschiedene Arten laden kannst.

Der erste JSON-Datensatz kommt von diesem Link. Die Daten liegen als Dictionary mit Schlüssel-Wert-Paaren vor. Es gibt drei Keys: integer, datetime und category.

• Importiere zunächst die pandas-Bibliothek und übergib dann die URL an pd.read_json(). Das Ergebnis ist ein DataFrame. Die Spalten entsprechen den Schlüsseln, die Zeilen den JSON-Werten.

import pandas as pd

json = pd.read_json('https://raw.githubusercontent.com/chrisalbon/simulated_datasets/master/data.json')

Lass dir mit .tail() schnell die letzten Zeilen des geladenen JSON ausgeben.

json.tail(6)

json.shape

(100, 3)

Wie du siehst, gibt es drei Spalten: integer, datetime und category. Zudem enthält der Datensatz 100 Zeilen, was die .shape-Ausgabe 100 x 3 bestätigt.

• JSON schreiben

JSON zu schreiben ist genauso einfach wie das Einlesen – eine einzige Codezeile. Statt read_json() verwendest du to_json() mit einem Dateinamen, fertig!

json.to_json('dataframe.json')

• Verschachteltes JSON als String parsen

Als Nächstes nutzt du einen JSON-Datensatz, der etwas komplexer ist: eine verschachtelte Struktur. Das bedeutet, dass jeder key weitere keys enthalten kann.

Hier ein Beispieldatensatz zur Veranschaulichung.

nested_json = """{
   "article": [

      {
         "id":"01",
         "language": "JSON",
         "edition": "first",
         "author": "Allen"
      },

      {
         "id":"02",
         "language": "Python",
         "edition": "second",
         "author": "Aditya Sharma"
      }
   ],

   "blog":[
   {
       "name": "Datacamp",
       "URL":"datacamp.com"
   }
   ]
}"""

In diesem Datensatz sind article und blog die Primärschlüssel. Unter ihnen liegen die jeweiligen values, die wiederum eigene key-value-Paare besitzen.

Beachte: Der Datensatz ist in Anführungszeichen eingeschlossen und liegt somit als String vor.

Ein verschachteltes JSON lässt sich auf mehrere Arten einlesen.

Zuerst liest du den JSON-String mit json.loads, indem du die Variable mit den Daten übergibst. Anschließend verwendest du json_normalize, um die verschachtelten Daten zu „flatten“, also in eine Tabelle zu überführen.

Du importierst dazu json_normalize aus der Bibliothek pandas.io.json.

import json  
from pandas.io.json import json_normalize  

nested = json.loads(nested_json)

nested

{'article': [{'id': '01',
   'language': 'JSON',
   'edition': 'first',
   'author': 'Allen'},
  {'id': '02',
   'language': 'Python',
   'edition': 'second',
   'author': 'Aditya Sharma'}],
 'blog': [{'name': 'Datacamp', 'URL': 'datacamp.com'}]}

Als Nächstes „flatten“ wir das JSON mit normalize. Übergebe zunächst das komplette Objekt und sieh dir das Ergebnis an.

nested_full = json_normalize(nested)

nested_full

Super! Wie du siehst, sind die Primärschlüssel die Spalten des DataFrames, während die Keys die Zeilen darstellen.

Die Ausgabe ist allerdings noch etwas unhandlich. Teilen wir sie in mehrere DataFrames auf.

Übergebe json.loads erneut an json_normalize, diesmal mit dem zusätzlichen Parameter record_path.

blog = json_normalize(nested,record_path ='blog')

blog

article = json_normalize(nested,record_path ='article')

article

Wie du siehst, sind die Primärschlüssel nun auf zwei DataFrames aufgeteilt. Die Spaltennamen entsprechen den Keys, die innerhalb der Primärschlüssel als Schlüssel-Wert-Paare verschachtelt waren. Praktisch, oder?

Zum Abschluss des JSON-Teils schauen wir uns noch an, wie du JSON aus einer Datei statt aus einem String liest.

• JSON aus einer Datei lesen

nested_json = {
   "article": [

      {
         "id":"01",
         "language": "JSON",
         "edition": "first",
         "author": "Allen"
      },

      {
         "id":"02",
         "language": "Python",
         "edition": "second",
         "author": "Aditya Sharma"
      }
   ],

   "blog":[
   {
       "name": "Datacamp",
       "URL":"datacamp.com"
   }
   ]
}

Wie du erkennst, stehen hier keine Anführungszeichen am Anfang und Ende der Daten. Wir behandeln das also wie ein Dateiobjekt und lesen es ein.

Das geht mit einer einzigen Codezeile. So funktioniert’s:

json_file = pd.DataFrame.from_dict(json_normalize(nested_json))

json_file

Die Ausgabe entspricht der Variante, bei der du JSON als String eingelesen hast. Der einzige Unterschied: Du nutzt pandas, um das JSON zu parsen und zu flatten. Da es sich um ein Dictionary handelt, verwendest du .from_dict().

HTML-Daten laden

HTML ist die Hypertext Markup Language zur Erstellung von Webanwendungen und -seiten. Sie beschreibt die Struktur einer Seite semantisch. Der Browser erhält ein HTML-Dokument vom Webserver und rendert daraus eine multimediale Webseite.

In Webanwendungen wird HTML mit Cascading Style Sheets (CSS) kombiniert und serverseitig häufig mit Frameworks wie Flask, Django usw. eingesetzt.

HTML nutzt Tags, um Codeblöcke zu definieren, z. B. <p></p> für einen Absatz oder <image></image> zum Einfügen eines Bildes. Viele solcher Tags zusammen ergeben eine HTML-Seite.

Um eine HTML-Datei zu lesen, sucht der pandas-DataFrame nach einem Tag – konkret dem <td></td>-Tag, das Tabellen in HTML beschreibt.

pandas verwendet dafür read_html().

Wenn du also HTML an pandas übergibst und ein sauber formatiertes DataFrame erwartest, stelle sicher, dass die Seite eine Tabelle enthält!

• Zur Datenquelle: Du verwendest eine Cryptocurrency-Website als HTML-Datensatz. Sie listet verschiedene Coins mit Details wie:
  • Letzter Preis des Coins (Last price)
  • Preisänderung in Prozent (%)
  • 24-Stunden-Volumen (gehandelte Coins, 24 volume)
  • Gesamtzahl der Coins (# Coins)

Los geht’s!

Importiere zuerst die Bibliothek requests, um eine Anfrage an die URL zu senden, von der du den HTML-Inhalt abrufen willst.

import requests

url = 'https://www.worldcoinindex.com/'

crypto_url = requests.get(url)

crypto_url

<Response [200]>

Bis hierhin hast du die URL definiert, mit requests.get() eine Anfrage gesendet und als Antwort ein Acknowledge [200] OK erhalten. Das bedeutet, die Verbindung zum Webserver war erfolgreich.

Um den HTML-Inhalt der Seite zu lesen, rufst du crypto_url.text auf. Das gibt dir den HTML-Code der cryptocurrency-Seite zurück.

Führe crypto_url.text gern aus, um dir die Ausgabe anzusehen.

Übergebe anschließend crypto_url.text an pd.read_html(). Die Funktion liefert eine Liste von DataFrames, in der jedes Listenelement einer Tabelle (DataFrame) auf der cryptocurrency-Seite entspricht.

crypto_data = pd.read_html(crypto_url.text)

Lass dir Länge und Typ der Rückgabe ausgeben. Der Typ sollte eine Liste sein.

len(crypto_data), type(crypto_data)

(1, list)

Die Ausgabe zeigt, dass genau eine Tabelle gefunden wurde – verpackt in einer Liste.

crypto_data = crypto_data[0]

Entferne nun die erste und zweite Spalte, da sie keine nützlichen Informationen enthalten. Behalte alle Zeilen.

crypto_final = crypto_data.iloc[:,2:]

Jetzt ist es Zeit, das cryptocurrency-DataFrame auszugeben!

crypto_final.head()

Aus der Tabelle ist ersichtlich, dass Bitcoin die höchste Market Cap hat.

NaN-Werte entfernen (Not a Number)

Einige Werte im DataFrame sind keine echten Messwerte. Entfernen wir sie aus der Tabelle.

Lösche zunächst die Spalte Price Charts 7d, da sie ausschließlich NaN enthält und keinen Informationswert hat.

del crypto_final['Price Charts 7d']

crypto_final.head()

Jetzt entfernen wir die NaN-Werte.

crypto_final = crypto_final.dropna()

Crypto-Coins visualisieren: Ticker vs. prozentuale Preisänderung (%)

Importiere zunächst matplotlib zum Plotten.

import matplotlib.pyplot as plt
%matplotlib inline

Die Spalte % hat den Typ string und muss in float konvertiert werden. Entferne zuerst das %-Zeichen und wandle die Spalte dann in Float um.

crypto_final['%'] = crypto_final['%'].apply(lambda x: x.strip('%'))

crypto_final['%'] = crypto_final['%'].astype('float')

Jetzt wird geplottet.

plt.figure()
plt.figure(figsize=(16,10))
x = crypto_final.iloc[:20]['Ticker']
y = crypto_final.iloc[:20]['%']
plt.xticks(fontsize=12)
plt.yticks(fontsize=14)
plt.xlabel('Percentage Increase/Decrease in Price',fontsize=20)
plt.ylabel('Ticker',fontsize=20)

plt.plot(x,y,label='% Increase/Decrease in Price')
plt.legend(loc='lower left',prop={'size': 15})

<matplotlib.legend.Legend at 0x1298a9630>

<Figure size 432x288 with 0 Axes>

Im Diagramm siehst du, dass Litecoin (LTC) und Huobitoken (HT) den größten Preisanstieg verzeichnen, während Maticnetwork (MATIC) und Waves den stärksten Rückgang zeigen.

Pickle-Daten laden

Pickle ist ein Python-spezifisches binäres Serialisierungsformat und im Gegensatz zu JSON nicht menschenlesbar. Es dient dem Serialisieren und Deserialisieren von Python-Objektstrukturen. Objekte wie DataFrames, Listen oder Dictionaries werden in einen Bytestrom umgewandelt und auf der Festplatte gespeichert.

Der große Vorteil von Pickle: Es kann viele verschiedene Python-Datentypen speichern.

Pickle wird häufig genutzt, um trainierte Machine-Learning-Modelle zu speichern. Ähnlich wie bei JSON gibt es praktische Funktionen wie pickle.load() zum Laden und pickle.dump() zum Speichern im Pickle-Format.

Ein weiterer Vorteil: Als Pickle gespeicherte DataFrames belegen weniger Speicherplatz und behalten beim erneuten Laden ihre Datentypen bei.

Lass uns das zuvor erstellte Cryptocurrency-DataFrame picklen und anschließend mit pandas wieder einlesen.

import pickle

Mit pickle.dump speicherst du das DataFrame als Pickle-Objekt. Verwende als protocol HIGHEST_PROTOCOL, das auch rückwärtskompatibel zu Python 2 ist.

with open('crypto_final.pickle', 'wb') as sub_data:
    pickle.dump(crypto_final, sub_data, protocol=pickle.HIGHEST_PROTOCOL)

Zum Schluss wandelst du das pickle-Objekt mit der pandas-Funktion read_pickle wieder in ein DataFrame um.

crypto_final = pd.read_pickle('crypto_final.pickle')

crypto_final.head()

Stark, oder? So unkompliziert ist das. Und dank Pickle musst du dir um Datentyp-Konvertierungsfehler keine Sorgen machen – die pickle-Serialisierung kümmert sich darum!

Geh noch weiter

Glückwunsch – du hast das Tutorial abgeschlossen.

Du hast einen guten Einstieg bekommen, wie du verschiedene Datenformate mit pandas in Python lädst.

Es gibt noch viele weitere Formate wie Excel, SQL, HDF5 usw., die unter das pandas-Datenimportdach fallen. Such dir spannende öffentliche Datensätze in diesen Formaten und probiere sie aus.

Wenn du mehr über DataFrames in pandas lernen möchtest, nimm an DataCamps interaktivem Kurs Data Manipulation with pandas teil. Außerdem findest du viele hilfreiche pandas-Tutorials zu Themen wie DataFrames zusammenführen, Gleitende Durchschnitte berechnen und die apply-Methode nutzen. Oder wenn du ganz neu bei pandas bist, starte mit dieser Einsteigeranleitung.

Quellen:

• JSON Data in Python
• pandas Tutorial: Importing Data with read_csv()

Stell gern deine Fragen zu diesem Tutorial in den Kommentaren.