Die besten Python-HTTP-Clients für Web Scraping

HTTP-Clients sind hilfreiche Python-Bibliotheken, die es Ihrem Code ermöglichen, Requests (Anfragen) an Webserver oder APIs zu senden und Responses (Antworten) zu empfangen. Sie erleichtern das Senden verschiedener Arten von HTTP-Requests (GET, POST, PUT, DELETE usw.), das Abrufen von Daten, das Übermitteln von Daten oder das Ausführen von Aktionen auf Websites oder APIs.

Wenn es um Web Scraping geht, werden diese Clients oft zusammen mit HTML-Parsing-Bibliotheken wie Beautiful Soup oder html5lib verwendet.

In diesem Artikel werfen Sie einen Blick auf einige der besten Python-HTTP-Clients, darunter Requests, urllib3, Uplink, gRequests, HTTPX und aiohttp. Sie bewerten jedes Produkt anhand seiner Funktionen, seiner Benutzerfreundlichkeit, seiner Dokumentation und seines Supports sowie seiner Beliebtheit. Am Ende dieses Artikels werden Sie eine bessere Vorstellung davon haben, welche Bibliothek für Ihren Anwendungsfall am besten geeignet ist.

Requests

Beginnen wir mit dem beliebtesten Python-HTTP-Client: der Requests -Bibliothek mit beeindruckenden 30 Millionen Downloads pro Woche.

Hier ist ein Beispiel dafür, wie Sie HTTP-Requests und Responses mit Requests behandeln können:

import requests

print("Testing `requests` library...")
resp = requests.get('https://httpbin.org/get', params={"foo": "bar"})
if resp.status_code == 200:     # success
    print(f"Response Text: {resp.text} (HTTP-{resp.status_code})")
else:   # error
    print(f"Error: HTTP-{resp.status_code}")

Beachten Sie, dass httpbin.org Beispiel-Responses zum Testen verschiedener HTTP-Methoden bereitstellt.

In diesem Codeausschnitt verwendet die Methode requests.get(...) die gewünschte URL und einen einzelnen Abfrageparameter, foo. Sie können beliebige Abfrageparameter mit dem Argument params übergeben.

Bei Requests und anderen HTTP-Clients müssen Sie Ihren URLs keine Abfragezeichenfolgen manuell hinzufügen oder Ihre Daten verschlüsseln; die Bibliothek erledigt das für Sie. Um JSON-Daten zu senden, übergeben Sie ein Python-Dictionary mit dem Argument data , und Sie können die JSON-Response direkt mit resp.json() empfangen.

Die Requests-Bibliothek verarbeitet standardmäßig automatisch HTTP-Weiterleitungen (3xx), was beim Web Scraping nützlich ist, um auf Inhalte von umgeleiteten URLs zuzugreifen. Sie unterstützt auch Secure Sockets Layer (SSL)-Verbindungen.

Unter der Haube verwendet Requests urllib3, um HTTP-Aufgaben auf niedriger Ebene wie Verbindungspooling und SSL-Verifizierung zu verwalten, wodurch Entwicklern eine übergeordnete, pythonischere API geboten wird.

Darüber hinaus unterstützt Requests die Sitzungsverwaltung, sodass Sie Parameter wie Cookies, Header oder Authentifizierungstoken über mehrere Requests hinweg beibehalten können. Dies ist besonders nützlich für Web-Scraping-Aufgaben, bei denen die Aufrechterhaltung solcher Parameter für den Zugriff auf eingeschränkte Inhalte unerlässlich ist.

Die Requests-Bibliothek unterstützt auch Streaming, was für Web-Scraping-Aufgaben hilfreich ist, die umfangreiche Responses erfordern, z. B. das Herunterladen von Dateien oder das Verarbeiten von Streaming-Daten von APIs.

Um Response-Daten effizient zu verarbeiten, ohne alles in den Speicher zu laden, können Sie Methoden wie iter_content () oder iter_lines () verwenden:

import requests

print("Testing `requests` library with streaming...")
resp = requests.get('https://httpbin.org/stream/10', stream=True)
for chunk in resp.iter_content(chunk_size=1024):
    print(chunk.decode('utf-8'))

Der Requests-Bibliothek fehlen jedoch integrierte asynchrone Funktionen und integrierte Caching-Unterstützung (obwohl diese über requests-cache verfügbar ist). Darüber hinaus unterstützt Requests kein HTTP/2 und es ist unwahrscheinlich, dass es bald hinzugefügt wird, wie in dieser Diskussionangegeben.

Hinweis: HTTP/2 ist die neuere Version des HTTP-Protokolls, das schneller und effizienter als HTTP/1.1 ist. Es ermöglicht mehrere Requests und Responses über eine einzige TCP-Verbindung (Transmission Control Protocol) durch Multiplexing, was zu weniger Client-Server-Verbindungen und einem schnelleren Laden der Seiten führt. Die Unterstützung für HTTP/2 ist jedoch immer noch begrenzt.

Die Requests-Bibliothek vereinfacht Pythons HTTP-Interaktionen. Sie zeichnet sich durch einfache Methoden, präzise Syntax, automatisches Verbindungspooling für Effizienz und integrierte JSON-Dekodierung aus. Die einfache Bedienung, die Sitzungsverwaltung, die Streaming-Funktionen und die umfangreiche Dokumentation machen sie zu einer beliebten Wahl für Entwickler.

urllib3

urllib3 ist eine gut getestete und weit verbreitete Bibliothek für HTTP-Requests –nicht nur für Entwickler, sondern auch für viele andere HTTP-Clients. Es bietet nützliche Funktionen und Anpassungsoptionen für die Bearbeitung von HTTP-Requests auf niedriger Ebene beim Web Scraping.

Hier ist ein einfaches Beispiel, das urllib3 verwendet, um eine HTTP-Request auszuführen:

import urllib3

print("Testing `urllib3` library...")
http = urllib3.PoolManager()    # PoolManager for connection pooling
resp = http.request('GET', 'https://httpbin.org/get', fields={"foo": "bar"})

if resp.status == 200:     # success
    print(f"Response: {resp.data.decode('utf-8')} (HTTP-{resp.status})")
else:    # error
    print(f"Error: HTTP-{resp.status}")

In diesem Code-Snippet erstellt urllib3.PoolManager() einen Pool von Verbindungen, die für mehrere Requests wiederverwendet werden können. Dadurch wird die Performance verbessert, da der Aufwand für das Herstellen neuer Verbindungen für jede Request vermieden wird. Zusammen mit der URL können Sie die erforderlichen Abfrageparameter mithilfe des Arguments fields übergeben.

Eine bemerkenswerte Funktion von urllib3 ist die Fähigkeit, Streaming-Responses zu verarbeiten, sodass Sie große Datenmengen effizient verarbeiten können, ohne alles in den Speicher zu laden. Dies ist nützlich, um große Dateien herunterzuladen oder Streaming-APIs beim Web Scraping zu verwenden.

urllib3 unterstützt standardmäßig die automatische Weiterleitung und verfügt über eine integrierte SSL-Unterstützung. Es fehlen jedoch integrierte asynchrone Funktionen, Caching-Unterstützung sowie Sitzungsverwaltung (wie Cookies), und HTTP/2 wird nicht unterstützt.

Obwohl urllib3 das Connection-Pooling weniger benutzerfreundlich macht als die Requests-Bibliothek, verwendet urllib3 im Gegensatz zu einigen Clients, die einen klassenbasierten Ansatz oder Decorators benötigen, eine einfache Skriptsyntax, was urllib3 für grundlegende HTTP-Interaktionen nützlich macht. Zusätzlich enthält urllib3 eine gut gepflegte Dokumentation.

Wenn Sie eine leistungsstarke Bibliothek und kein Sitzungsmanagement benötigen, eignet sich urllib3 hervorragend für einfache Web-Scraping-Aufgaben.

Uplink

Uplink ist ein leistungsfähiger, aber weniger bekannter Python-HTTP-Client. Er vereinfacht Interaktionen mit RESTful-APIs mithilfe klassenbasierter Schnittstellen und ist daher besonders nützlich für Web Scraping, das API-Aufrufe beinhaltet.

Schauen Sie sich diesen Beispielcode an, der Uplink verwendet, um einen API-Endpunkt aufzurufen:

import uplink

@uplink.json
class JSONPlaceholderAPI(uplink.Consumer):
    @uplink.get("/posts/{post_id}")
    def get_post(self, post_id):
        pass


def demo_uplink():
    print("Testing `uplink` library...")
    api = JSONPlaceholderAPI(base_url="https://jsonplaceholder.typicode.com")
    resp = api.get_post(post_id=1)
    if resp.status_code == 200:     # success
        print(f"Response: {resp.json()} (HTTP-{resp.status_code})")
    else:   # error
        print(f"Error:HTTP-{resp.status_code}")

Dieser Code-Snippet definiert eine JSONPlaceholderApi-Klasse, die von upLink.Consumer übernimmt. Er verwendet den @uplink.get–Decorator, um eine HTTP-GET-Request für die JSONPlaceholder-API zu erstellen, um einen bestimmten Post abzurufen. Der Parameter post_id wird mit diesem Decorator dynamisch in den Endpunkt aufgenommen: @uplink.get("/posts/{post_id}"). Die Website https://jsonplaceholder.typicode.com simuliert eine REST-API und bietet JSON-Responses zum Testen und Entwickeln.

Uplink unterstützt SSL und verarbeitet automatisch Weiterleitungen, um die finale Response abzurufen. Es bietet auch erweiterte Funktionen wie Bring Your Own HTTP Library (Bringen Sie Ihre eigene HTTP-Bibliothek mit).

Uplink hat jedoch keine integrierte Unterstützung für Streaming-Responses, asynchrone Requests, Caching (obwohl es requests-cacheverwenden kann) und HTTP/2.

Uplink bietet eine angemessene Dokumentation für seine leistungsstarken Funktionen, aber es wird nicht aktiv gepflegt (das letzte Release war 0.9.7 im März 2022) und ist nicht sehr beliebt. Der klassenbasierte Ansatz und die Decorator-Syntax mögen zwar objektorientierte Entwickler ansprechen, aber für diejenigen, die den Skriptstil von Python bevorzugen, bietet es nur mäßigen Bedienkomfort.

Benutzer wählen Uplink normalerweise, wenn sie Daten hauptsächlich von verschiedenen RESTful-API-Endpunkten und nicht von HTML-Seiten sammeln müssen.

GRequests

GRequests ist eine Erweiterung der bekannten Requests-Bibliothek, die Unterstützung für asynchrone Requests bietet. Es ermöglicht das gleichzeitige Abrufen von Daten von mehreren Websites oder APIs.

Im Gegensatz zu sequentiellen Requests, die auf jede Response warten, bevor die nächste gesendet wird, erhöht GRequests die Effizienz, indem Requests gleichzeitig gesendet werden. Dies ist besonders vorteilhaft für das Abrufen von Daten von mehreren Websites oder APIs.

Sehen Sie sich dieses Beispiel an:

import grequests

print("Testing `grequests` library...")
# Fetching data from multiple URLs
urls = [
    'https://www.python.org/',
    'http://httpbin.org/get',
    'http://httpbin.org/ip',
]

responses = grequests.map((grequests.get(url) for url in urls))
for resp in responses:
    print(f"Response for: {resp.url} ==> HTTP-{resp.status_code}")

In diesem Code sendet GRequests gleichzeitig drei GET-Requests mit grequests.map(...) an verschiedene URLs und sammelt die Responses in einer Liste mit dem Namen responses. Dann durchläuft es diese Responses, um sie zu drucken. Intern verwendet GRequests gevent, eine Coroutinen-basierte Netzwerkbibliothek, für asynchrone HTTP-Requests. Auf diese Weise können Sie mehrere HTTP-Requests gleichzeitig senden, ohne eine komplexe Parallelität zu verwalten. Eine praktische Anwendung hierfür könnte darin bestehen, Nachrichten von verschiedenen Websites für ein bestimmtes Thema oder eine bestimmte Kategorie zu durchsuchen.

GRequests unterstützt auch Funktionen wie die automatische Verarbeitung von Weiterleitungen, SSL-Unterstützung und die Verarbeitung von Streaming-Responses, ohne sie alle auf einmal in den Speicher zu laden. Beachten Sie jedoch, dass GRequests keine integrierte HTTP/2-Unterstützung oder Caching-Funktionen hat, obwohl es requests-cache verwenden kann.

GRequests vereinfacht asynchrone HTTP-Requests mit intuitiven Methoden, die der Basisbibliothek Requests ähneln. Es macht komplexe async/await -Konstrukte überflüssig, um Parallelität zu handhaben, was die Verwendung vereinfacht. Die Dokumentation ist jedoch aufgrund ihrer winzigen Codebasis (213 Zeilen in der Version 0.7.0) und der reduzierten Entwicklungsaktivität minimal. Diese Faktoren tragen zu seiner geringeren Beliebtheit bei.

Sie sollten GRequests aufgrund seiner benutzerfreundlichen asynchronen Funktionen in Betracht ziehen, wenn Sie Daten aus mehreren Quellen gleichzeitig erfassen müssen.

HTTPX

HTTPX ist ein moderner und funktionsreicher HTTP-Client für Python, der häufig für alle Arten von Web-Scraping-Projekten verwendet wird. Es wurde entwickelt, um Pythons Requests-Bibliothek zu ersetzen und gleichzeitig asynchrone Unterstützung und höhere Leistung zu bieten.

Das folgende Beispiel zeigt eine asynchrone HTTP-GET-Request mit HTTPX:

import httpx
import asyncio

async def fetch_posts():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://jsonplaceholder.typicode.com/posts')
        return response.json()

async def httpx_demo():
    print("Testing `httpx` library...")
    posts = await fetch_posts()
    for idx, post in enumerate(posts):
        print(f"Post #{idx+1}: {post['title']}")

# async entry point to execute the code
asyncio.run(httpx_demo())

Dieser Code definiert eine asynchrone Funktion namens fetch_posts(), die Dummy-Blogbeiträge von der https://jsonplaceholder.typicode.com/posts-API mithilfe von httpx.asyncClient() abruft. Eine weitere asynchrone Funktion, httpx_demo (), wartet darauf, dass fetch_posts () diese Posts zurückgibt, und druckt dann ihre Titel in einer Schleife aus. Schließlich dient asyncio.run(httpx_demo()) als Einstiegspunkt für die asynchrone Ausführung von httpx_demo().

Neben der integrierten Unterstützung für asynchrone HTTP-Clients bietet HTTPX auch integrierte HTTP/2-Unterstützung. Dies ermöglicht ein schnelleres Laden mehrerer Ressourcen gleichzeitig über eine einzige TCP-Verbindung, was es für Websites schwieriger macht, Ihren Browser-Fingerabdruck beim Web Scraping zu verfolgen.

Um eine HTTP/2-Request zu senden, setzen Sie einfach den Parameter http2=True, wenn Sie einen HTTPX-Client erstellen:

import httpx

client = httpx.Client(http2=True)
response = client.get("https://http2.github.io/")
print(response)

Denken Sie daran, dass Sie HTTPX mit seiner http2-Unterstützung installieren müssen, um HTTP/2 zu verwenden:

pip install httpx[http2]

Darüber hinaus bietet HTTPX eine hervorragende Unterstützung für Streaming-Responses, sodass Sie große Responses oder Datenströme effizient verarbeiten können, ohne die gesamte Response in den Speicher zu laden.

Hier ist ein Beispiel für eine Streaming-Text-Response mit HTTPX:

with httpx.stream("GET", "https://httpbin.org/stream/10") as resp:
   for text in resp.iter_text():
       print(text)

HTTPX enthält zwar keine integrierten Caching-Funktionen, aber Sie können stattdessen Hishel verwenden.

HTTPX folgt standardmäßig keinen HTTP-Weiterleitungen, aber Sie können dies mit dem Parameter follow_redirects aktivieren:

import httpx

# test http --> https redirect
response = httpx.get('http://github.com/', follow_redirects=True)

Obwohl die asynchronen Funktionen die Komplexität erhöhen, bietet HTTPX einfache Methoden für die HTTP-Kommunikation und unterstützt benutzerfreundliche synchrone Requests. Dies macht es sowohl für Anfänger als auch für erfahrene Entwickler zugänglich. Darüber hinaus wächst seine Nutzung dank seiner umfangreichen Dokumentation und einer aktiven Community von Entwicklern, die Tools für die HTTPX-Integration entwickeln.

Wenn Sie nach einem funktionsreichen, asynchronen HTTP-Client suchen, sollten Sie HTTPX in Betracht ziehen.

aiohttp

Ähnlich wie HTTPX bietet aiohttp eine integrierte asynchrone Unterstützung für HTTP-Requests. aiohttp ist jedoch ausschließlich für die asynchrone Programmierung konzipiert, sodass es sich in Szenarien, die gleichzeitige und nicht blockierende Requests erfordern, hervorragend eignet. Dadurch eignet es sich gut für leistungsstarke Web-Scraping-Projekte und ist einfach mit Proxys zu verwenden.

So können Sie aiohttp verwenden, um mehrere URLs gleichzeitig zu scrapen:

import asyncio
import aiohttp

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()    

async def demo_aiohttp():
    print("Testing `aiohttp` library...")
    urls = [
        'https://www.python.org/',
        'http://httpbin.org/get',
        'http://httpbin.org/ip',
    ]
    tasks = [fetch_data(url) for url in urls]
    responses = await asyncio.gather(*tasks)
    for resp_text in responses:
        print(f"Response: {resp_text}")

# async entry point to execute the code      
asyncio.run(demo_aiohttp())

Die asynchrone Funktion aiohttp erstellt eine aiohttp.ClientSession() und sendet eine GET-Request an die angegebene URL. Anschließend erstellt es eine Liste von Aufgaben für jede URL und führt sie gleichzeitig mit asyncio.gather(...) aus. Sobald alle Aufgaben abgeschlossen sind, werden die gescrapten Daten (in diesem Fall der Response-Text) gesammelt und gedruckt. Die eigentliche Ausführung wird mit asyncio.run(demo_aiohttp())initiiert.

aiohttp verarbeitet automatisch HTTP-Weiterleitungen und unterstützt Streaming-Responses, wodurch eine effiziente Verwaltung großer Dateien oder Datenströme ohne übermäßigen Speicherverbrauch gewährleistet wird. Es bietet auch Flexibilität mit einer Vielzahl von Middleware und Erweiterungen von Drittanbietern.

Zusätzlich kann aiohttp bei Bedarf als Entwicklungsserver dienen, obwohl sich dieser Artikel ausschließlich auf die HTTP-Client-Funktionalität konzentriert.

Allerdings fehlt aiohttp die Unterstützung für HTTP/2 und die eingebauten Caching-Funktionen. Dennoch können Sie bei Bedarf das Caching mithilfe von Bibliotheken wie aiohttp-client-cache integrieren.

aiohttp kann komplizierter zu bedienen sein als einfachere HTTP-Clients wie Requests, insbesondere für Anfänger. Sein asynchroner Charakter und seine zusätzlichen Funktionen erfordern ein gutes Verständnis der asynchronen Programmierung in Python. Mit 14.700 Sternen auf GitHub und zahlreichen Bibliotheken von Drittanbietern , die darauf aufbauen, ist aiohttp jedoch sehr beliebt und bietet Entwicklern eine umfassende Dokumentation .

Wenn Sie nach vollwertiger asynchroner Unterstützung suchen, sollten Sie aiohttp in Betracht ziehen. Aufgrund seiner asynchronen Leistung eignet es sich ideal für Daten-Scraping-Aufgaben in Echtzeit, wie z. B. die Überwachung von Aktienkursen oder die Verfolgung von Live-Ereignissen wie Wahlen, während sie stattfinden.

In der folgenden Tabelle finden Sie einen schnellen Überblick über die wichtigsten Python-HTTP-Clients:

Fazit

In diesem Artikel haben Sie alles über einige beliebte Python-HTTP-Clients erfahren, darunter Requests, urllib3, Uplink, GRequests, HTTPX und aiohttp, die jeweils einzigartige Funktionen wie Einfachheit, asynchrone Unterstützung, Streaming und HTTP/2 bieten.

Während Requests, Uplink und GRequests für ihre Einfachheit bekannt sind, bieten aiohttp und HTTPX leistungsstarke asynchrone Funktionen. Obwohl Requests nach wie vor am beliebtesten ist, gewinnen aiohttp und HTTPX aufgrund ihrer asynchronen Fähigkeiten an Bedeutung. Letztendlich müssen Sie jeden einzelnen prüfen, um denjenigen zu wählen, die Ihren Anforderungen entspricht.

Wenn es um Web Scraping im wirklichen Leben geht, müssen Sie mehr als nur Ihren HTTP-Client berücksichtigen, z. B. die Umgehung von Anti-Bot-Maßnahmen und die Verwendung von Proxys. Zum Glück kann Bright Data helfen.

Bright Data erleichtert das Web Scraping mit Tools wie der Web Scraper IDE, die vorgefertigte JavaScript-Funktionen und Vorlagen bietet, und dem Web Unlocker, der CAPTCHAs und Anti-Bot-Maßnahmen umgeht. Der  Scraping Browser von Bright Data lässt sich in Puppeteer, Playwright und Selenium für die mehrstufige Datenerfassung integrieren. Darüber hinaus ermöglichen die Proxy-Netzwerke und Dienste von Bright Data den Zugriff von verschiedenen Standorten aus. Diese Tools erledigen komplexe Aufgaben wie die Verwaltung von Proxys und das Lösen von CAPTCHAs, sodass Sie sich darauf konzentrieren können, die benötigten Daten zu erhalten.

Starten Sie noch heute Ihre kostenlose Testversion und erleben Sie alles, was Bright Data zu bieten hat.