# Python requests: enviar solicitudes HTTP con Python

Python `requests` es una biblioteca popular que permite enviar solicitudes HTTP y comprobar las respuestas. Aunque `.get()` es el método más utilizado del módulo, existen muchas otras opciones disponibles.

## ¿Qué es Python `requests`?

Python `requests` es una herramienta estándar que te permite **enviar solicitudes HTTP** a través del [lenguaje de programación](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/que-lenguaje-de-programacion-aprender/) Python. Se basa en una interfaz de programación clara y eficaz que facilita mucho la integración de funciones de terceros. La biblioteca `requests` de Python ofrece varias herramientas con las que puedes enviar solicitudes HTTP y recibir las respuestas correspondientes. Aunque el módulo Python `requests` es ampliamente utilizado y muy recomendable, **no forma parte de la instalación estándar de Python**.

## Instalación y uso de la biblioteca Python `requests`

Antes de instalar la biblioteca Python `requests`, se recomienda configurar primero una [máquina virtual](https://www.ionos.es/digitalguide/servidores/know-how/maquina-virtual/) donde puedas probarla sin preocupaciones. Después, utiliza `pip` para la instalación con el siguiente comando:

```bash
$ python -m pip install requests
```

Una vez instalada, puedes importar la biblioteca en tu código con el siguiente comando:

```python
import requests
```

## Funcionamiento, sintaxis y métodos

Al igual que otras herramientas similares, Python `requests` también envía una solicitud HTTP y, si la transmisión tiene éxito, recibe una respuesta. La respuesta es un objeto que contiene toda la información importante, como el **contenido, la codificación y el estado**. La sintaxis de una solicitud de este tipo es la siguiente:

```python
requests.method(url, **kwargs)
```

Nota `**kwargs` representa argumentos opcionales que puedes pasar a las funciones, como `headers`, `files` o `cookies`.

Aunque `.get()` es la función que usarás más a menudo, Python requests te ofrece otros métodos. Las funciones disponibles son:

- `.delete(url, **kwargs)`: utiliza `.delete()` para eliminar un recurso específico
- `.get(url, parameter=None, **kwargs)`: utiliza `.get()` para solicitar información a un servidor
- `.head(url, **kwargs)`: con `.head()` también solicitas una respuesta de un servidor, pero te limitas al encabezado
- `.patch(url, data=None, **kwargs)`: con `.patch()` puedes mejorar el rendimiento, ya que solo envía cambios al recurso
- `.post(url, data=None, json=None, **kwargs)`: con `.post()` envías datos al servidor, como formularios o información en formato JSON
- `.put(url, data=None, **kwargs)`: con `.put()` modificas un recurso existente y generas nuevos datos en el servidor.
- `.request(method, url, **kwargs)`: con `.request()` envías una solicitud utilizando un método específico a la URL

## Ejemplo del método `.get()`

La estructura de `.get()` es muy sencilla, lo que hace que Python `requests` sea una biblioteca práctica. Solo necesitas el método y la URL a la que quieres acceder, la cual se escribe entre comillas. Aquí tienes un ejemplo:

```python
import requests
requests.get("https://ejemplo.com")
```

Recibirás la respuesta del servidor objetivo automáticamente. Puedes almacenar la respuesta en una variable para examinarla posteriormente:

```python
import requests
response = requests.get("https://ejemplo.com")
```

## Consultar códigos de estado

La respuesta más básica que puedes recibir de una solicitud es un [código de estado HTTP](https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/una-mirada-a-los-codigos-de-estado-http-mas-comunes/), que te indica si la solicitud fue exitosa o no. El código de estado es de tres dígitos, y existen varias categorías que te informan sobre el resultado de tu solicitud. Aquí tienes las categorías más importantes:

- **1XX**: contiene información adicional
- **2XX**: indica que la solicitud fue exitosa
- **3XX**: informa de una redirección de tu solicitud
- **4XX**: informa de un error del lado del cliente
- **5XX**: informa de un error del lado del servidor

Entre los códigos de estado más comunes se encuentran “200 – OK” (para una solicitud exitosa) y “[404 – Not Found](https://www.ionos.es/digitalguide/paginas-web/creacion-de-paginas-web/que-significa-el-error-404-not-found/)” (si los datos solicitados no se encuentran en el servidor).

Después de hacer una solicitud con Python `requests`, puedes consultar el estado usando `.status_code`. Para ello, utiliza el siguiente código:

```python
response.status_code
```

Si la solicitud tuvo éxito, recibirás el siguiente resultado:

```python
200
```

Puedes usar el siguiente código para visualizarlo mejor:

```python
if response.status_code == 200:
	print("La solicitud tuvo éxito.")
elif response.status_code == 404:
	print("La solicitud no tuvo éxito.")
```

## Ver los encabezados con Python `requests`

El encabezado de una respuesta HTTP contiene mucha información útil. Entre otros datos, encontrarás el **tipo de contenido enviado, el límite de tiempo para el almacenamiento en caché** y otros detalles. Con la biblioteca Python `requests`, puedes ver fácilmente el encabezado. Primero, ejecuta la función `.get()` y luego accede a `.headers`:

```python
import requests
response = requests.get("https://ejemplo.com")
response.headers
```

La salida te mostrará un objeto que contiene los valores del encabezado. También puedes consultar valores individuales especificando el comando correspondiente. Por ejemplo, si quieres saber más sobre el tipo de contenido, debes ejecutar el siguiente código:

```python
response.headers["content-type"]
```

## Acceder al payload

El paquete de datos que se envía **entre el servidor y el cliente** se conoce como “payload” y se encuentra en el cuerpo de la respuesta. Puedes utilizar `response` para acceder a la información del payload. Para obtener una representación en bytes, utiliza el siguiente código:

```python
import requests
response = requests.get("https://ejemplo.com")
response.content
type(response.content)
```

Si prefieres introducir la información obtenida en una cadena, utiliza el siguiente código:

```python
response.text
type(response.text)
```

Python `requests` obtendrá la codificación del encabezado. Como alternativa, también puedes indicar al sistema que utilice un método de codificación diferente. Aquí tienes un código de ejemplo:

```python
response.encoding = "utf-8"
response.text
```

## Verificar el progreso

Cuando envías una solicitud, Python `requests` se prepara para evitar errores no deseados. Durante el envío de la solicitud, entre otras cosas, **comprueba el encabezado**. Puedes consultar el progreso de la solicitud utilizando la función `.request`, con el siguiente código:

```python
import requests
response = requests.post("https://ejemplo.com", json={"key": "value"})
print(response.request.headers["content-type"])
print(response.request.url)
print(response.request.body)
```

Esto te proporciona información sobre el payload, el encabezado, la URL y muchos otros aspectos.

## Autenticación con el módulo de Python`requests`

El parámetro `auth` se utiliza en Python `requests` para enviar una autenticación al servidor, permitiendo verificar la identidad de quien interactúa con él. usa el siguiente código para aplicar la función de autenticación:

```python
import requests
from requests.auth import HTTPBasicAuth
response = requests.get("https://tupagina.com/basic-auth/user/passwd", 
	auth=HTTPBasicAuth("user", "passwd"))
print(response.status_code)
print(response.request.headers["Authorization"])
```

## Utilizar un certificado SSL

En general, se recomienda utilizar un [certificado SSL](https://www.ionos.es/digitalguide/paginas-web/creacion-de-paginas-web/certificado-ssl/) para evitar la pérdida de datos y accesos no autorizados. Python `requests` ofrece un certificado SSL de forma predeterminada. Sin embargo, si quieres evitar la verificación SSL al hacer una solicitud, puedes hacerlo con el siguiente código:

```python
import requests
requests.get("https://ejemplo.com", verify=False)
```

De todas formas, recibirás una advertencia al respecto.

## Iniciar un timeout con Python `requests`

Con Python `requests`, también puedes limitar el **tiempo máximo de espera para una respuesta**. De manera predeterminada, el cliente esperará una respuesta indefinidamente. Si la respuesta no llega, las solicitudes pueden acumularse y afectar al rendimiento, pero puedes evitarlo con el parámetro `timeout`. El siguiente código hace que Python `requests` cancele la solicitud una vez transcurridos al menos dos segundos:

```python
requests.get("https://ejemplo.com", timeout=2)
```

Consejo Despliega tu página web o aplicación directamente desde GitHub: [Deploy Now](https://www.ionos.es/alojamiento/deploy-now "Deploy Now de IONOS") de IONOS es la mejor opción tanto para aplicaciones de una sola página como para páginas web estáticas. ¡Elige la tarifa que mejor se adapte a tus necesidades y disfruta de una configuración más rápida, flujos de trabajo optimizados y un diseño seguro!


This is a markdown version of: [https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/modulo-python-requests/](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/modulo-python-requests/) for AI/LLM consumption.