requests

import requests

requête d'une page :

pour un get response = requests.get('https://www.google.com')
pour un post : response = requests.post('http://www.example.com', data = {'param1': value1, 'param2': value2})
si on veut passer des paramètres dans l'URL (?param1=value1) : response = requests.get('http://www.example.com', params = {'param1': value1}).
- On peut alors voir l'URL construite en faisant : print(response.url) (notamment utile quand redirection, permet de voir les différentes URL requêtées).
- si la valeur associée à un paramètre est None, il ne sera pas rajouté dans l'URL.
response.status_code : le statut http de retour.
response.ok : True si le statut est < 400.
response.encoding : l'encoding de la pate, par exemple UTF-8.
response.content : le contenu de la page (en bytes)
response.text : si la réponse est du texte, gère comme il faut par rapport à l'encoding (alors que response.content renvoie le contenu de type bytes).
on peut changer l'encoding d'une page reçue ! Faire response.encoding = 'ISO-8859-1' et l'appel de response.text renverra cet encoding !
response.json() : réponse sous forme de json, si la réponse est du json.
si on veut faire un post avec une variable qui a plusieurs valeurs :
- response = requests.post(myUrl, data = {'param1': [value1, value2]})
- ou alors aussi : response = requests.post(myUrl, data = [('param1', value1), ('param1', value2)])
si on veut envoyer un data non encodé pour les formes, utiliser pour data une chaine de caractère plutôt qu'un dictionnaire : import json; response = requests.post(myUrl, json.dumps({'param1': value1}))
dans le cas de json, on peut faire directement : response = requests.post(myUrl, json = {'param1': value1})

on peut passer des paramètres au header de la requête :

response = requests.get(myUrl,
  headers = {'user-agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:71.0) Gecko/20100101 Firefox/71.0',
             'connection': 'keep-alive'})

response.headers : renvoie un dictionnaire du header de la réponse, mais ce dictionnaire est special car les clef sont case-insensitives (comme le veut le protocole http).
on peut aussi voir le header de la requête : response.request.headers

pour télécharger du contenu de grande taille :

response = session.get(myUrl, stream = True)
chunkSize = 100000000
with open('myFile', 'wb') as fhOut:
  for chunk in response.iter_content(chunk_size = chunkSize):
    fhOut.write(chunk)

Cookies :

session.cookies est de la classe requests.cookies.RequestsCookieJar
on peut boucler sur session.cookies pour récupérer des objets http.cookiejar.Cookie :
```
for cookie in session.cookies:
  print(cookie)
    
```
avec un objet http.cookiejar.Cookie, on a les champs : name, value, domain (de quel hôte il vient), path (quel chemin), is_expired() (s'il est expiré).
rajout d'un cookie :
si la réponse renvoie des cookies, on peut les récupérer avec response.cookies
pour renvoyer des cookies : response = requests.get(myUrl, cookies = {'param1': value1, 'param2': value2})

Multipart post :

response = requests.post(myUrl, files = {'file': open('myImage.png', 'rb')})
on peut fixer le nom de fichier, le content-type et des headers : response = requests.post(myUrl, files = {'file': (myFile.png', open('myImage.png', 'rb'), 'application/png, {'Expires': '0'})})

Par défaut, requests suit automatiquement les redirections, et on peut avoir l'historique des réponses dans response.history : liste des responses précédentes.

Timeout :

il faut utiliser pour chaque requête un timeout, sous peine qu'une requête bloque tout le programme.
response = request.get(myUrl, timeout = 1) : le timeout est en secondes.
si le timeout est dépassé, une exception est lancée.

Sessions :

les cookies persistent entre requêtes au même serveur.
la connection TCP est réutilisée pour les requêtes au même serveur, ce qui améliore les performances.
on crée une session par : session = requests.Session() et on on la termine par session.close()
toutes les méthodes de requests sont disponibles avec l'objet session, par exemple : response = session.get(myUrl) ou response = session.post(myUrl, data = myData)
on peut donner une authentification : session.auth = ('user', 'pass')
une session a les champs :
- session.headers : dictionnaire des headers passés à chaque requête.
- session.cookies : dictionnaire des cookies passés à chaque requête.
tous les dictionnaires qu'on passe aux requêtes sont fusionnés avec ceux déjà présents dans la session.
on peut utiliser une session sous la forme, avec fermeture automatique quand on sort du bloc :
```
with requests.Session() as session:
  session.get(myUrl)
  ...
    
```
keep-alive est automatique pour les sessions.

On peut décomposer la requête faite avec une session :

request = requests.Request('get', 'http://www.example.com', ...)
preparedRequest = session.prepare_request(request)
response = session.send(preparedRequest) (c'est à ce niveau que l'on peut rajouter des parameètres comme headers, cookies, etc ...)

ça permet d'afficher le contenu envoyé par : print(preparedRequest.body.decode('utf8'))

https :

par défaut, requests vérifie les certificats.
on peut inactiver cette vérification en faisant : requests.get('https://www.example.com', verify = False)
on peut donner un fichier comportant toute la chaîne des certificats avec requests.get(..., verify = 'myChain.pem')
sinon, on peut aussi donner le fichier dans la variable d'environnement : export REQUESTS_CA_BUNDLE=myChain.pem
les certificats utilisés par requests se situent dans : python3 -c 'import certifi; print(certifi.where())', mais apparemment, il y a aussi des certificats pour l'installation via pip

Parsing d'une page :

from lxml import html
tree = html.fromstring(response.content)

on peut utiliser response.content ou response.text

Parsing d'un document html : tree = html.fromstring(htmlTextContent) : renvoie un objet lxml.html.HtmlElement

Méthodes applicables aux objets HtmlElement :

elt.tag : le tag de l'élément.
elt.text le texte contenu dans l'élément.
elt.attrib : dictionnaire des attributs de l'élément.
for subelt in elt: : boucle directement sur les fils de l'élément.
list(elt) : la liste des fils de l'élément.
elt.findall('td') : tous les fils <td> de l'élément.
elt.find('td') : le premier fils <td> de l'élément (renvoie None si non trouvé)
elt.get_element_by_id('myId') : récupère l'élément dont l'id est donné.
elt.getparent() : le parent de l'élément.
elt.xpath(xpathExpression) : renvoie les éléments correspondant à l'expression xpath
elt.iter('span') : renvoie un itérateur sur tous les sous éléments <span> directs ou indirects.
elt.text_content() : renvoie le contenu en texte (sans les tags html) de l'élément.
etree.tostring(elt).decode() : pour avoir le contenu d'un élément (sous forme html). Faire from lxml import etree.

programmer en python, tutoriel python, graphes en python, Aymeric Duclert