Schnelle Einführung in Python-Anfragen

In diesem Artikel wird hauptsächlich das Schnellstart-Tutorial für die Verwendung von Python-Anfragen vorgestellt. Es ist sehr einfach, Anfragen zum Senden von Netzwerkanfragen zu verwenden. Weitere Informationen zu spezifischen Betriebsmethoden finden Sie in diesem Artikel.

Schnell loslegen

Sie können es kaum erwarten? Diese Seite bietet eine gute Anleitung für den Einstieg in Anfragen. Es wird davon ausgegangen, dass Sie Requests installiert haben. Wenn Sie es noch nicht getan haben, gehen Sie zum Installationsbereich und werfen Sie einen Blick darauf.

Stellen Sie zunächst sicher, dass:

Requests installiert ist.

Requests auf dem neuesten Stand ist.

Beginnen wir mit einigen einfachen Beispielen.

Eine Anfrage senden

Das Senden von Netzwerkanfragen ist mit Requests sehr einfach.

Importieren Sie zunächst das Modul „Anfragen“:

>>> import requests

Versuchen Sie dann, eine Webseite zu erstellen. In diesem Beispiel rufen wir die öffentliche Zeitleiste von Github ab:

>>> r = requests.get('https://github.com/timeline.json')

Jetzt haben wir ein Antwortobjekt namens r. Wir können alle gewünschten Informationen von diesem Objekt erhalten.

Requests Simple API bedeutet, dass alle HTTP-Anfragetypen offensichtlich sind. Sie könnten beispielsweise eine HTTP-POST-Anfrage wie diese senden:

>>> r = requests.post(http://httpbin.org/post)

Hübsch, oder? Was ist mit den anderen HTTP-Anfragetypen: PUT, DELETE, HEAD und OPTIONS? Sie sind alle gleich einfach:

>>> r = requests.put("http://httpbin.org/put")
>>> r = requests.delete("http://httpbin.org/delete")
>>> r = requests.head("http://httpbin.org/get")
>>> r = requests.options(http://httpbin.org/get)

Sie sind alle gut, aber das ist nur die Spitze des Eisbergs der Anfragen.

Übergabe von URL-Parametern

Vielleicht möchten Sie häufig Daten für die Abfragezeichenfolge der URL übergeben. Wenn Sie die URL manuell erstellen, werden die Daten als Schlüssel/Wert-Paare gefolgt von einem Fragezeichen in die URL eingefügt. Beispiel: httpbin.org/get?key=val. Mit Anfragen können Sie das Schlüsselwortargument params verwenden, um diese Parameter als Wörterbuch mit Zeichenfolgen bereitzustellen. Wenn Sie beispielsweise key1=value1 und key2=value2 an httpbin.org/get übergeben möchten, können Sie den folgenden Code verwenden:

>>> payload = {'key1': 'value1', 'key2': 'value2'}
>>> r = requests.get("http://httpbin.org/get", params=payload)

Durch Drucken In der Ausgabe der URL können Sie sehen, dass die URL korrekt codiert wurde:

>>> print(r.url)
http://httpbin.org/get?key2=value2&key1=value1

Beachten Sie, dass keiner der Wörterbuchschlüssel mit dem Wert None hinzugefügt wird zur darin enthaltenen URL-Abfragezeichenfolge.

Sie können auch eine Liste als Wert übergeben:

>>> payload = {'key1': 'value1', 'key2': ['value2', 'value3']}
>>> r = requests.get('http://httpbin.org/get', params=payload)
>>> print(r.url)
http://httpbin.org/get?key1=value1&key2=value2&key2=value3

Antwortinhalt

Wir können den Inhalt der Serverantwort lesen. Am Beispiel der GitHub-Timeline:

>>> import requests
>>> r = requests.get('https://github.com/timeline.json')
>>> r.text
u'[{"repository":{"open_issues":0,"url":"https://github.com/...

Anfragen dekodieren Inhalte automatisch vom Server. Die meisten Unicode-Zeichensätze können nahtlos dekodiert werden.

Nachdem eine Anfrage gestellt wurde, erstellt Requests anhand der HTTP-Header eine fundierte Vermutung über die Antwortkodierung. Wenn Sie auf r.text zugreifen, verwendet Requests die abgeleitete Textkodierung. Sie können herausfinden, welche Codierung Requests verwendet, und diese mithilfe der Eigenschaft r.encoding ändern:

>>> r.encoding
'utf-8'
>>> r.encoding = 'ISO-8859-1'

Wenn Sie die Codierung ändern, wann immer Sie auf r zugreifen .text und Request verwenden alle den neuen Wert von r.encoding. Möglicherweise möchten Sie die Kodierung ändern, nachdem Sie eine spezielle Logik zur Berechnung der Kodierung des Texts verwendet haben. Beispielsweise können HTTP und XML selbst Codierungen angeben. In diesem Fall sollten Sie r.content verwenden, um die Codierung zu finden, und dann r.encoding auf die entsprechende Codierung festlegen. Dadurch kann r.text mit der richtigen Codierung analysiert werden.

Anfragen können bei Bedarf auch eine benutzerdefinierte Codierung verwenden. Wenn Sie Ihre eigene Kodierung erstellen und diese beim Codecs-Modul registrieren, können Sie den Decodernamen einfach als Wert von r.encoding verwenden und Requests die Kodierung für Sie übernehmen lassen.

Binärer Antwortinhalt

Sie können bei Nicht-Text-Anfragen auch auf den Anforderungsantworttext in Bytes zugreifen:

>>> r.content
b'[{"repository":{"open_issues":0,"url":"https://github.com/...

Anfragen dekodieren gzip automatisch und entleeren die übertragungskodierten Antwortdaten für Sie.

Um beispielsweise ein Bild aus den von der Anfrage zurückgegebenen Binärdaten zu erstellen, können Sie den folgenden Code verwenden:

>>> from PIL import Image
>>> from io import BytesIO
>>> i = Image.open(BytesIO(r.content))

JSON-Antwortinhalt

Requests verfügt außerdem über einen integrierten JSON-Decoder, der Sie bei der Verarbeitung von JSON-Daten unterstützt:

>>> import requests
>>> r = requests.get('https://github.com/timeline.json')
>>> r.json()
[{u'repository': {u'open_issues': 0, u'url': 'https://github.com/...

Wenn die JSON-Dekodierung fehlschlägt, löst r.json() eine Ausnahme aus. Wenn die Antwort beispielsweise 401 (Unauthorized) lautet, wird beim Versuch, auf r.json() zuzugreifen, die Ausnahme „ValueError: No JSON object Could be decoded“ ausgelöst.

Es ist zu beachten, dass ein erfolgreicher Aufruf von r.json() nicht den Erfolg der Antwort bedeutet. Einige Server enthalten ein JSON-Objekt in der Fehlerantwort (z. B. HTTP 500-Fehlerdetails). Dieser JSON wird dekodiert und zurückgegeben. Um zu überprüfen, ob die Anfrage erfolgreich war, verwenden Sie r.raise_for_status() oder prüfen Sie, ob r.status_code Ihren Erwartungen entspricht.

Ursprünglicher Antwortinhalt

在罕见的情况下，你可能想获取来自服务器的原始套接字响应，那么你可以访问 r.raw。 如果你确实想这么干，那请你确保在初始请求中设置了 stream=True。具体你可以这么做：

>>> r = requests.get('https://github.com/timeline.json', stream=True)
>>> r.raw
<requests.packages.urllib3.response.HTTPResponse object at 0x101194810>
>>> r.raw.read(10)
&#39;\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03&#39;

但一般情况下，你应该以下面的模式将文本流保存到文件：

with open(filename, 'wb') as fd:
 for chunk in r.iter_content(chunk_size):
  fd.write(chunk)

使用 Response.iter_content 将会处理大量你直接使用 Response.raw 不得不处理的。 当流下载时，上面是优先推荐的获取内容方式。 Note that chunk_size can be freely adjusted to a number that may better fit your use cases.

定制请求头

如果你想为请求添加 HTTP 头部，只要简单地传递一个 dict 给 headers 参数就可以了。

例如，在前一个示例中我们没有指定 content-type:

>>> url = 'https://api.github.com/some/endpoint'
>>> headers = {'user-agent': 'my-app/0.0.1'}
>>> r = requests.get(url, headers=headers)

注意: 定制 header 的优先级低于某些特定的信息源，例如：

如果在 .netrc 中设置了用户认证信息，使用 headers= 设置的授权就不会生效。而如果设置了auth= 参数，``.netrc`` 的设置就无效了。

如果被重定向到别的主机，授权 header 就会被删除。

代理授权 header 会被 URL 中提供的代理身份覆盖掉。

在我们能判断内容长度的情况下，header 的 Content-Length 会被改写。

更进一步讲，Requests 不会基于定制 header 的具体情况改变自己的行为。只不过在最后的请求中，所有的 header 信息都会被传递进去。

注意: 所有的 header 值必须是 string、bytestring 或者 unicode。尽管传递 unicode header 也是允许的，但不建议这样做。

更加复杂的 POST 请求

通常，你想要发送一些编码为表单形式的数据——非常像一个 HTML 表单。要实现这个，只需简单地传递一个字典给 data 参数。你的数据字典在发出请求时会自动编码为表单形式：

>>> payload = {'key1': 'value1', 'key2': 'value2'}

>>> r = requests.post("http://httpbin.org/post", data=payload)
>>> print(r.text)
{
  ...
  "form": {
    "key2": "value2",
    "key1": "value1"
  },
  ...
}

你还可以为 data 参数传入一个元组列表。在表单中多个元素使用同一 key 的时候，这种方式尤其有效：

>>> payload = (('key1', 'value1'), ('key1', 'value2'))
>>> r = requests.post('http://httpbin.org/post', data=payload)
>>> print(r.text)
{
  ...
  "form": {
    "key1": [
      "value1",
      "value2"
    ]
  },
  ...
}

很多时候你想要发送的数据并非编码为表单形式的。如果你传递一个 string 而不是一个 dict，那么数据会被直接发布出去。

例如，Github API v3 接受编码为 JSON 的 POST/PATCH 数据：

>>> import json
>>> url = 'https://api.github.com/some/endpoint'
>>> payload = {'some': 'data'}
>>> r = requests.post(url, data=json.dumps(payload))

此处除了可以自行对 dict 进行编码，你还可以使用 json 参数直接传递，然后它就会被自动编码。这是 2.4.2 版的新加功能：

>>> url = 'https://api.github.com/some/endpoint'
>>> payload = {'some': 'data'}
>>> r = requests.post(url, json=payload)

POST一个多部分编码(Multipart-Encoded)的文件

Requests 使得上传多部分编码文件变得很简单：

>>> url = 'http://httpbin.org/post'
>>> files = {'file': open('report.xls', 'rb')}
>>> r = requests.post(url, files=files)
>>> r.text
{
  ...
  "files": {
    "file": "29a1523db4da14c32d48e307909783a5"
  },
  ...
}

你可以显式地设置文件名，文件类型和请求头：

>>> url = 'http://httpbin.org/post'
>>> files = {'file': ('report.xls', open('report. xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}
>>> r = request.post(url, files=files)
>>> r.text
{
...
"files": {
"file": "29a1523db4da14c32d48e307909783a5 "
},
...
}

Wenn Sie möchten, können Sie den empfangenen String auch als Datei senden:

>>> url = 'http://httpbin.org/post'
>>> files = {'file': ('report.csv', 'some,data,to,sendnanother,row,to,sendn ' )}

>>> r = request.post(url, files=files)
>>> r.text
{
...
„files“: {
„file“: „some,data,to,send\nanother,row,to,send\n“
},
...
}

Wenn Sie eine sehr große Datei als mehrteilige/Formulardaten-Anfrage senden, möchten Sie die Anfrage möglicherweise streamen. Standardmäßig werden Anfragen nicht unterstützt, es gibt jedoch einen Paket-Requests-Toolbelt eines Drittanbieters, der dies unterstützt. Sie können die Toolbelt-Dokumentation lesen, um zu erfahren, wie Sie es verwenden.

Senden mehrerer Dateireferenzen in einer Anfrage im Abschnitt „Erweiterte Nutzung“.

Warnung

Wir empfehlen dringend, die Datei im Binärmodus zu öffnen. Dies liegt daran, dass Requests möglicherweise versucht, Ihnen einen Content-Length-Header bereitzustellen. In diesem Fall wird dieser Wert auf die Anzahl der Bytes in der Datei festgelegt. Wenn Sie die Datei im Textmodus öffnen, können Fehler auftreten.

Antwortstatuscode

Wir können den Antwortstatuscode erkennen:

>>> get ')
>>> r.status_code
200

Zur einfachen Referenz verfügt Requests auch über ein integriertes Statuscode-Abfrageobjekt:

> > > r.status_code == request.codes.ok
True

Wenn eine Fehleranforderung gesendet wird (ein 4XX-Clientfehler oder eine 5XX-Serverfehlerantwort), können wir Response.raise_for_status übergeben () um eine Ausnahme auszulösen:

>>> status_code
404
>>> bad_r.raise_for_status()
Traceback (letzter Aufruf zuletzt):
Datei „requests/models.py“, Zeile 832, in raise_for_status
raise http_error
requests.Exceptions.HTTPError: 404 Client Error

Da der Statuscode von r in unserem Beispiel jedoch 200 ist, erhalten wir beim Aufruf von raise_for_status():

> ;>> r.raise_for_status()

Keine

Alles ist ganz harmonisch.

Antwortheader

Wir können die Serverantwortheader als Python-Wörterbuch anzeigen:

>>> r.headers

{
' content-encoding': 'gzip',
'transfer-encoding': 'chunked',
'connection': 'close',
'server': 'nginx/1.0.4',
'x-runtime': '148ms',
'etag': '"e1ca502697e5c9317743dc078f67693f"',
'content-type': 'application/json'
}

Aber das Das Wörterbuch ist etwas Besonderes: Es gilt nur für HTTP-Header. Gemäß RFC 2616 wird bei HTTP-Headern die Groß-/Kleinschreibung nicht beachtet.

Daher können wir auf diese Antwort-Header-Felder mit beliebigen Großbuchstaben zugreifen:

>>> r.headers['Content-Type']

'application/json '
>>> r.headers.get('content-type')
'application/json'

Es hat auch einen besonderen Punkt, das heißt, der Server kann es mehrfach akzeptieren mal Verwenden Sie jedes Mal unterschiedliche Werte für denselben Header. Aber Anfragen werden sie kombinieren, sodass sie durch eine Zuordnung dargestellt werden können, siehe RFC 7230:

Ein Empfänger KANN mehrere Header-Felder mit demselben Feldnamen zu einem „Feld-Name:Feld-Wert“-Paar kombinieren. ohne die Semantik der Nachricht zu ändern, indem jeder nachfolgende Feldwert der Reihe nach durch ein Komma getrennt an den kombinierten Feldwert angehängt wird.

Der Empfänger kann mehrere Header-Felder mit demselben Namen zusammenführen. Sie werden zu einem zusammengefasst „Feldname:Feldwert“-Paar, und jeder nachfolgende Feldwert wird der Reihe nach durch Kommas getrennt an den kombinierten Feldwert angehängt, ohne die Semantik der Informationen zu ändern.

Cookies

Wenn eine Antwort Cookies enthält, können Sie schnell darauf zugreifen:

>>> url = 'http://example.com/some/cookie/setting/url'
>>> r = requests.get(url)
>>> r.cookies['example_cookie_name']
'example_cookie_value'
要想发送你的cookies到服务器，可以使用 cookies 参数：

>>> url = 'http://httpbin.org/cookies'
>>> cookies = dict(cookies_are='working')

>>> r = requests.get(url, cookies=cookies)
>>> r.text
'{"cookies": {"cookies_are": "working"}}'

Cookie 的返回对象为 RequestsCookieJar，它的行为和字典类似，但界面更为完整，适合跨域名跨路径使用。你还可以把 Cookie Jar 传到 Requests 中：

>>> jar = requests.cookies.RequestsCookieJar()
>>> jar.set('tasty_cookie', 'yum', domain='httpbin.org', path='/cookies')
>>> jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/elsewhere')
>>> url = 'http://httpbin.org/cookies'
>>> r = requests.get(url, cookies=jar)
>>> r.text
'{"cookies": {"tasty_cookie": "yum"}}'

重定向与请求历史

默认情况下，除了 HEAD, Requests 会自动处理所有重定向。

可以使用响应对象的 history 方法来追踪重定向。

Response.history 是一个 Response 对象的列表，为了完成请求而创建了这些对象。这个对象列表按照从最老到最近的请求进行排序。

例如，Github 将所有的 HTTP 请求重定向到 HTTPS：

>>> r = requests.get('http://github.com')
>>> r.url
'https://github.com/'
>>> r.status_code
200
>>> r.history
[<Response [301]>]

如果你使用的是GET、OPTIONS、POST、PUT、PATCH 或者 DELETE，那么你可以通过 allow_redirects 参数禁用重定向处理：

>>> r = requests.get('http://github.com', allow_redirects=False)
>>> r.status_code
301
>>> r.history
[]

如果你使用了 HEAD，你也可以启用重定向：

>>> r = requests.head('http://github.com', allow_redirects=True)
>>> r.url
'https://github.com/'
>>> r.history
[<Response [301]>]

超时

你可以告诉 requests 在经过以 timeout 参数设定的秒数时间之后停止等待响应。基本上所有的生产代码都应该使用这一参数。如果不使用，你的程序可能会永远失去响应：

>>> requests.get('http://github.com', timeout=0.001)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
requests.exceptions.Timeout: HTTPConnectionPool(host=&#39;github.com&#39;, port=80): Request timed out. (timeout=0.001)

注意

timeout 仅对连接过程有效，与响应体的下载无关。 timeout 并不是整个下载响应的时间限制，而是如果服务器在 timeout 秒内没有应答，将会引发一个异常（更精确地说，是在timeout 秒内没有从基础套接字上接收到任何字节的数据时）If no timeout is specified explicitly, requests do not time out.

错误与异常

遇到网络问题（如：DNS 查询失败、拒绝连接等）时，Requests 会抛出一个 ConnectionError 异常。

如果 HTTP 请求返回了不成功的状态码， Response.raise_for_status() 会抛出一个 HTTPError 异常。

若请求超时，则抛出一个 Timeout 异常。

若请求超过了设定的最大重定向次数，则会抛出一个 TooManyRedirects 异常。

所有Requests显式抛出的异常都继承自 requests.exceptions.RequestException 。

Das obige ist der detaillierte Inhalt vonSchnelle Einführung in Python-Anfragen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!