3 Wege, HTTP-Aufrufe mit Python-Requests durchzuführen (Anfänger bis Fortgeschrittene)

Die Fähigkeit, eine HTTP-Anfrage zu stellen, ist für die Interaktion von Applications mit dem Web unerlässlich. Wenn Sie Python verwenden, egal ob Sie einen Web Scraper bauen, RESTful APIs nutzen oder auf andere Weise mit dem Web interagieren müssen, ist das Requests-Modul von Python die beliebteste und am einfachsten zu verwendende Option. In diesem Beitrag werden wir drei Stufen von HTTP-Anfragen mit dem Requests-Modul erforschen, beginnend mit den Grundlagen und aufbauend auf fortgeschrittenen Techniken. Am Ende werden Sie in der Lage sein, Requests in der Produktion einzusetzen!

Die übergeordneten Codebeispiele in diesem Beitrag stammen aus dem Vonage Python SDKunserem SDK, mit dem Sie APIs für Messaging, Voice, Video, 2-Faktor-Authentifizierung und vieles mehr aufrufen können - und das alles mit Python. Wir verwenden das Requests-Modul, um all dies und noch mehr zu tun, daher ist es das perfekte Beispielprojekt für die Verwendung von Requests.

Steigern wir unser Antragsspiel und beginnen wir mit Stufe 1... jetzt gleich!

Stufe 1: Einfache HTTP-Anfragen

Auf der grundlegenden Ebene haben wir grundlegende HTTP-Anfragen. Diese sind das tägliche Brot für Python-Entwickler, die mit Webdiensten interagieren müssen. Das Requests-Modul macht es unglaublich einfach, GET- und POST-Anfragen auszuführen, mit denen Sie mühelos Webseiten abrufen oder Daten an einen Server senden können.

Installieren Sie zunächst die Anforderungen in einer virtuellen Umgebung Ihrer Wahl:

Sobald Sie Ihre virtuelle Umgebung aktiviert und die Anforderungen installiert haben, können Sie sie sofort nutzen. Hier ist ein Beispiel für eine GET-Anfrage, um den Inhalt einer Webseite abzurufen:

import requests

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

Wenn Sie den obigen Code ausführen, sollten Sie den gesamten HTML-Code der https://example.com Seite anzeigen. Aber wir können mehr tun, als nur Webseiten mit Anfragen zu erhalten!

Hier ist eine POST-Anfrage, bei der wir Daten an eine URL senden:

import requests

data = {'vonage': 'loves', 'python': '!'}
response = requests.post('https://httpbin.org/post', json=data)
print(response.json())

Die Antwort, die in ein Python-Wörterbuch serialisiert wurde, sehen Sie unten. Beachten Sie, dass sie die von uns geposteten Daten enthält:

{'args': {}, 'data': '{"vonage": "loves", "python": "!"}', 'files': {}, 'form': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Content-Length': '34', 'Content-Type': 'application/json', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.31.0', 'X-Amzn-Trace-Id': 'Root=1-65012480-007aeecf146f5ff007c7678d'}, 'json': {'python': '!', 'vonage': 'loves'}, 'origin': '82.30.197.62', 'url': 'https://httpbin.org/post'}

Mit diesen einfachen Beispielen können Sie bereits erste HTTP-Anfragen in Python stellen. Was aber, wenn Sie Einstellungen über mehrere Anfragen hinweg beibehalten oder Ressourcen gemeinsam nutzen wollen? Hier kommt Level 2 ins Spiel!

Ebene 2: Verwendung von Sitzungen für Persistenz

HTTP-Sitzungen sind eine Möglichkeit, Einstellungen über mehrere Anfragen an denselben Server hinweg beizubehalten. Sitzungen verwenden auch Verbindungspooling, was bedeutet, dass Sie bei mehreren HTTP-Aufrufen an dieselben Hosts dieselben Ressourcen verwenden und dadurch erhebliche Leistungssteigerungen erzielen können!

Wenn einer dieser Punkte auf Sie zutrifft, sollten Sie eine Sitzung nutzen:

• Wenn Sie eine zustandsabhängige Verbindung aufrechterhalten müssen, z. B. bei der Arbeit mit authentifizierten APIs oder Webanwendungen.

• Wenn Sie viele Anfragen an dieselbe API/denselben Host stellen und keine Zeit und Ressourcen verschwenden wollen.

Das Modul Requests bietet ein Session-Objekt, mit dem Sie genau das tun können. Hier ist ein Beispiel:

import requests

# Create a session
session = requests.Session()

# Set headers to be sent in every request
session.headers.update({'Accepts': 'application/json'})

# Perform multiple requests within the same session
response1 = session.get('https://example.com/some-page')
response2 = session.get('https://example.com/some-other-page')

Die Verwendung einer Sitzung auf diese Weise bedeutet, dass alle Cookies, die wir setzen, beibehalten werden. Wir können auch Standardwerte für eine Sitzung festlegen, indem wir sie zum Sitzungsobjekt hinzufügen, wie wir es oben mit dem gesendeten Header getan haben. Das ist unglaublich nützlich, aber der Hauptgrund für die Verwendung von Session-Objekten im Vonage Python SDK ist, dass unsere Benutzer damit sehr schnell viele API-Aufrufe tätigen können.

Hier ist ein Beispiel für die Leistungsvorteile der Verwendung einer HTTP-Sitzung. Der folgende Code verwendet KEINE Sitzung, sondern führt 100 separate API-Aufrufe an die Vonage Number Insight API um Informationen für 100 verschiedene Numbers abzurufen und sie in das internationale E.164-Format zu konvertieren:

import requests
import time

start_time = time.perf_counter()

number_conversions = {}
params = {'api_key': 'MY_API_KEY', 'api_secret': 'MY_API_SECRET', 'country': 'GB'}

for i in range(100):
    phone_number = str(1614960100 + i)
    params['number'] = phone_number
    
    with requests.get(
        'https://api.nexmo.com/ni/basic/json',
        params=params,
    ) as response:
        number_conversions[phone_number] = response.json()[
            'international_format_number'
        ]

elasped_time = time.perf_counter() - start_time
print(f'Time elapsed is: {elasped_time} seconds.')

Wir erhalten die folgende Ausgabe: Time elapsed is: 11.103735665994463 seconds. Es dauerte also über 11 Sekunden, um 100 API-Aufrufe auszuführen, was nicht schlecht ist, aber viel besser sein könnte.

Ich habe den Code oben profiliert, hier ist eine Eiszapfenplot-Visualisierung mit snakeviz:

Vanilla requests icicle plot

Wir sehen, dass wir die meiste Zeit (mehr als 10/11 Sekunden) mit dem Verbindungspooling verbracht haben. Die Verwendung einer Sitzung, die es mehreren HTTP-Aufrufen ermöglicht, ein gemeinsames Connection Pooling zu verwenden und Ressourcen gemeinsam zu nutzen, sollte diese Zeitspanne verringern. Schauen wir uns das mal an.

Wenn wir ein Sitzungsobjekt für die Number Insight API-Aufrufe verwenden, können wir den Unterschied erkennen:

with requests.Session() as session:

    for i in range(100):
        phone_number = str(441614960100 + i)
        params['number'] = phone_number
    
        with session.get(
            'https://api.nexmo.com/ni/basic/json',
            params=params,
        ) as response:
            number_conversions[phone_number] = response.json()[
                'international_format_number'
            ]

Dieses Mal erhalten wir diese Ausgabe: Time elapsed is: 4.058261167003366 seconds. Das ist fast dreimal so schnell! In diesem Eiszapfen-Diagramm des Programms können wir sehen, dass unser System im Verhältnis weniger Zeit für das Pooling von Verbindungen aufwendet, und dass die verwendete Zeit viel effizienter genutzt wird, als wenn wir 100 separate Anfragen stellen, wie wir es oben getan haben.

Session requests case icicle plot

Wir sehen also, dass Sie durch die Verwendung einer Sitzung Dinge wie Cookies und Header automatisch handhaben können, was Ihren Code sauberer und effizienter macht. Was aber, wenn Sie noch mehr Kontrolle über Ihre HTTP-Anfragen benötigen oder Ihre Verbindungen feiner abstimmen wollen? Dann ist es Zeit für Stufe 3.

Ebene 3: Nutzung eines HTTP-Adapters für erweiterte Einstellungen

Jetzt sind wir bereit für die fortgeschrittenste Stufe, auf der wir das Verhalten von HTTP-Anfragen auf einer sehr niedrigen Ebene anpassen, einschließlich Einstellungen wie Verbindungspooling und Wiederholungen. Mit Requests können wir diese Eigenschaften auf niedriger Ebene einstellen, indem wir einen HTTP-Adapter verwenden, den Sie in ein Session-Objekt einbinden können, um Ihre benutzerdefinierten Einstellungen für die gesamte Sitzung zu verwenden. In Requests verwenden wir ein Objekt namens HTTPAdapter um dies zu tun.

Hier sehen Sie, wie Sie das HTTPAdapter Objekt verwenden, um benutzerdefinierte Einstellungen zu konfigurieren:

import requests
from requests.adapters import HTTPAdapter

session = requests.Session()

# Create an HTTPAdapter object and configure connection pooling and retries
adapter = HTTPAdapter(pool_connections=20, pool_maxsize=5, max_retries=3)

# Mount the HTTPAdpater object to the session
session.mount('https://', adapter)

response = session.get('https://example.com')

Dies kann auch mit anfragespezifischen Werten wie dem Timeout (z. B. session.get('https://example.com', timeout=10)) kombiniert werden, um eine feinkörnige Kontrolle pro Anfrage zu ermöglichen.

Die Verwendung eines HTTP-Adapters gibt Ihnen die Kontrolle über die Art und Weise, wie Ihre HTTP-Anfragen gestellt werden, und ermöglicht eine Feinabstimmung des Verhaltens Ihrer Anwendung, um Ihre spezifischen Anforderungen zu erfüllen.

Bonus: Ein geeignetes Python-SDK verwenden

Unter . Python-SDK von Vonagemachen wir uns all diese Techniken zunutze, um Anfragen auf die effektivste Weise zu senden. Wir verwenden eine Sitzung und erlauben den Benutzern, die Einstellungen für Anfragen und HTTP-Adapter zu konfigurieren, wenn sie ein Client Objekts. Der folgende Code zeigt, wie dieselbe Anfrage wie oben ausgeführt wird, um 100 Number Insight API-Aufrufe zu tätigen, aber dieses Mal wird das Vonage Python SDK für die Aufrufe verwendet.

import vonage

client = vonage.Client(key='MY_API_KEY', secret='MY_API_SECRET')
number_conversions = {}

for i in range(100):
    phone_number = str(1614960100 + i)
    response = client.number_insight.get_basic_number_insight(
        country='GB', number=phone_number
    )
    number_conversions[phone_number] = response['international_format_number']

Wenn Sie eine der Standardeinstellungen anpassen möchten, wie pool_connections oder Anfrage timeoutanpassen möchten, können Sie dies bei der Erstellung des client Objekts angeben.

Der Vorteil der Verwendung des Vonage SDK für den Aufruf von Vonage APIs ist, dass Sie sich nicht um die Anfragelogik kümmern müssen. Sie geben an, was passieren soll, und das SDK kümmert sich für Sie darum. Viele andere Dienste verfügen über ähnliche SDKs, um die Logik zu abstrahieren, die für Sie vielleicht nicht wichtig ist, aber Ihnen die Möglichkeit gibt, in die Details einzutauchen, wenn Sie es brauchen oder wollen.

Einpacken

In diesem Blogbeitrag haben wir die drei Stufen von HTTP-Anfragen mit dem Python-Modul Requests erkundet, von einfachen Anfragen bis hin zu fortgeschrittenen Anpassungen mit Sessions und HTTP-Adaptern. Wenn Sie diese Stufen beherrschen, sind Sie gut gerüstet, um eine Vielzahl von webbezogenen Aufgaben in Ihren Python-Projekten zu bewältigen.

Denken Sie daran, dass jede Stufe auf der vorherigen aufbaut. Beginnen Sie also mit den Grundlagen und steigen Sie schrittweise auf, wenn sich die Anforderungen Ihres Projekts weiterentwickeln. HTTP-Anfragen sind ein grundlegender Aspekt der Webentwicklung, und mit dem Modul Requests steht Ihnen ein leistungsfähiges Werkzeug zur Verfügung, um sie effektiv zu bearbeiten.

Wenn Sie die APIs von Vonage nutzen möchten, können Sie sich sich für einen kostenlosen Entwickler Account anmelden (mit kostenlosen Credits!)

Wenn Sie Fragen zu diesem Artikel haben, können Sie sich gerne an uns wenden auf unserem Vonage Community Slack und fragen Sie uns dort, oder indem Sie uns eine Nachricht auf X, früher bekannt als Twitter.

Experimentieren Sie also mit verschiedenen Ebenen von HTTP-Anfragen und befähigen Sie Ihre Python Applications, wie ein Profi mit dem Web zu interagieren!