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

J'ai parlé de l'utilisation et des méthodes de la bibliothèque urllib de Python, de l'utilisation de base de la bibliothèque Urllib de collecte de données réseau Python et de l'utilisation avancée de l'urllib de Python.

Aujourd'hui, nous allons apprendre à utiliser la bibliothèque Requests en Python.

Installation de la bibliothèque Requests

Utilisez pip pour installer, si vous avez installé le package pip (un outil de gestion de packages Python, je ne sais pas si vous pouvez utilisez Baidu), ou l'environnement intégré, tel que 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[]>

Requête de base http

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 les paramètres des en-têtes :

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

BasiqueRequête POST

Pour une requête POST, nous avons généralement besoin à Il ajoute 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, fournissez simplement 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)

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 n'est qu'un exemple, vous pouvez utiliser la variable cookies pour obtenir les cookies du site

Dans De plus, vous pouvez utiliser des variables de 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"}}'

Configuration du délai d'attente

Vous pouvez utiliser des variables de délai d'attente pour configurer le temps maximum de requête

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

Remarque : le délai d'attente n'est valable que pour le processus de connexion et n'a rien à voir avec 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.

Objet Session

Dans les requêtes ci-dessus, chaque requête équivaut en fait à lancer 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.

Vérification des certificats SSL

Désormais disponible partout sur les sites Web commençant par https, les requêtes peuvent vérifier les certificats SSL pour les requêtes HTTPS, tout comme un navigateur Web. Pour vérifier le certificat SSL d'un certain hôte, vous pouvez utiliser le paramètre verify, car le certificat 12306 n'était pas invalide il y a quelque temps :

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.

Si nous voulons ignorer la vérification du certificat de 12306 tout à l'heure, définissez simplement verify sur False :

import requests

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

Une fois trouvée, la demande peut être faite normalement. Par défaut, verify est True, vous devez donc définir cette variable manuellement si nécessaire.

Proxies

Si vous devez utiliser un proxy, vous pouvez configurer des requêtes individuelles en fournissant le paramètre proxys à n'importe quelle méthode de requête.

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"

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!