# Python requests: Enviar requisições HTTP em Python

Python `requests` é uma biblioteca popular que permite enviar requisições HTTP e verificar as respostas. Embora `.get()` seja o método mais importante do módulo, há várias outras opções disponíveis.

## O que é Python `requests`?

Python `requests` é uma biblioteca padrão que permite enviar **requisições HTTP** dentro da linguagem de programação. Com base em uma interface de programação simples e eficaz, a biblioteca facilita a integração de recursos de terceiros. Python `requests` oferece diversas ferramentas para enviar requisições HTTP e obter as respostas correspondentes. Embora amplamente utilizada e recomendada, a biblioteca **não faz parte da instalação padrão** do Python.

## Instalação e iniciação da biblioteca Python `requests`

Antes de instalar o Python `requests`, é recomendável configurar primeiro uma máquina virtual, onde você pode testar a biblioteca com segurança. Para instalar, utilize o `pip`. O código é o seguinte:

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

Para usar a biblioteca após a instalação, você precisa do seguinte código:

```python
import requests
```

## Funcionamento, sintaxe e métodos de Python `requests`

Assim como outras ferramentas similares, o Python `requests` envia uma requisição HTTP e, quando transmitida com sucesso, recebe uma resposta. Esta resposta é um objeto que contém todas as informações essenciais, como **conteúdo, codificação e status**. A sintaxe de uma *request* (requisição) é sempre da seguinte forma:

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

Nota `kwargs` refere-se a argumentos opcionais que você pode passar para métodos como `headers`, `files` ou `cookies`.

Embora `.get()` seja o método que você mais utilizará, o Python `requests` oferece alguns outros. Estes são os seguintes:

- `.delete(url, **kwargs)`: Com `.delete()` você exclui um recurso específico no servidor.
- `.get(url, params=None, **kwargs)`: Com `.get()`, você solicita informações de um servidor.
- `.head(url, **kwargs)`: Com `.head()`, você solicita apenas os cabeçalhos de uma resposta do servidor.
- `.patch(url, data=None, **kwargs)`: Com `.patch()`, você modifica parcialmente um recurso, enviando apenas as alterações necessárias
- `.post(url, data=None, json=None, **kwargs)`: Com `.post()`, você envia dados para um servidor, geralmente para criar um novo recurso.
- `.put(url, data=None, **kwargs)`: Com `.put()`, você atualiza um recurso existente ou o cria, caso ainda não exista.
- `.request(method, url, **kwargs)`: Com `.request()`, você envia uma requisição HTTP personalizada, especificando o método e a URL.

## Exemplo do método `.get()` com Python `requests`

A estrutura do `.get()` é muito simples, o que torna o Python `requests` uma biblioteca prática. Você só precisa do método e da URL que deseja acessar. A URL deve ser escrita entre aspas. Um exemplo de código seria:

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

Agora, você receberá uma resposta do servidor. Para exemplificar, você pode armazenar a resposta em uma variável. No nosso exemplo, ficaria assim:

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

## Consultar códigos de status

A resposta mais simples que você recebe em uma requisição é um código de status HTTP. Ele indica se a solicitação foi bem-sucedida ou não. O código de status é composto por três dígitos e possui diversas variantes que informam sobre o andamento da solicitação. As principais categorias incluem:

- **1XX**: Contém informações informativas
- **2XX**: Indica uma solicitação bem-sucedida
- **3XX**: Informa um redirecionamento da solicitação
- **4XX**: Indica um erro causado pelo cliente
- **5XX**: Indica um erro causado pelo servidor

Os códigos de status mais conhecidos são: “200 – OK” (indicam uma solicitação bem-sucedida) e “404 – Not Found”, (ocorre quando os dados solicitados não são encontrados no servidor).

Após fazer uma requisição com Python `requests`, você pode consultar o status com `.status_code`. Para isso, use este código:

```python
response.status_code
```

Se a solicitação for bem-sucedida, a saída será:

```python
200
```

Para uma visualização mais clara, utilize o código a seguir:

```python
if response.status_code == 200: 
print("A solicitação foi bem-sucedida.") 
elif response.status_code == 404: 
print("A solicitação não foi bem-sucedida.")
```

## Visualizar cabeçalhos com Python `requests`

O cabeçalho de uma resposta HTTP contém várias informações úteis. Entre elas, estão **o tipo de dado enviado, o tempo de cache** e outras informações. Com a biblioteca Python `requests`, você pode acessar os cabeçalhos de forma simples. Para isso, primeiro faça uma requisição com `.get()` e depois `.headers`:

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

A saída será um objeto contendo os valores dos cabeçalhos. Esses valores podem ser consultados individualmente, especificando a chave correspondente. Se você quiser verificar o tipo de dado retornado, use o seguinte comando:

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

## Acessar Payload

O conjunto de dados **enviado entre o servidor e o cliente** é conhecido como “Payload”. Ele está localizado no corpo da resposta HTTP. Com `response`, você pode acessar essas informações. Para visualizar o conteúdo em bytes, use a seguinte instrução:

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

Se você quiser converter as informações coletadas em uma string, use o seguinte código:

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

Python `requests` usa automaticamente a codificação definida no cabeçalho da resposta. Se necessário, você pode instruir o sistema a usar outro método. Este é um exemplo de código:

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

## Verificar progresso

Ao enviar uma requisição, o Python `requests` prepara o processo para evitar erros. Entre outras ações, ele verifica os **cabeçalhos** da requisição. Você pode acompanhar o progresso dessa verificação utilizando o atributo `.request`. O código a seguir mostra como fazer isso:

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

Com esse código, você obtém informações sobre o Payload, os cabeçalhos, a URL e outros detalhes da requisição.

## Autenticação com o módulo Python `requests`

O parâmetro `auth` é utilizado no Python `requests` para autenticar a requisição junto ao servidor. Isso permite que o servidor valide a autenticidade da requisição e controle com quem está interagindo. Para usar a autenticação, você pode aplicar o seguinte código:

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

## Usar certificado SSL

O uso de um [certificado SSL](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/criar-sites/certificado-ssl/ "Certificado SSL") é geralmente recomendado para proteger os dados e evitar acessos não autorizados. O Python `requests` oferece essa opção por padrão. Se for necessário **desativar a verificação SSL** para uma requisição específica, você pode fazer isso com o seguinte código:

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

No entanto, o Python `requests` exibirá um aviso ao fazer isso.

## Configurar timeout no Python `requests`

No Python `requests`, você também pode definir um **tempo limite para uma resposta**. Por padrão, o cliente pode esperar indefinidamente por uma resposta. Se essa resposta não chegar, as requisições podem se acumular e comprometer o desempenho. O parâmetro `timeout` evita esse problema. No exemplo a seguir, o Python `requests` será configurado para cancelar a requisição após dois segundos:

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

Dica Implante seu site ou aplicativo diretamente via GitHub: Com o [Deploy Now](https://www.ionos.com/hosting/deploy-now "Deploy Now — IONOS") da IONOS, você obtém a solução ideal para aplicações Single-Page e sites estáticos. Escolha o plano adequado para suas necessidades e aproveite uma configuração mais rápida, fluxos de trabalho otimizados e um design seguro!


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-requests/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/python-requests/) for AI/LLM consumption.