HTML von einer URL mit Python abrufen

Requests-Bibliothek zur Abfrage von HTML von URLs

Um HTML von URLs mit Python abzurufen, kannst du die beliebte Requests-Bibliothek verwenden. Sie bietet eine benutzerfreundliche Schnittstelle und eine Vielzahl von Funktionen, die das Abrufen von Webinhalten vereinfachen.

Verwendung von Requests.get()

Die Hauptfunktion, die du verwenden wirst, ist requests.get(). Sie nimmt eine URL als Argument und stellt eine GET-Anfrage an die Website. Wenn die Anfrage erfolgreich ist, wird ein Response-Objekt zurückgegeben, das den HTML-Inhalt der Seite enthält.

Abrufen des HTML-Inhalts

Um den HTML-Inhalt aus dem Response-Objekt abzurufen, kannst du die get_text()-Methode verwenden. Sie gibt den HTML-Inhalt als Unicode-Zeichenfolge zurück.

import requests

url = 'https://example.com'
response = requests.get(url)
print(response.text)

Fehlerbehandlung

Es ist wichtig, Fehlerbehandlungscodes in deinen Code zu integrieren, um Probleme bei der Verbindungsherstellung oder beim Abrufen von Inhalten zu behandeln. Die Response-Objekte verfügen über Eigenschaften wie status_code und reason, die Informationen über den Status der Anfrage liefern.

Anpassung von Anfragen

Die Requests-Bibliothek bietet mehrere Argumente, mit denen du Anfragen anpassen kannst. Dazu gehören Zeitüberschreitungen, Header und Proxys.

import requests

url = 'https://example.com'
headers = {'User-Agent': 'Mozilla/5.0'}
response = requests.get(url, headers=headers)

Umgang mit Encodierungen

HTML-Inhalte können in verschiedenen Encodierungen vorliegen. Die Requests-Bibliothek versucht, die Encodierung automatisch zu ermitteln, aber du kannst auch eine bestimmte Encodierung angeben, indem du die encoding-Eigenschaft des Response-Objekts setzt.

Verwendung der urlopen()-Funktion zur Verbindung zu Websites

Die urlopen()-Funktion aus der urllib.request-Bibliothek ermöglicht dir die Verbindung zu einer Website-URL und das Abrufen ihres Inhalts. Hier erfährst du, wie du diese Funktion verwenden kannst:

Syntax

from urllib.request import urlopen

url = "https://www.example.com"
response = urlopen(url)

Beispiel

Betrachten wir ein Beispiel, in dem wir die urlopen()-Funktion verwenden, um eine Verbindung zur Website von Python.org herzustellen:

import urllib.request

url = "https://www.python.org"
response = urllib.request.urlopen(url)

Parameter

• url: Die URL der Website, zu der eine Verbindung hergestellt werden soll.
• timeout: Optional. Ein Zeitlimit (in Sekunden) für die Verbindung. Wenn die Website nicht innerhalb des Zeitlimits antwortet, wird eine URLError-Ausnahme ausgelöst.
• cafile: Optional. Der Pfad zu einer Zertifizierungsstelle (CA), die zum Überprüfen von SSL-Zertifikaten verwendet werden soll.
• capath: Optional. Der Pfad zu einem Verzeichnis von CA-Zertifikaten, die zum Überprüfen von SSL-Zertifikaten verwendet werden sollen.

Abrufen des HTML-Inhalts mit get_text()-Methode

Sobald du eine Verbindung zu einer Website hergestellt hast, kannst du deren HTML-Inhalt abrufen. Die get_text()-Methode der requests.Response-Klasse liefert den gesamten HTML-Text des Dokuments als Unicode-Zeichenfolge.

Funktionsweise

Um den HTML-Inhalt abzurufen, rufst du einfach die get_text()-Methode des Response-Objekts auf. Der zurückgegebene Text enthält den gesamten HTML-Code, einschließlich Tags, Attribute und Inhalt.

import requests

response = requests.get("https://example.com")
html_text = response.text

Umgang mit Encodierung

Der HTML-Inhalt kann in verschiedenen Zeichencodierungen vorliegen. Um sicherzustellen, dass der Text korrekt angezeigt wird, solltest du die Zeichencodierung des Dokuments bestimmen und gegebenenfalls in Unicode konvertieren.

Die requests-Bibliothek versucht, die Zeichencodierung anhand des Content-Type-Headers zu ermitteln. Wenn der Header nicht vorhanden ist oder die Encodierung nicht erkannt wird, verwendet die Bibliothek UTF-8 als Standard.

Du kannst die Zeichencodierung auch manuell festlegen, indem du das Argument encoding der get_text()-Methode verwendest.

Fehlerbehandlung

Es ist wichtig, Fehler bei der Abfrage des HTML-Inhalts zu behandeln. Mögliche Fehler sind:

• Verbindungsfehler
• Fehler beim Abrufen des Inhalts
• Fehler bei der Encodierung

Du solltest diese Fehler abfangen und entsprechende Maßnahmen ergreifen, z. B. eine alternative URL versuchen oder die Anforderung erneut senden.

Optimierung der Abfrageleistung

Wenn du mehrere Anfragen sendest oder große HTML-Dokumente abrufst, kannst du die Abfrageleistung optimieren. Hier sind einige Tipps:

• Verwende Sitzungen, um Verbindungen wiederzuverwenden.
• Setze Zeitüberschreitungen für Anfragen.
• Komprimiere HTML-Dokumente mit Gzip.

Fehlerbehandlung bei Verbindungs- oder Inhaltsabrufproblemen

Fehler können auftreten, wenn du versuchst, HTML von einer URL abzurufen. Diese Probleme können auf Verbindungsprobleme oder Probleme beim Abrufen des Inhalts selbst zurückzuführen sein.

Umgang mit Verbindungsproblemen

Wenn du auf Verbindungsprobleme stößt, solltest du die folgende Vorgehensweise in Betracht ziehen:

• Überprüfe deine Internetverbindung: Stelle sicher, dass dein Gerät mit dem Internet verbunden ist.
• Verwende einen Proxy-Server: Versuche, über einen Proxy-Server eine Verbindung herzustellen, wenn du von einem eingeschränkten Netzwerk aus zugreifst.
• Setze die Zeitüberschreitung für die Verbindung: Verwende das Argument timeout im request.get-Aufruf, um eine Zeitüberschreitung für die Verbindung festzulegen.
• Fange Verbindungsfehler ab: Verwende try–except-Blöcke, um Verbindungsfehler abzufangen und entsprechende Fehlermeldungen auszugeben.

Umgang mit Problemen beim Inhaltsabruf

Wenn du Probleme beim Abrufen des HTML-Inhalts hast, kannst du die folgenden Maßnahmen ergreifen:

• Überprüfe den HTTP-Statuscode: Der Statuscode der Antwort gibt Auskunft über den Erfolg oder Misserfolg der Anfrage. Übliche Fehlercodes sind 404 (nicht gefunden), 403 (verboten) und 500 (interner Serverfehler).
• Behandle unterschiedliche Encodierungen: Webinhalte können in verschiedenen Encodierungen wie UTF-8 oder ISO-8859-1 vorliegen. Verwende die encoding-Methode im Response-Objekt, um die richtige Encodierung zu ermitteln.
• Fange Ausnahmen für Inhaltsabruf ab: Verwende try–except-Blöcke, um Ausnahmen abzufangen, die beim Abrufen des Inhalts auftreten können.

Indem du diese Fehlerbehandlungsmechanismen implementierst, kannst du robuste HTML-Abfrageanwendungen erstellen, die mit verschiedenen Fehlerszenarien umgehen können.

Zusätzliche Argumente zum Anpassen von Anfragen (z. B. Zeitüberschreitung, Header)

Wenn du spezielle Anforderungen für deine HTML-Abfragen hast, kannst du zusätzliche Argumente an die requests.get()-Funktion übergeben, um sie anzupassen.

Zeitüberschreitung festlegen

Standardmäßig ist die Zeitüberschreitung für Anfragen auf 5 Sekunden gesetzt. Wenn du eine längere Zeitüberschreitung benötigst, kannst du das timeout-Argument angeben:

import requests

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

# Setze eine Zeitüberschreitung von 10 Sekunden
response = requests.get(url, timeout=10)

Header hinzufügen

In HTTP-Anfragen werden Header verwendet, um zusätzliche Informationen über die Anfrage bereitzustellen. Du kannst benutzerdefinierte Header mit dem headers-Argument hinzufügen:

import requests

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

# Füge einen benutzerdefinierten Header hinzu
headers = {'Benutzer-Agent': 'Mein benutzerdefinierter Agent'}
response = requests.get(url, headers=headers)

Cookies übergeben

Cookies werden verwendet, um den Status zwischen Anfragen zu speichern. Du kannst Cookies mit dem cookies-Argument übergeben:

import requests

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

# Erstelle ein Cookie-Objekt
cookie = requests.cookies.CookieJar()
cookie.set('session_id', 'ABC123')

# Übergebe Cookies an die Anfrage
response = requests.get(url, cookies=cookie)

Authentifizierung aktivieren

Für Websites, die eine Authentifizierung erfordern, kannst du das auth-Argument verwenden, um Anmeldeinformationen anzugeben:

import requests

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

# Gib Anmeldeinformationen an
auth = ('username', 'password')
response = requests.get(url, auth=auth)

Umgang mit verschiedenen Encodierungen im HTML-Inhalt

Beim Abrufen von HTML von URLs ist es wichtig, sich der verschiedenen Encodierungen bewusst zu sein, die zum Speichern des Inhalts verwendet werden können. HTML-Dokumente können in einer Vielzahl von Encodierungen wie UTF-8, UTF-16 und ISO-8859-1 codiert sein.

Wenn du den HTML-Inhalt abrufst, kann es vorkommen, dass du aufgrund von Encodierungsproblemen auf seltsame Zeichen oder verstümmelten Text stößt. Um dieses Problem zu lösen, musst du die richtige Encodierung des Dokuments identifizieren und verwenden, um den Inhalt korrekt anzuzeigen.

Encodierung erkennen

Es gibt verschiedene Möglichkeiten, die Encodierung eines HTML-Dokuments zu erkennen:

• Überprüfe die Content-Type-Header der HTTP-Antwort. Diese enthalten in der Regel Informationen zur Encodierung.
• Suche nach einer meta-Tag im HTML-Dokument, das die Encodierung angibt, z. B. <meta charset="utf-8">.
• Verwende die chardet-Bibliothek, um die Encodierung anhand einer Stichprobe des HTML-Inhalts zu ermitteln.

Encodierung konvertieren

Sobald du die Encodierung identifiziert hast, musst du den abgerufenen HTML-Inhalt gegebenenfalls in eine andere Encodierung konvertieren, die für deine Anwendung geeignet ist. Dies kann mithilfe der decode()-Methode der bytes-Klasse erfolgen, z. B.:

html_bytes = requests.get(url).content
html_decoded = html_bytes.decode("utf-8")

Wenn du die Encodierung nicht kennst, kannst du versuchen, sie mithilfe einer Bibliothek wie chardet zu erraten:

import chardet

html_bytes = requests.get(url).content
encoding = chardet.detect(html_bytes)["encoding"]
html_decoded = html_bytes.decode(encoding)

Best Practice

Um Probleme im Zusammenhang mit Encodierungen zu vermeiden, solltest du beim Abrufen von HTML folgende Best Practices beachten:

• Identifiziere die Encodierung des Dokuments immer, bevor du den Inhalt abrufst.
• Konvertiere den Inhalt in die gewünschte Encodierung, bevor du ihn weiterverarbeitest.
• Verwende eine zuverlässige Bibliothek wie chardet oder universal-encoding-detector, um die Encodierung zu erkennen, insbesondere wenn du HTML von verschiedenen Quellen abrufst.

Möglichkeiten zur Optimierung von HTML-Abfragen für Leistung

Um sicherzustellen, dass deine Python-Skripte für den Abruf von HTML von URLs effizient und zuverlässig sind, solltest du Folgendes beachten:

Zeitüberschreitung einstellen

Verwende den timeout-Parameter in der urlopen()-Funktion, um eine maximale Zeitspanne für eine Antwort festzulegen. Dadurch wird verhindert, dass dein Skript auf eine langsame Verbindung wartet und Zeit verschwendet.

Header-Informationen festlegen

Du kannst die headers-Information in der Request-Klasse angeben, um zusätzliche Informationen an den Zielserver zu senden. Dies kann verwendet werden, um Spoofing zu vermeiden und die Wahrscheinlichkeit zu erhöhen, dass der Server die Anfrage bearbeitet.

Verbindungspooling verwenden

Einige HTTP-Bibliotheken wie requests bieten Verbindungspooling, das Wiederverwenden von Verbindungen ermöglicht. Dies kann die Leistung bei wiederholten Abfragen auf denselben Server deutlich verbessern.

Caching implementieren

Wenn du weißt, dass du mehrmals auf dieselbe URL zugreifen musst, kannst du den HTML-Inhalt zwischenspeichern und aus dem Cache abrufen, anstatt jedes Mal eine neue Abfrage durchzuführen. Dies kann die Leistung erheblich verbessern, insbesondere bei Ressourcen, die selten geändert werden.

Komprimierung aktivieren

Überprüfe, ob der Zielserver die HTTP-Komprimierung unterstützt. Wenn dies der Fall ist, kannst du die Accept-Encoding-Header-Information in deiner Request-Klasse festlegen, um Komprimierung anzufordern. Dies kann die Größe der Antwort verringern und die Übertragungszeit verkürzen.

Proxy-Server nutzen

Wenn du Abfragen über einen Proxy-Server durchführst, kannst du die Anonymität deiner Abfragen verbessern und geografische Einschränkungen umgehen. Dies kann jedoch zu zusätzlicher Latenz führen.