Kurze Einführung in das Parsen von JSON mit JMESPath in Python

Hallo! JSON hat sich schnell zum beliebtesten Datenformat im modernen Web entwickelt. Als Web-Scraping-Experte mit über fünf Jahren Erfahrung habe ich miterlebt, wie sich JSON von einem Nischendatenformat zur Verkehrssprache für Web-APIs und Websites entwickelt hat.

In diesem Beitrag möchte ich Ihnen JMESPath vorstellen – eine praktische Python-Bibliothek zum Parsen und Verarbeiten von JSON-Daten. Mit dem Aufkommen von JSON ist JMESPath zu einem unverzichtbaren Werkzeug in meiner Web-Scraping-Toolbox geworden.

Werfen wir einen praktischen Blick auf die Funktionsweise von JMESPath, damit Sie es in Ihren Python-Skripten und Web-Scrapern verwenden können!

Der rasante Aufstieg von JSON

Lassen Sie uns zunächst kurz diskutieren warum JSON so beliebt geworden ist im Internet. JSON steht für JavaScript Object Notation und erfreut sich seit seiner ersten Formalisierung Anfang der 2000er Jahre stetig wachsender Beliebtheit.

Hier sind einige Statistiken zur Einführung von JSON:

• Auf über 70 % der modernen Web-APIs Verwenden Sie JSON für die Datenübertragung
• Um 60% der Websites stellen jetzt in gewisser Weise JSON-Daten bereit
• Beliebte Websites wie Twitter, Reddit und Facebook bieten alle an JSON-basierte APIs
• JSON ist bis zu 4x beliebter als XML für Webdaten insgesamt

JSON hat sich aufgrund seiner integrierten JavaScript-Unterstützung, der einfachen Syntax, der geringen Dateigröße und der einfachen Analyse zum bevorzugten Format für Webdaten entwickelt.

Für uns Web-Scraper bedeutet das, dass die von uns gewünschten Daten zunehmend in rohen und strukturierten JSON-Dokumenten verfügbar sind. Allerdings ist die Erfassung dieser nützlichen Daten nicht immer einfach.

Obwohl JSON überall zu finden ist, handelt es sich bei rohem JSON, das von Websites extrahiert wurde, oft um Folgendes:

• Enorm – enthält Unmengen überschüssiger Daten, die wir nicht benötigen
• Verschachtelte – mit Daten, die in komplexen Objekten und Arrays verborgen sind
• Unhandlich – es fehlen leicht extrahierbare Felder und Werte

Hier kommt JMESPath zur Rettung!

Was ist JMESPath?

JMESPath (ausgesprochen „James Path“) ist eine Abfragesprache, die speziell für das Parsen von JSON-Daten entwickelt wurde.

Mit JMESPath schreiben Sie Ausdrücke an:

• Wählen Sie einfach verschachtelte JSON-Felder aus
• JSON-Arrays filtern
• Komplexes JSON in einfachere Strukturen umwandeln
• Sortieren, begrenzen und transformieren Sie JSON programmgesteuert

JMESPath wurde von Amazon entwickelt (die sich mit der Verarbeitung von JSON auskennen!) und für verschiedene Programmiersprachen implementiert.

Für Python verwenden wir die jmespath Modul, das eine saubere API für die Verwendung von JMESPath zum Parsen von JSON bereitstellt.

Einige Beispiele dafür, was Sie tun können:

• Auswählen bestimmte Felder aus JSON-Dokumenten
• Filter Arrays von JSON-Objekten
• Ebnen verschachtelte JSON in einfache Listen und Werte
• Umformen JSON-Daten in für Python geeignete Formen
• Sortieren und Begrenzen Arrays von JSON-Daten

JMESPath ermöglicht die einfache Arbeit selbst mit sehr komplexem JSON in Python.

JMESPath in Python installieren

JMESPath kann einfach mit pip installiert werden:

pip install jmespath

Importieren Sie es nach der Installation in Ihre Python-Skripte:

import jmespath

Und Sie können mit dem Parsen von JSON beginnen!

JSON mit JMESPath-Grundlagen abfragen

Der Kern von JMESPath ist das Ausdrucken Pfade um einen Drilldown in JSON-Dokumente durchzuführen.

Einige Beispiele für grundlegende JMESPath-Ausdrücke:

Wähle aus name Feld aus einem JSON-Objekt:

data = {‘name‘: ‘John‘, ‘age‘: 30}

jmespath.search(‘name‘, data)
# ‘John‘

Holen Sie sich alle Namen aus einer Liste von JSON-Objekten:

data = [
  {‘name‘: ‘John‘, ‘age‘: 30},
  {‘name‘: ‘Sarah‘, ‘age‘: 25}
]

jmespath.search(‘[*].name‘, data)
# [‘John‘, ‘Sarah‘] 

Holen Sie sich das erste Element aus einem JSON-Array:

data = {‘hobbies‘: [‘hiking‘, ‘reading‘, ‘coding‘]}  

jmespath.search(‘hobbies[0]‘, data)
# ‘hiking‘

Wie Sie sehen, verwendet JMESPath eine JavaScript-ähnliche Syntax mit Punktnotation und Array-Indizierung.

Schauen wir uns nun einige erweiterte Funktionen an.

Filtern von Arrays von JSON-Objekten

Eine häufige Aufgabe ist das Filtern von Arrays von JSON-Objekten basierend auf Bedingungen.

JMESPath macht das Filtern von JSON-Arrays zum Kinderspiel.

Wir können Benutzer beispielsweise nach Alter filtern:

data = [
  {‘name‘: ‘Sarah‘, ‘age‘: 25},
  {‘name‘: ‘Mark‘, ‘age‘: 19},
  {‘name‘: ‘John‘, ‘age‘: 30}    
]

jmespath.search(‘[?age > `28`].name‘, data) 
# [‘John‘]

Das [?age >28] Der Filter wählt Elemente aus, deren Alter größer als 28 ist.

Sie können nach Zeichenfolgen, Zahlen, verschachtelten Objekten filtern – so ziemlich nach allem in Ihren JSON-Daten.

JSON-Daten reduzieren und projizieren

Eine weitere äußerst nützliche JMESPath-Funktion ist das Reduzieren und Projizieren von JSON in andere Formen.

Beispielsweise können wir verschachteltes JSON mit in eine einfache Liste „flachen“. [] Projektionen:

data = {
  ‘product‘: {
    ‘id‘: 123, 
    ‘name‘: ‘Widget‘,
    ‘colors‘: [‘blue‘,‘green‘]    
  }
}

jmespath.search(‘product.[id, name, colors[]]‘, data) 

# [123, ‘Widget‘, ‘blue‘, ‘green‘]

Ebenso können wir JSON-Objekte mit in andere JSON-Objekte umformen {} Projektionen:

data = {
  ‘product‘: {
    ‘id‘: 123,
    ‘name‘: ‘Super Widget‘,
    ‘price‘: 9.99,
    ‘dimensions‘: {
      ‘length‘: 10,
      ‘width‘: 5     
    }
  }
}

jmespath.search("""
  product.{  
    id: id,
    name: name,     
    price_usd: price,
    length_cm: dimensions.length,
    width_cm: dimensions.width   
  }   
""", data)

# {‘id‘: 123,  
#  ‘name‘: ‘Super Widget‘,
#  ‘price_usd‘: 9.99,
#  ‘length_cm‘: 10,
#  ‘width_cm‘: 5}

Projektionen ermöglichen die einfache Umformung selbst komplexer verschachtelter JSON-Dateien in einfache Formate wie Listen und Diktate, die für Python nützlich sind.

JSON-Arrays sortieren, begrenzen und aufteilen

JMESPath bietet einige hilfreiche Möglichkeiten, Arrays von JSON-Daten zu verarbeiten:

data = [ 
  {‘name‘: ‘Sarah‘, ‘age‘: 25},
  {‘name‘: ‘Mark‘, ‘age‘: 19},
  {‘name‘: ‘John‘, ‘age‘: 30}
]

# Sort by age
jmespath.search(‘[*].age | sort(@)‘, data)  
# [19, 25, 30]  

# Slice first 2 elements 
jmespath.search(‘[*][:2]‘, data)
# [{‘name‘: ‘Sarah‘, ‘age‘: 25}, {‘name‘: ‘Mark‘, ‘age‘: 19}]

# Limit to 2 elements
jmespath.search(‘[*][0:2]‘, data)    
# [{‘name‘: ‘Sarah‘, ‘age‘: 25}, {‘name‘: ‘Mark‘, ‘age‘: 19}]

Dadurch können wir große Arrays aus JSON-Dokumenten übernehmen und genau die Bits extrahieren, die wir benötigen.

JMESPath für Web Scraping

Nachdem wir uns nun mit den Grundlagen der JSON-Abfrage mit JMESPath befasst haben, sehen wir uns die Anwendung beim Web Scraping an.

In diesem Beispiel extrahieren wir Immobilieneintragsdaten von Realtor.com. Die gewünschten Daten befinden sich in einem JSON-Skript-Tag auf jeder Auflistungsseite.

Hier ist eine Beispielauflistung:

https://www.realtor.com/realestateandhomes-detail/335-30th-Ave_San-Francisco_CA_94121_M17833-49194

Zuerst durchsuchen wir die Seite und holen uns das JSON-Skript:

import requests
from parsel import Selector 

url = "https://www.realtor.com/realestateandhomes-detail/335-30th-Ave_San-Francisco_CA_94121_M17833-49194"

response = requests.get(url)
selector = Selector(text=response.text)

json_data = selector.css(‘script#__NEXT_DATA__::text‘).get()

Dies gibt uns ein JSON-Objekt mit Tausende von Zeilen, die alle Auflistungsdaten enthalten.

Hier ist nur ein kleiner Ausschnitt:

{
  "building": {
    "rooms": {
      "baths": 4,
      "beds": 4,
      "total_rooms": null,
      "room_type": null
    },
    "building_size": {
      "size": 3066,
      "units": null
    }, 
    "parking": {
      "spaces": null,
      "description": null,
      "parking_type": null
    }
   }
   // and lots more!   
}

Anstatt dieses riesige Objekt zu analysieren, können wir JMESPath verwenden, um nur das abzufragen, was wir tatsächlich wollen:

import json
import jmespath

data = json.loads(json_data) 

result = jmespath.search("""
  {
    id: listing_id,   
    facts: {
      beds: building.rooms.beds,
      baths: building.rooms.baths,
      sqft: building.building_size.size
    },
    price: list_price  
  }
""", data) 

print(result)

Dies druckt nur die Felder, die wir wollen:

{‘id‘: ‘2950457253‘,
 ‘facts‘: {‘beds‘: 4, ‘baths‘: 4, ‘sqft‘: 3066},
 ‘price‘: 2995000} 

Mit JMESPath konnten wir Tausende JSON-Zeilen in ein sauberes Python-Wörterbuch mit genau den gewünschten Feldern analysieren.

Wir könnten jetzt ganz einfach Daten über alle Einträge sammeln, indem wir URLs durchgehen und bei jeder Iteration JSON mit JMESPath extrahieren.

Vergleich mit anderen JSON-Parsern

Es gibt einige andere beliebte JSON-Parsing-Optionen in Python:

• JSON-Pfad – Ähnliche Abfragesprache wie JMESPath, jedoch weniger umfassend
• jq – Leistungsstarker JSON-Prozessor, erfordert jedoch das Erlernen einer einzigartigen Syntax
• json.load() – Integrierter Python-JSON-Parser, erfordert jedoch viel Code

Meiner Erfahrung nach bietet JMESPath die beste Balance für einfaches und dennoch leistungsstarkes JSON-Parsing in Python.

Einige wichtige Vorteile von JMESPath:

• Prägnante Abfragesyntax
• Schnelle Leistung für große JSON-Dokumente
• Leicht zu erlernende Ausdrücke
• Hervorragende Dokumentation und Community-Unterstützung
• Anspruchsvolle Objektprojektion
• Speziell für JSON entwickelt

Für das schnelle Parsen von Web-Scraping-JSON ist JMESPath meine erste Wahl.

Weitere JMESPath-Ressourcen

Hier sind einige weitere großartige Ressourcen zum Beherrschen von JMESPath:

• JMESPath-Beispiele – Offizielles Repo mit mehr Codeschnipseln
• JMESPath-Tutorials – Video-Komplettlösung für Ausdrücke
• JMESPath-Spezifikation – Vollständige Sprachgrammatik
• JMESPath-Erweiterungsbibliotheken – Tools, die die JMESPath-Funktionalität erweitern

Insbesondere empfehle ich das Spielen mit dem JMESPath-Terminal Hier können Sie Ausdrücke schnell anhand von JSON-Beispieldaten ausprobieren.

Lassen Sie uns den gesamten JSON analysieren!

Vielen Dank, dass Sie an dieser kurzen Einführung in das Parsen von JSON mit JMESPath in Python teilgenommen haben. Ich hoffe, Sie fanden es hilfreich!

Hier ist eine kurze Zusammenfassung dessen, was wir behandelt haben:

• Was ist JMESPath? – Eine Abfragesprache zum Filtern, Reduzieren und Transformieren von JSON-Daten.
• Warum es wichtig ist – JSON ist zum dominierenden Webdatenformat geworden.
• Wie installiert man - pip install jmespath
• Grundlagen der Abfrage – Punktnotation, Array-Indizierung, Filter usw.
• Abflachung/Vorsprung – Umgestaltung von komplexem verschachteltem JSON.
• Sortieren/Schneiden – JSON-Arrays streiten.
• Beispiel für Web Scraping – Extrahieren von Daten von realtor.com mit JMESPath.

Mit dem Aufkommen von JSON kann ein Tool wie JMESPath das Extrahieren nützlicher Daten aus gecrackten Websites und APIs enorm vereinfachen.

Lassen Sie mich wissen, wenn Sie weitere Fragen haben! Ich helfe immer gerne anderen Web-Scrapern.

Gehen Sie jetzt los und nutzen Sie JMESPath, um all das saftige JSON im Web zu sammeln!