Explication détaillée de l'utilisation avancée de la bibliothèque Requests

Bien que le module urllib2 de la bibliothèque standard de Python contienne déjà la plupart des fonctions que nous utilisons habituellement, son API est vraiment inconfortable à utiliser. Il n’est plus adapté à l’époque actuelle et à l’Internet moderne. La naissance des Requêtes nous offre un meilleur choix. Cet article présente l'utilisation avancée de la bibliothèque tierce Requests en Python.

1. Installation de la bibliothèque Requests

Utilisez pip pour installer, si vous avez installé le package pip (aPython Package outil de gestion, je ne sais pas si vous pouvez utiliser Baidu), ou environnement intégré, comme Python（x,y） ou anaconda, vous pouvez directement utiliser pip pour installer la bibliothèque Python.

$ pip install requests

Une fois l'installation terminée, jetons un coup d'œil à la méthode de base :

#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, ...}

Jetons un coup d'œil à un petit châtaignier :

#小例子
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[]>

2. Requêtes http de base

La bibliothèque de requêtes fournit toutes les méthodes de requête de base de http. Par exemple :

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)

Requête GET de base

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

Si vous souhaitez demander un fichier JSON, vous pouvez utiliser la méthode json() pour l'analyser. Par exemple, écrivez un. Fichier JSON vous-même et nommez-le a.json. Le contenu Comme suit :

["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'}]

Si vous souhaitez obtenir la réponse brute du socket du serveur, vous pouvez obtenir r.raw. Cependant, stream=True doit être défini dans la requête initiale.

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;

De cette manière, le contenu original du socket de la page Web est obtenu.

Si vous souhaitez ajouter des en-têtes, vous pouvez passer le paramètre headers :

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信息

Requête POST de base

Pour les requêtes POST, nous devons généralement y ajouter quelques paramètres. Ensuite, la méthode de transmission de paramètres la plus élémentaire peut utiliser le paramètre data.

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"
}

Vous pouvez voir que les paramètres ont été transmis avec succès, puis le serveur a renvoyé les données que nous avons transmises.

Parfois, les informations que nous devons envoyer ne se présentent pas sous la forme d'un formulaire. Nous devons envoyer des données au format JSON, nous pouvons donc utiliser la méthode json.dumps() pour sérialiser les données du formulaire.

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"
}

Grâce à la méthode ci-dessus, nous pouvons POST des données au format JSON

Si vous souhaitez télécharger un fichier, utilisez simplement le paramètre file directement :

#新建一个 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"
}

De cette façon, nous avons terminé avec succès le téléchargement d'un fichier.

Les requêtes prennent en charge les téléchargements en streaming, ce qui vous permet d'envoyer des flux de données ou des fichiers volumineux sans les lire au préalable en mémoire. Pour utiliser le streaming upload, il vous suffit de fournir un fichier de classe objet pour le corps de votre requête, ce qui est très pratique :

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

4. Cookies

Si une réponse contient des cookies, alors nous pouvons utiliser la variable cookies pour obtenir :

import requests

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

Le programme ci-dessus est juste pour exemple, vous pouvez utiliser la variable cookies pour obtenir les cookies du site

De plus, vous pouvez utiliser la variable cookies pour envoyer des informations sur les cookies au serveur :

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"}}'

5. Configuration du délai d'attente

Vous pouvez utiliser la variable timeout pour configurer le temps maximum de requête

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

Remarque : le délai d'attente est uniquement pour les connexions. Le processus fonctionne quel que soit le téléchargement du corps de la réponse.

Autrement dit, ce délai ne fait que limiter le temps demandé. Même si la réponse renvoyée contient une grande quantité de contenu, le téléchargement prendra un certain temps.

6. Objet de session

Dans les requêtes ci-dessus, chaque requête équivaut en fait au lancement d'une nouvelle requête. Cela équivaut à l’utilisation d’un navigateur différent pour ouvrir chaque requête séparément. Autrement dit, il ne fait pas référence à une session, même si la même URL est demandée. Par exemple :

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

Évidemment, ce n'est pas en session et les cookies ne peuvent pas être obtenus. Alors que devons-nous faire si nous devons maintenir une session persistante sur certains sites ? Tout comme utiliser un navigateur pour parcourir Taobao, sauter entre différents onglets crée en fait une session à long terme.

La solution est la suivante :

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"
}
}

On constate que les cookies peuvent être obtenus avec succès, ce qui consiste à établir une session.

Donc, puisque session est une variable globale, nous pouvons certainement l'utiliser pour une configuration globale.

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"
}
}

Et si les en-têtes passés par la méthode get étaient également des x-test ?

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"
}
}

Et si vous ne souhaitez pas de variable dans la configuration globale ? C'est simple, il suffit de le régler sur Aucun.

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"
}
}

Ce qui précède est l'utilisation de base de session session.

7. Vérification du certificat SSL

Les sites Web commençant par https peuvent désormais être vus partout. . Comme un navigateur Web. Pour vérifier le certificat SSL d'un certain hébergeur, vous pouvez utiliser le paramètre verify, car le certificat 12306 n'était pas invalide il y a quelque temps, testons-le :

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

Eh bien, demande normale, car il y a trop de contenu, je ne collerai pas la sortie.

如果我们想跳过刚才 12306 的证书验证，把 verify 设置为 False 即可：

import requests

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

发现就可以正常请求了。在默认情况下 verify 是 True，所以如果需要的话，需要手动设置下这个变量。

八、代理

如果需要使用代理，你可以通过为任意请求方法提供 proxies 参数来配置单个请求。

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

总结

【相关推荐】

1. Python免费视频教程

2. Python基础入门教程

3. Python遇见数据采集视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!