<p>Poder interactuar con una API RESTful basadas en HTTP es una tarea cada vez más común en proyectos en cualquier lenguaje de programación.<br> <br> En Python, también tenemos la opción de interactuar con una API REST de una manera simple con el módulo requests. En esta sección, revisamos las diferentes formas en que podemos interactuar con una API basada en HTTP utilizando el paquete de requests de Python.</p>

Una de las mejoras opciones dentro del ecosistema de Python para realizar peticiones HTTP es la librería de terceros requests. Puede instalar la biblioteca de solicitudes en su sistema de una manera fácil con el comando pip:

pip install request

Este módulo está disponible en el repositorio oficial de python PyPi.

Documentación oficial del módulo request

Para probar el módulo en nuestro script, solo tiene que importarlo como los otros módulos. Básicamente, requests es un contenedor de urllib junto con otros módulos de Python para proporcionarnos métodos con los cuales realizar peticiones a un sitio web o a una API REST, ya que contamos con los métodos “POST”, “GET”, “PUT”, “PATCH”, “DELETE” que son todos los métodos disponibles para comunicarse con una API RESTful.

Este módulo tiene una forma muy simple de implementación, por ejemplo, una petición GET usando el módulo requests sería:

>>> import requests
>>> response = requests.get('http://www.python.org')

Como podemos ver aquí, el método request.get() está devolviendo un objeto response que contiene la respuesta. En este objeto encontrará toda la información correspondiente a la respuesta de nuestra petición. Estas son las principales propiedades y métodos que ofrece el objeto de respuesta, en nuestro caso llamado response:

• response.status_code: este es el código HTTP devuelto por el servidor.
• response.content: Aquí encontraremos el contenido de la respuesta del servidor.
• response.json(): en el caso de que la respuesta sea un JSON, este método serializa la cadena y devuelve una estructura de diccionario con la estructura JSON correspondiente. En el caso de no recibir un JSON para cada respuesta, el método devolvería una excepción que podríamos controlar.

Podemos acceder a las propiedades del objeto de respuesta para verificar el código de estado, la url y el tipo de contenido:

>>> response.status_code
200
 
>>> response.reason
'OK'
>>> response.url
'http://www.python.org'
>>> response.headers['content-type']
'text/html; charset=utf-8'

También podemos acceder a las propiedades de las cabeceras a través del objeto de respuesta donde podemos ver que el user-agent corresponde a la versión de la librería requests que estamos utilizando:

 >>> response.request.headers
{'User-Agent': 'python-requests/2.23.0', 'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*', 'Connection': 'keep-alive'}

En el siguiente ejemplo utilizamos el módulo requests para obtener el fichero robots.txt de un domino con una simple petición GET con el módulo requests. Puede encontrar el siguiente código en el archivo leer_web_robots.py:

import requests
import sys
 
def main(url):
    robot_url = f'{url}/robots.txt'
    response = requests.get(robot_url)
    print(response.text)
 
if __name__ == "__main__":
    url = sys.argv[1]
    main(url)

Para ejecutar el script anterior necesitamos pasar como parámetro el dominio del cual queremos obtener el fichero robots.txt.

En este ejemplo estamos extrayendo la información del dominio www.python.org:

$ python leer_web_robots.py http://www.python.org

Resultado de la ejecución del script:

# Directions for robots.  See this URL:
# http://www.robotstxt.org/robotstxt.html
# for a description of the file format.

User-agent: HTTrack
User-agent: puf
User-agent: MSIECrawler
Disallow: /

# The Krugle web crawler (though based on Nutch) is OK.
User-agent: Krugle
Allow: /
Disallow: /~guido/orlijn/
Disallow: /webstats/

# No one should be crawling us with Nutch.
User-agent: Nutch
Disallow: /

# Hide old versions of the documentation and various large sets of files.
User-agent: *
Disallow: /~guido/orlijn/
Disallow: /webstats/

Escribir una función que recibe por parámetro una url de un fichero de texto y devuelve el número de palabras que contiene.

Parámetros:

• url: Es una cadena con la url del fichero de texto.

Devuelve:

• El número de palabras que contiene el fichero de texto dado por la url.

Pasos a seguir:

1. Importar el módulo requests.
2. Definir función y realizar la petición con el módulo requests, añadiendo también control de excepciones.
3. Obtener el número de palabras del contenido de la respuesta.

Ejemplo de url con fichero de texto: https://www.gutenberg.org/cache/epub/2000/pg2000.txt.

import requests
 
def palabras_url(url):
    try:
        response = requests.get(url)
    except Exception:
        return('¡La url ' + url + ' no existe!')
    else:
        contenido = response.text
        return len(contenido.split())
 
print(palabras_url('https://www.gutenberg.org/cache/epub/2000/pg2000.txt'))
 
# Prueba con excepción:
print(palabras_url('https://no-existe.txt'))

En el siguiente script podemos ver las cabeceras de la respuesta y de la petición a través del objeto response en el dominio http://python.org

Puede encontrar el siguiente código en el archivo obtener_cabeceras_requests.py:

import requests
 
response = requests.get("http://www.python.org")
 
print(response.content)
 
print("Status code: "+str(response.status_code))
 
print("Cabeceras de respuesta: ")
for header, value in response.headers.items():
    print(header, '-->', value)
 
print("Cabeceras de la peticion:")
for header, value in response.request.headers.items():
    print(header, '-->', value)

La instrucción response.headers proporciona las cabeceras de la respuesta del servidor web. Básicamente, la respuesta es un diccionario de objetos, y con el método items(), podemos iterar con el formato clave-valor para acceder a las diferentes cabeceras.

Al ejecutar el script anterior podemos resaltar la presencia de python-request en la cabecera User-Agent en las cabeceras de la petición.

Cabeceras de la peticion:

User-Agent --> python-requests/2.23.0
Accept-Encoding --> gzip, deflate
Accept --> */*
Connection --> keep-alive

De de la misma forma, podríamos obtener solo las claves con el método keys() del diccionario de respuesta.

Puede encontrar el siguiente código en el archivo obtener_cabeceras_keys.py:

import requests
 
import requests
if __name__ == "__main__":
    response = requests.get("http://www.python.org")
    for header in response.headers.keys():
        print(header + ":" + response.headers[header])