Usando la biblioteca requests para manejar solicitudes y respuestas HTTP en Python
Si eres como nosotros, entonces la transferencia de datos a través de internet es una parte importante de tu trabajo. Ya sea que estés consultando una API, descargando un archivo o interactuando con un sitio web, necesitas una forma efectiva y eficiente para realizar solicitudes y manejar las respuestas HTTP.
Es por eso que recurrimos a la biblioteca requests en Python. Esta biblioteca es fácil de usar y maneja todo el trabajo pesado de las solicitudes y las respuestas HTTP. En esta sección, te mostraremos cómo puedes utilizar la biblioteca requests para manejar solicitudes y respuestas HTTP en Python.
Primero, necesitamos instalar la biblioteca requests. Puedes hacer esto utilizando pip, que es el administrador de paquetes de Python:
pip install requests
Una vez que requests esté instalado, lo importaremos en nuestro código y comenzaremos a utilizar sus métodos. Aquí hay un ejemplo de solicitud GET simple:
import requests
response = requests.get('https://api.example.com/users')
print(response.status_code)
print(response.content)
En este ejemplo estamos haciendo una solicitud GET a una API en https://api.example.com/users. La respuesta de esta API se almacena en la variable response. En la siguiente línea estamos imprimiendo el código de estado de la respuesta (por ejemplo, 200, 404, etc.) y el contenido de la respuesta.
requests también tiene la capacidad de manejar otros tipos de solicitudes como POST, PUT y DELETE. Aquí hay un ejemplo de una solicitud POST:
import requests
payload = {'username': 'juanito123', 'email': '[email protected]'}
response = requests.post('https://api.example.com/users', data=payload)
print(response.status_code)
En este ejemplo, estamos haciendo una solicitud POST a https://api.example.com/users con un diccionario de datos payload que contiene el nombre de usuario y el correo electrónico del usuario que estamos creando. La respuesta de esta API se almacena en la variable response. En la siguiente línea estamos imprimiendo el código de estado de la respuesta.
requests también tiene la capacidad de manejar solicitudes con encabezados personalizados, autenticación y cookies. Aquí hay un ejemplo de una solicitud con encabezados personalizados:
import requests
headers = {'X-Auth': 'secret-key'}
response = requests.get('https://api.example.com/users', headers=headers)
print(response.content)
En este ejemplo, estamos haciendo una solicitud GET a https://api.example.com/users con un encabezado personalizado X-Auth que contiene una clave secreta. La respuesta de esta API se almacena en la variable response y en la siguiente línea estamos imprimiendo el contenido de la respuesta.
La biblioteca requests es una herramienta poderosa y fácil de usar para manejar solicitudes y respuestas HTTP en Python. Con la capacidad de manejar solicitudes con encabezados personalizados, autenticación y cookies, requests te ofrece la flexibilidad y el control que necesitas para transferir datos a través de internet.
Preparando una solicitud HTTP con requests
Antes de realizar una solicitud HTTP con Python y la biblioteca requests, es importante preparar la solicitud con todos los detalles necesarios para que el servidor pueda procesarla correctamente.
Para comenzar, es necesario importar la biblioteca requests al archivo que estemos utilizando. Para esto, podemos utilizar el siguiente comando:
import requests
Luego, podemos utilizar la función requests.get() para hacer una solicitud de tipo GET a un determinado sitio web. Por ejemplo, supongamos que queremos hacer una solicitud al sitio web “www.google.com”. Podemos hacerlo de la siguiente manera:
response = requests.get("http://www.google.com")
En este caso, estamos almacenando la respuesta del servidor en la variable response. Es importante destacar que este método puede lanzar una excepción si no podemos hacer la solicitud correctamente.
Podemos también agregar parámetros a la solicitud para afinarla más. Por ejemplo, si queremos buscar algo en Google, podemos agregar el parámetro q con nuestra búsqueda. Para esto, utilizamos la función requests.get() de la siguiente manera:
response = requests.get("http://www.google.com", params={"q": "Python"})
En este caso, estamos buscando la palabra “Python” en Google. Podemos utilizar también otros parámetros como headers para agregar encabezados personalizados a la solicitud.
Otro tipo de solicitud muy común es la solicitud POST, que nos permite enviar información al servidor para que la procese. Para hacer esto, utilizamos la función requests.post(). Por ejemplo, supongamos que queremos enviar un formulario a un sitio web. Podemos hacerlo de la siguiente manera:
response = requests.post("http://www.ejemplo.com/enviar_formulario", data={"nombre": "Juan", "apellido": "Pérez"})
En este caso, estamos enviando un formulario con los campos “nombre” y “apellido” al sitio web “www.ejemplo.com/enviar_formulario".
En general, es importante conocer todos los parámetros disponibles para las solicitudes HTTP y cómo utilizarlos adecuadamente para obtener la respuesta que necesitamos. En la documentación de la biblioteca requests podemos encontrar una lista completa de los parámetros y ejemplos de cómo utilizarlos.
Preparar una solicitud HTTP con Python y la biblioteca requests implica conocer los detalles necesarios para hacer la solicitud y cómo enviar la información adecuada al servidor. Con las herramientas adecuadas y un poco de práctica, podemos hacer solicitudes HTTP de manera eficiente y obtener la información que necesitamos de manera rápida y sencilla.
Enviando solicitudes y obteniendo respuestas con requests
Si quieres hacer solicitudes HTTP en Python, hay varios paquetes disponibles. Uno de los más populares es requests. En esta sección, vamos a explorar cómo usar requests para enviar solicitudes HTTP y obtener respuestas.
Primero, es importante entender los diferentes tipos de solicitudes HTTP que se pueden hacer. Hay cuatro métodos principales: GET, POST, PUT y DELETE. Cada uno tiene un propósito diferente. Por ejemplo, el método GET se usa para obtener información del servidor, mientras que POST se usa para enviar información al servidor. Cuando envías una solicitud HTTP, incluyes la URL del recurso que deseas acceder, así como cualquier información adicional necesaria, como encabezados o parámetros.
Aquí hay un ejemplo simple de cómo usar requests para enviar una solicitud GET a una página web:
import requests
response = requests.get("https://www.example.com/")
print(response.content)
En este ejemplo, usamos el método get de requests para enviar una solicitud GET a la página web de ejemplo. Luego, imprimimos la respuesta que recibimos del servidor. La respuesta incluirá el contenido HTML de la página web.
También puedes enviar solicitudes POST con requests. Aquí te mostramos cómo enviar un formulario a un servidor web:
import requests
payload = {'username': 'johndoe', 'password': 'mypass'}
response = requests.post("https://www.example.com/login", data=payload)
print(response.text)
En este ejemplo, definimos un diccionario payload de los datos que queremos enviar al servidor, que incluye un nombre de usuario y una contraseña. Luego, usamos el método post de requests para enviar la solicitud POST a la URL del formulario de inicio de sesión. La respuesta del servidor es el contenido HTML de la página que el servidor carga después de iniciar sesión.
Es importante tener en cuenta que, en muchos casos, también querrás incluir encabezados HTTP en tus solicitudes requests. Los encabezados HTTP son información adicional enviada junto con la solicitud que proporciona información útil al servidor. Aquí hay un ejemplo que incluye algunos encabezados personalizados:
import requests
url = 'https://api.github.com/some/endpoint'
headers = {'user-agent': 'my-app/0.0.1'}
response = requests.get(url, headers=headers)
En este ejemplo, definimos la URL de la API de GitHub que queremos acceder y un diccionario de encabezados que incluyen el encabezado user-agent. Luego, enviamos una solicitud GET a la API de GitHub y pasamos los encabezados como argumento.
requests es una excelente opción para enviar solicitudes HTTP en Python. Proporciona una interfaz simple y fácil de usar para enviar solicitudes y recibir respuestas. Si bien solo hemos cubierto algunos ejemplos básicos aquí, hay muchas opciones avanzadas disponibles en la biblioteca para manejar solicitudes y respuestas HTTP personalizadas.
Manejo de errores HTTP y códigos de estado con requests
Cuando hacemos solicitudes HTTP con requests en Python, es importante estar preparados para manejar posibles errores que puedan surgir. Algunos de los errores más comunes incluyen códigos de estado no exitosos y errores de conexión. En esta sección, exploraremos cómo manejar estos errores usando la biblioteca requests.
Manejo de códigos de estado no exitosos
Los códigos de estado son enviados por el servidor para indicar si la solicitud fue exitosa o no. Cuando hacemos una solicitud HTTP con requests, podemos acceder al código de estado a través del atributo status_code del objeto Response.
Si el código de estado indica que la solicitud no fue exitosa, podemos manejar el error utilizando la función raise_for_status(). Esta función generará una excepción si el código de estado es mayor o igual a 400.
Aquí hay un ejemplo de cómo manejar un código de estado no exitoso usando raise_for_status():
import requests
response = requests.get('https://example.com/404')
try:
response.raise_for_status()
except requests.exceptions.HTTPError as error:
print(f"Hubo un error: {error}")
En este ejemplo, estamos haciendo una solicitud GET a una página que no existe, lo que resultará en un código de estado 404. Usamos raise_for_status() para comprobar si la solicitud fue exitosa y si no lo fue, generamos una excepción. En este caso, la excepción es HTTPError() y la imprimimos en la consola.
Manejo de errores de conexión
También es importante estar preparados para manejar errores de conexión cuando hacemos solicitudes HTTP con requests. Si pierdes la conexión a Internet o si el servidor está caído, podrías recibir un error ConnectionError.
Aquí hay un ejemplo de cómo manejar un error de conexión:
import requests
try:
response = requests.get('https://example.com')
except requests.exceptions.ConnectionError as error:
print(f"No se pudo conectar: {error}")
En este ejemplo, intentamos hacer una solicitud GET a https://example.com. Si no podemos conectarnos al servidor, generamos una excepción ConnectionError y la imprimimos en la consola.
Cuando hacemos solicitudes HTTP con requests en Python, es importante estar preparados para manejar errores que puedan surgir. Los códigos de estado no exitosos y los errores de conexión son algunos de los errores más comunes que podemos encontrarnos. Pero con la función
raise_for_status()y la excepciónConnectionError, podemos fácilmente manejar estos errores y seguir adelante con nuestro código.
Personalizando solicitudes con headers y cookies en requests
Cuando realizamos una solicitud HTTP utilizando la biblioteca requests de Python, podemos personalizarla para que incluya una serie de headers y cookies. Estos datos adicionales pueden ser muy útiles para interactuar con sitios web y APIs de terceros.
Los headers son una serie de datos que se envían junto con una solicitud HTTP. Estos datos pueden incluir información acerca de la versión del navegador web del usuario, el tipo de contenido que se está solicitando, la dirección IP del usuario, entre otros. En algunas ocasiones, los sitios web o APIs exigen la inclusión de ciertos headers para poder procesar correctamente las solicitudes.
Por otro lado, las cookies son pequeños archivos de texto que se utilizan para almacenar información en el navegador web del usuario. Las cookies son comúnmente utilizadas para mantener una sesión de usuario en un sitio web, almacenar las preferencias de un usuario o incluso para rastrear la actividad del usuario en diferentes sitios web.
Para incluir headers en nuestra solicitud HTTP utilizando la biblioteca requests, podemos utilizar un diccionario de Python que contenga los datos que deseamos enviar. Por ejemplo, para enviar el header “User-Agent” que indica la versión del navegador web que estamos utilizando, podemos hacer lo siguiente:
import requests
headers = {
"User-Agent": "Mozilla/5.0 ( Windows NT 10.0; Win64; x64 ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
}
response = requests.get("https://www.ejemplo.com", headers=headers)
Además, podemos utilizar la opción de cookies de la biblioteca requests para incluir cookies en nuestra solicitud HTTP. Para hacer esto, podemos pasar un diccionario de Python que contenga las cookies que deseamos enviar. Por ejemplo, para enviar una cookie “session_id” que contiene el ID de sesión de un usuario, podemos hacer lo siguiente:
import requests
cookies = {
"session_id": "abc1234def5678ghi90"
}
response = requests.get("https://www.ejemplo.com", cookies=cookies)
Personalizar las solicitudes HTTP con headers y cookies puede ser muy útil al interactuar con sitios web y APIs de terceros. Al utilizar la biblioteca requests de Python, podemos fácilmente enviar headers y cookies en nuestras solicitudes HTTP. Conociendo esto, podemos obtener información valiosa y automatizar tareas de una manera más efectiva.
Manejo de autenticación en solicitudes HTTP con requests
Cuando utilizamos la biblioteca requests en Python para realizar solicitudes HTTP a servidores web, es importante tener en cuenta el manejo de la autenticación. En algunos casos, los servidores web requieren que los usuarios se autentiquen para poder acceder a ciertas funcionalidades o recursos.
En requests, el manejo de la autenticación se realiza a través de los objetos AuthBase y HTTPBasicAuth. El objeto AuthBase es una clase abstracta que define una interfaz para la autenticación personalizada, mientras que HTTPBasicAuth es una implementación simple de la autenticación básica que se utiliza en muchos servidores web.
Para utilizar la autenticación básica con requests, podemos crear un objeto HTTPBasicAuth y pasar sus credenciales al realizar una solicitud. Las credenciales deben estar en forma de una tupla que contenga el nombre de usuario y la contraseña, separados por dos puntos (:) y luego codificados en Base64.
Veamos un ejemplo de autenticación básica en requests:
import requests
from requests.auth import HTTPBasicAuth
# Credenciales de usuario
username = 'usuario'
password = 'contraseña'
# URL del recurso protegido
url = 'https://www.mi-servidor-web.com/recurso-protegido/'
# Crear objeto HTTPBasicAuth
auth = HTTPBasicAuth(username, password)
# Realizar solicitud HTTP GET con autenticación básica
response = requests.get(url, auth=auth)
En este ejemplo, creamos un objeto HTTPBasicAuth con las credenciales de usuario proporcionadas y lo pasamos como argumento en la solicitud HTTP GET realizada con requests. De esta manera, requests enviará las credenciales de autenticación al servidor web y podremos acceder al recurso protegido.
Existen otros tipos de autenticación, como la autenticación digest o la autenticación basada en token, que requieren diferentes métodos de autenticación y manejo de credenciales. Sin embargo, el uso de requests con estos tipos de autenticación sigue siendo sencillo y accesible.
El manejo de la autenticación en
requestsnos permite realizar solicitudes HTTP a servidores web que requieren autenticación de usuario. Con la ayuda deHTTPBasicAuthy otras implementaciones deAuthBase, podemos asegurarnos de que nuestras solicitudes sean autenticadas de manera segura y efectiva.
Usando proxies en solicitudes HTTP con requests
En ocasiones necesitamos realizar solicitudes HTTP a través de un servidor proxy, ya sea por motivos de seguridad, privacidad o para acceder a recursos en una red privada. En esas situaciones, la biblioteca requests de Python nos ofrece una manera sencilla de especificar y usar un proxy en nuestras solicitudes.
Primero, definimos el proxy que queremos utilizar. Existen varios tipos de proxies, como HTTP, HTTPS, SOCKS. En este ejemplo usaremos un proxy HTTP.
proxy = {
'http': 'http://tu.proxy.com:puerto',
}
Aquí definimos un diccionario con el protocolo que queremos utilizar (en este caso http) y la dirección del proxy (en este caso http://tu.proxy.com:puerto). Reemplaza tu.proxy.com por la dirección del servidor proxy y puerto por el número de puerto apropiado.
Luego, al realizar una solicitud, podemos pasar este diccionario como argumento a la función requests.get() o requests.post() según corresponda.
import requests
url = 'https://www.ejemplo.com'
response = requests.get(url, proxies=proxy)
print(response.status_code)
Aquí hemos utilizado la función requests.get() para realizar una solicitud GET a https://www.ejemplo.com a través del proxy definido en proxy. Luego imprimimos el código de estado de la respuesta usando response.status_code.
En caso de que necesitemos autenticarnos en el servidor proxy, podemos incluir nuestras credenciales en el diccionario proxy.
proxy = {
'http': 'http://usuario:contraseñ[email protected]:puerto',
}
Aquí hemos agregado usuario:contraseña@ antes de la dirección del proxy. Reemplaza usuario y contraseña con tus credenciales para autenticarte en el proxy.
Y eso es todo lo que necesitamos para usar un proxy en nuestras solicitudes HTTP con la biblioteca requests de Python. Recuerda que algunos proxies pueden requerir configuraciones adicionales, así que asegúrate de verificar las especificaciones de tu servidor proxy antes de utilizarlo.
La biblioteca de Python requests nos permite usar proxies en nuestras solicitudes HTTP de una manera simple y fácil. Basta con definir el proxy que queremos utilizar en un diccionario y pasarlo como argumento en la función de solicitud que vayamos a ejecutar. En caso de necesitar autenticación, podemos agregar nuestras credenciales en el diccionario del proxy.
Manejo de redirecciones en solicitudes HTTP con requests
Cuando estamos realizando solicitudes HTTP con la biblioteca requests en Python, es posible que nos enfrentemos a situaciones en las que la URL que estamos solicitando tenga redirecciones. Un redireccionamiento en una solicitud HTTP ocurre cuando la URL solicitada redirige al cliente a una URL diferente para devolver la respuesta.
El manejo de redirecciones en solicitudes HTTP con requests es muy sencillo, ya que la biblioteca lo maneja automáticamente por defecto. Pero es importante entender cómo funciona para saber cómo hacer una solicitud HTTP y obtener la respuesta correcta.
Ejemplo de redirección
Imaginemos que queremos hacer una solicitud HTTP GET a la URL http://www.ejemplo.com/primera-pagina, pero cuando hacemos la solicitud, recibimos una respuesta con un código de redirección 301, indicando que la página ha sido permanentemente movida a http://www.ejemplo.com/segunda-pagina.
En este caso, requests detecta el código de redirección y realiza una nueva solicitud GET a la nueva URL. Si la nueva URL también tiene un redireccionamiento, requests seguirá realizando solicitudes sucesivas hasta que llegue a una URL que no tenga redirecciones o haya alcanzado el límite máximo de redirecciones.
Control de redirecciones
En algunos casos, puede que no queramos que requests maneje automáticamente los redireccionamientos. En estos casos, podemos controlar el manejo de redirecciones utilizando el parámetro allow_redirects.
Por ejemplo, si queremos evitar que requests siga automáticamente los redireccionamientos, podemos desactivarlos pasando el valor False al parámetro allow_redirects.
import requests
# Hacer una solicitud HTTP GET sin redirecciones
response = requests.get("http://www.ejemplo.com/primera-pagina", allow_redirects=False)
# Comprobar el código de respuesta
if response.status_code == 302:
print("La página fue redireccionada")
En este ejemplo, si la URL http://www.ejemplo.com/primera-pagina tiene un redireccionamiento a otra URL, requests no seguirá el redireccionamiento y devolverá una respuesta con el código 302.
El manejo de redirecciones en solicitudes HTTP con
requestses una tarea fácil que se realiza automáticamente por la biblioteca. Sin embargo, en algunos casos, podemos querer controlar el manejo de redirecciones utilizando el parámetroallow_redirects. En general, es importante entender cómo funcionan los redireccionamientos para obtener la respuesta correcta de nuestra solicitud HTTP.
Trabajando con archivos y datos en solicitudes HTTP con requests
Trabajar con archivos y datos en solicitudes HTTP con requests es realmente sencillo y práctico. Esta biblioteca de Python nos permite realizar solicitudes HTTP y obtener respuestas de sitios web de forma fácil y rápida, incluso con sitios que requieren autenticación o envío de datos.
Para empezar a trabajar con requests, podemos realizar una solicitud GET a una página web y guardar la respuesta en una variable:
import requests
response = requests.get('https://www.ejemplo.com')
Esta respuesta contiene toda la información de la página web, incluyendo el código HTML, las cabeceras y otros detalles. Para acceder al contenido HTML de la página, podemos utilizar el atributo text de la respuesta:
html = response.text
Si deseamos realizar una solicitud POST a una página web y enviar datos en la solicitud, podemos hacerlo de la siguiente manera:
payload = {'username': 'usuario', 'password': 'contraseña'}
response = requests.post('https://www.ejemplo.com/login', data=payload)
En este caso, los datos del formulario de inicio de sesión se han guardado en un diccionario Python llamado payload, el cual se pasa como argumento al realizar la solicitud POST.
Si deseamos enviar archivos en una solicitud, también podemos hacerlo utilizando requests. Por ejemplo, si deseamos enviar una imagen en una solicitud POST, podemos hacer lo siguiente:
files = {'foto': open('foto.jpg', 'rb')}
response = requests.post('https://www.ejemplo.com/upload', files=files)
En este ejemplo, hemos abierto el archivo foto.jpg en modo binario y lo hemos incluido en un diccionario de archivos que se pasa como argumento al realizar la solicitud POST.
requests es una herramienta muy útil para trabajar con solicitudes y respuestas HTTP en Python. Con esta biblioteca podemos realizar solicitudes GET y POST, enviar datos y archivos en las solicitudes y mucho más. Si estás interesado en aprender más sobre esta biblioteca, te recomendamos revisar la documentación oficial de requests y experimentar con algunos ejemplos. ¡Pronto podrás estar realizando solicitudes HTTP en Python de forma fácil y eficiente!
Manejo de sesiones de usuario en solicitudes HTTP con requests
Cuando trabajamos con solicitudes HTTP es común necesitar mantener cierta información durante la conexión, como puede ser el inicio de sesión de un usuario en un sitio web. Para este tipo de situación, la biblioteca requests de Python ofrece una forma sencilla y eficiente de manejar sesiones de usuario.
Una sesión de usuario es una serie de solicitudes HTTP que se realizan desde un mismo cliente o usuario. Para manejar estas sesiones en nuestra aplicación, requests nos ofrece la clase Session. Esta clase nos permite mantener información entre varias solicitudes HTTP, como por ejemplo las cookies o el estado de sesión.
La creación de una sesión es muy sencilla, simplemente creamos una instancia de la clase Session y luego realizamos las solicitudes HTTP normalmente. Para utilizar una sesión en una solicitud específica, en lugar de utilizar la función get o post directamente, utilizamos los métodos correspondientes de la sesión. Por ejemplo:
import requests
# Creamos una sesión
s = requests.Session()
# Realizamos una solicitud GET utilizando la sesión
response = s.get('https://ejemplo.com')
# Realizamos una solicitud POST utilizando la sesión
payload = {'usuario': 'ejemplo', 'password': '12345'}
response = s.post('https://ejemplo.com/login', data=payload)
En el ejemplo anterior, creamos una sesión utilizando la clase Session de requests. Luego realizamos dos solicitudes HTTP, una GET y una POST, utilizando la sesión creada en lugar de llamar directamente a las funciones get y post de requests. A través de la sesión, se mantendrá la información de cookies y estado de sesión.
Otro beneficio de utilizar sesiones en nuestras solicitudes HTTP es la posibilidad de personalizar la sesión. Por ejemplo, podemos establecer valores predeterminados para encabezados o autenticación básica, y estos valores se mantendrán en todas las solicitudes realizadas a través de la sesión.
import requests
# Creamos una sesión
s = requests.Session()
# Establecemos un encabezado predeterminado
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'}
s.headers.update(headers)
# Realizamos una solicitud GET utilizando la sesión
response = s.get('https://ejemplo.com')
En este segundo ejemplo, además de crear una sesión, establecemos un encabezado predeterminado utilizando la función headers.update de la sesión. Este encabezado se utilizará en todas las solicitudes realizadas a través de la sesión.
El manejo de sesiones de usuario en solicitudes HTTP con requests es sencillo y eficiente. Utilizando la clase Session podemos mantener información entre varias solicitudes HTTP, personalizar la sesión con encabezados predeterminados y establecer valores de cookies o estado de sesión. Todo esto nos permite desarrollar aplicaciones más robustas y eficientes en Python.