Ich habe über die Verwendung und Methode der Urllib-Bibliothek von Python, die grundlegende Verwendung der Urllib-Bibliothek zur Netzwerkdatenerfassung in Python und die erweiterte Verwendung von Pythons Urllib gesprochen.
Heute lernen wir, wie man die Requests-Bibliothek in Python verwendet.
Verwenden Sie pip zur Installation, wenn Sie das Pip-Paket (ein Python-Paketverwaltungstool, ich weiß nicht, ob Sie Baidu verwenden können) oder ein installiert haben In einer integrierten Umgebung wie Python (x, y) oder Anaconda können Sie pip direkt zum Installieren der Python-Bibliothek verwenden.
$ 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 'requests.models.Response'> 200 UTF-8 <RequestsCookieJar[]>
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")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=value1Wenn 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) '\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03'
Auf diese Weise wird der ursprüngliche Socket-Inhalt der Webseite erhalten.
Wenn Sie Header hinzufügen möchten, können Sie den 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信息Für POST-Anfragen müssen wir im Allgemeinen einige Parameter hinzufügen Es. Dann kann die grundlegendste Parameterübergabemethode den Datenparameter verwenden.
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 nutzen, stellen Sie einfach ein dateiähnliches Objekt für Ihren Anfragetext bereit, was sehr praktisch ist:
with open('massive-body') as f: requests.post('http://some.url/streamed', data=f)
Wenn eine Antwort Cookies enthält, dann können wir das verwenden Cookies-Variable, um es 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 abzurufen
Darüber hinaus können Sie die Cookies verwenden Variable zum Senden von Cookie-Informationen an den Server:
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"}}'Sie können die Timeout-Variable verwenden, um die maximale Anforderungszeit zu konfigurieren
requests.get(‘Build software better, together’, timeout=0.001)
Hinweis: Timeout gilt nur für den Verbindungsvorgang und das Herunterladen des Antworttextes. Nichts 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.
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.
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 Verifizierungsparameter 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)
Versuchen wir es mit 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.
Wenn Sie einen Proxy verwenden müssen, können Sie einzelne Anfragen konfigurieren, indem Sie den Proxys-Parameter für jede Anfragemethode angeben.
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 vonSo verwenden Sie die Requests-Bibliothek in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
