Detaillierte Erläuterung der Verwendung der Requests-Bibliothek in Python

Ich habe über die Verwendung und Methoden der urllib-Bibliothek von Python, die grundlegende Verwendung der Urllib-Bibliothek für die Netzwerkdatenerfassung in Python und die erweiterte Verwendung der urllib von Python gesprochen.

Heute lernen wir, wie man die Requests-Bibliothek in Python verwendet.

Installation der Requests-Bibliothek

Verwenden Sie pip zur Installation, wenn Sie das Pip-Paket installiert haben (ein Python-Paketverwaltungstool, ich weiß nicht, ob Sie das können). Verwenden Sie Baidu) oder die integrierte Umgebung wie Python (x, y) oder Anaconda. Sie können pip direkt verwenden, um die Python-Bibliothek zu installieren.

$ pip install requests

Nachdem die Installation abgeschlossen ist, schauen wir uns die grundlegende Methode an:

    #get请求方法
    >>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
#打印get请求的状态码
    >>> r.status_code
200
#查看请求的数据类型，可以看到是json格式，utf-8编码
    >>> r.headers['content-type']
'application/json; charset=utf8'
    >>> r.encoding
'utf-8'
#打印请求到的内容
    >>> r.text
u'{"type":"User"...'
#输出json格式数据
    >>> r.json()
    {u'private_gists': 419, u'total_private_repos': 77, ...}

Werfen wir einen Blick auf eine kleine Kastanie:

#小例子
import requests

r = requests.get('http://www.baidu.com')
print type(r)
print r.status_code
print r.encoding
print r.text
print r.cookies
'''请求了百度的网址，然后打印出了返回结果的类型，状态码，编码方式，Cookies等内容
输出：'''
<class &#39;requests.models.Response&#39;>
200
UTF-8
<RequestsCookieJar[]>

http-Basisanforderung

Die Anforderungsbibliothek stellt alle grundlegenden Anforderungsmethoden von http bereit. Beispiel:

r = requests.post("http://httpbin.org/post")
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")

Grundlegende GET-Anfrage

r = requests.get("http://httpbin.org/get")
#如果想要加参数，可以利用 params 参数：
import requests
payload = {'key1': 'value1', 'key2': 'value2'}
r = requests.get("http://httpbin.org/get", params=payload)
print r.url

#输出：http://httpbin.org/get?key2=value2&key1=value1

Wenn Sie eine JSON-Datei anfordern möchten, können Sie sie mit der Methode json() analysieren. Schreiben Sie beispielsweise eine JSON-Datei selbst und nennen Sie sie a.json. Der Inhalt lautet wie folgt:

["foo", "bar", {
"foo": "bar"
}]
#利用如下程序请求并解析：
import requests
r = requests.get("a.json")
print r.text
print r.json()
'''运行结果如下，其中一个是直接输出内容，另外一个方法是利用 json() 方法
解析，感受下它们的不同:'''
["foo", "bar", {
"foo": "bar"
}]
[u'foo', u'bar', {u'foo': u'bar'}]

Wenn Sie die Raw-Socket-Antwort vom Server erhalten möchten, können Sie r.raw abrufen. Allerdings muss stream=True in der ersten Anfrage festgelegt werden.

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;

Auf diese Weise wird der ursprüngliche Socket-Inhalt der Webseite erhalten.

Wenn Sie Header hinzufügen möchten, können Sie Header-Parameter übergeben:

import requests

payload = {'key1': 'value1', 'key2': 'value2'}
headers = {'content-type': 'application/json'}
r = requests.get("http://httpbin.org/get", params=payload, headers=headers)
print r.url
#通过headers参数可以增加请求头中的headers信息

BasicPOST-Anfrage

Für POST-Anfragen benötigen wir im Allgemeinen Es fügt einige Parameter hinzu. Dann kann die einfachste Methode zum Übergeben von Parametern der Datenparameter sein.

import requests

payload = {'key1': 'value1', 'key2': 'value2'}
r = requests.post("http://httpbin.org/post", data=payload)
print r.text
#运行结果如下：
{
"args": {}, 
"data": "", 
"files": {}, 
"form": {
"key1": "value1", 
"key2": "value2"
}, 
"headers": {
"Accept": "*/*", 
"Accept-Encoding": "gzip, deflate", 
"Content-Length": "23", 
"Content-Type": "application/x-www-form-urlencoded", 
"Host": "http://httpbin.org", 
"User-Agent": "python-requests/2.9.1"
}, 
"json": null, 
"url": "http://httpbin.org/post"
}

Sie können sehen, dass die Parameter erfolgreich übergeben wurden und der Server dann die von uns übergebenen Daten zurückgegeben hat.

Manchmal liegen die Informationen, die wir senden müssen, nicht in Form eines Formulars vor. Wir müssen Daten im JSON-Format senden, damit wir die Methode json.dumps() verwenden können, um die Formulardaten zu serialisieren.

import json
import requests

url = 'http://httpbin.org/post'
payload = {'some': 'data'}
r = requests.post(url, data=json.dumps(payload))
print r.text

#运行结果：
{
"args": {}, 
"data": "{\"some\": \"data\"}", 
"files": {}, 
"form": {}, 
"headers": {
"Accept": "*/*", 
"Accept-Encoding": "gzip, deflate", 
"Content-Length": "16", 
"Host": "http://httpbin.org", 
"User-Agent": "python-requests/2.9.1"
}, 
"json": {
"some": "data"
}, 
"url": "http://httpbin.org/post"
}

Mit der oben genannten Methode können wir Daten im JSON-Format POSTEN

Wenn Sie eine Datei hochladen möchten, verwenden Sie einfach den Dateiparameter direkt:

#新建一个 test.txt 的文件，内容写上 Hello World!
import requests

url = 'http://httpbin.org/post'
files = {'file': open('test.txt', 'rb')}
r = requests.post(url, files=files)
print r.text

{
"args": {}, 
"data": "", 
"files": {
"file": "Hello World!"
}, 
"form": {}, 
"headers": {
"Accept": "*/*", 
"Accept-Encoding": "gzip, deflate", 
"Content-Length": "156", 
"Content-Type": "multipart/form-data; boundary=7d8eb5ff99a04c11bb3e862ce78d7000", 
"Host": "http://httpbin.org", 
"User-Agent": "python-requests/2.9.1"
}, 
"json": null, 
"url": "http://httpbin.org/post"
}

Auf diese Weise haben wir das Hochladen einer Datei erfolgreich abgeschlossen.

Requests unterstützt Streaming-Uploads, wodurch Sie große Datenströme oder Dateien senden können, ohne sie zuerst in den Speicher einzulesen. Um den Streaming-Upload zu verwenden, stellen Sie einfach eine Klassendatei Objekt für Ihren Anfragetext bereit, was sehr praktisch ist:

with open('massive-body') as f:
requests.post('http://some.url/streamed', data=f)

Cookies

Wenn eine Antwort Cookies enthält, dann Wir können die Cookies-Variable verwenden, um Folgendes zu erhalten:

import requests

url = 'Example Domain'
r = requests.get(url)
print r.cookies
print r.cookies['example_cookie_name']

Das obige Programm ist nur ein Beispiel. Sie können die Cookies-Variable verwenden, um die Cookies der Website

Darüber hinaus können Sie Cookie-Variablen verwenden, um Cookie-Informationen an den Server zu senden:

import requests

url = 'http://httpbin.org/cookies'
cookies = dict(cookies_are='working')
r = requests.get(url, cookies=cookies)
print r.text
#输出：
'{"cookies": {"cookies_are": "working"}}'

Timeout-Konfiguration

Sie können Timeout-Variablen verwenden, um die maximale Anforderungszeit zu konfigurieren

requests.get(‘Build software better, together’, timeout=0.001)

Hinweis: Die Zeitüberschreitung gilt nur für den Verbindungsvorgang und hat nichts mit dem Herunterladen des Antworttexts zu tun.

Mit anderen Worten, diese Zeit begrenzt nur die angeforderte Zeit. Selbst wenn die zurückgegebene Antwort eine große Menge an Inhalten enthält, dauert das Herunterladen einige Zeit.

Sitzungsobjekt

In den oben genannten Anfragen entspricht jede Anfrage tatsächlich dem Initiieren einer neuen Anfrage. Dies entspricht dem Effekt, wenn zum Öffnen jeder Anfrage ein anderer Browser verwendet wird. Das heißt, es bezieht sich nicht auf eine Sitzung, selbst wenn dieselbe URL angefordert wird. Zum Beispiel:

import requests

requests.get('http://httpbin.org/cookies/set/sessioncookie/123456789')
r = requests.get("http://httpbin.org/cookies")
print(r.text)
#结果是：
{
"cookies": {}
}

Natürlich geschieht dies nicht in einer Sitzung und Cookies können nicht abgerufen werden. Was sollten wir also tun, wenn wir auf einigen Websites eine dauerhafte Sitzung aufrechterhalten müssen? Genau wie die Verwendung eines Browsers zum Durchsuchen von Taobao führt das Springen zwischen verschiedenen Registerkarten tatsächlich zu einer langfristigen Sitzung.

Die Lösung lautet wie folgt:

import requests

s = requests.Session()
s.get('http://httpbin.org/cookies/set/sessioncookie/123456789')
r = s.get("http://httpbin.org/cookies")
print(r.text)
#在这里我们请求了两次，一次是设置 cookies，一次是获得 cookies
{
"cookies": {
"sessioncookie": "123456789"
}
}

Es wurde festgestellt, dass Cookies erfolgreich abgerufen werden können, nämlich zum Einrichten einer Sitzung.

Da es sich bei der Sitzung um eine globale Variable handelt, können wir sie definitiv für die globale Konfiguration verwenden.

import requests

s = requests.Session()
s.headers.update({'x-test': 'true'})
r = s.get('http://httpbin.org/headers', headers={'x-test2': 'true'})
print r.text
'''通过 s.headers.update 方法设置了 headers 的变量。然后我们又在请求中
设置了一个 headers，那么会出现什么结果？很简单，两个变量都传送过去了。
运行结果:'''
{
"headers": {
"Accept": "*/*", 
"Accept-Encoding": "gzip, deflate", 
"Host": "http://httpbin.org", 
"User-Agent": "python-requests/2.9.1", 
"X-Test": "true", 
"X-Test2": "true"
}
}

Was passiert, wenn die von der Get-Methode übergebenen Header auch X-Test-Header sind?

r = s.get('http://httpbin.org/headers', headers={'x-test': 'true'})

#它会覆盖掉全局的配置：
{
"headers": {
"Accept": "*/*", 
"Accept-Encoding": "gzip, deflate", 
"Host": "http://httpbin.org", 
"User-Agent": "python-requests/2.9.1", 
"X-Test": "true"
}
}

Was ist, wenn Sie keine Variable in der globalen Konfiguration haben möchten? Es ist ganz einfach, stellen Sie es einfach auf „Keine“.

r = s.get('http://httpbin.org/headers', headers={'x-test': None})
{
"headers": {
"Accept": "*/*", 
"Accept-Encoding": "gzip, deflate", 
"Host": "http://httpbin.org", 
"User-Agent": "python-requests/2.9.1"
}
}

Das Obige ist die grundlegende Verwendung der Sitzungssitzung.

SSL-Zertifikatsüberprüfung

Jetzt überall auf Websites verfügbar, die mit https beginnen, kann Requests SSL-Zertifikate für HTTPS-Anfragen überprüfen, genau wie ein Webbrowser. Um das SSL-Zertifikat eines bestimmten Hosts zu überprüfen, können Sie den Parameter ver

ify verwenden, da das 12306-Zertifikat vor einiger Zeit nicht ungültig war. Testen wir es:

import requests

r = requests.get('https://kyfw.12306.cn/otn/', verify=True)
print r.text
#结果：
requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:590)

Github :

import requests

r = requests.get('Build software better, together', verify=True)
print r.text

Nun, normale Anfrage, da es zu viel Inhalt gibt, werde ich die Ausgabe nicht einfügen.

Wenn wir die Zertifikatsüberprüfung von 12306 gerade überspringen möchten, setzen Sie einfach „Verifizieren“ auf „Falsch“:

import requests

r = requests.get('https://kyfw.12306.cn/otn/', verify=False)
print r.text

Sobald es gefunden wurde, kann die Anfrage normal gestellt werden. Standardmäßig ist „Verify“ „True“, daher müssen Sie diese Variable bei Bedarf manuell festlegen.

Proxies

Wenn Sie einen Proxy verwenden müssen, können Sie einzelne Anfragen konfigurieren, indem Sie den Proxys-Parameter für jede Anfragemethode bereitstellen.

import requests

proxies = {
"https": "http://41.118.132.69:4433"
}
r = requests.post("http://httpbin.org/post", proxies=proxies)
print r.text
#也可以通过环境变量 HTTP_PROXY 和 HTTPS_PROXY 来配置代理
export HTTP_PROXY="http://10.10.1.10:3128"
export HTTPS_PROXY="http://10.10.1.10:1080"

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Verwendung der Requests-Bibliothek in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!