Requests é uma biblioteca HTTP que fornece funcionalidade fácil para lidar com solicitações / respostas http em seu aplicativo da web. A biblioteca é desenvolvida em python.

O site oficial de solicitações Python que está disponível em https://2.python-requests.org/en/master/ define os pedidos da seguinte forma -

Requests é uma biblioteca HTTP elegante e simples para Python, construída para seres humanos.

Recursos de solicitações

Os recursos de solicitações são discutidos abaixo -

Solicitação

A biblioteca de solicitações Python possui métodos fáceis de usar disponíveis para lidar com solicitações Http. A passagem de parâmetros e o tratamento do tipo de solicitação como GET, POST, PUT, DELETE, etc. é muito fácil.

Resposta

Você pode obter a resposta no formato necessário e os compatíveis são formato de texto, resposta binária, resposta json e resposta bruta.

Cabeçalhos

A biblioteca permite que você leia, atualize ou envie novos cabeçalhos de acordo com seus requisitos.

Timeouts

Limites de tempo podem ser facilmente adicionados ao URL que você está solicitando, usando a biblioteca de solicitações Python. Acontece que você está usando um URL de terceiros e aguardando uma resposta.

É sempre uma boa prática fornecer um tempo limite no URL, pois podemos querer que o URL responda dentro desse tempo limite com uma resposta ou um erro que está ocorrendo devido ao tempo limite. Não fazer isso pode fazer com que qualquer um deles espere por esse pedido indefinidamente.

Manipulação de erros

O módulo de solicitações oferece suporte para tratamento de erros e alguns dos quais são erros de conexão, erros de tempo limite, erros TooManyRedirects, Response.raise_for_status, etc.

Biscoitos

A biblioteca permite que você leia, escreva e atualize o URL solicitado.

Sessões

Para manter os dados, você precisa de sessões entre as solicitações. Portanto, se o mesmo host for chamado repetidamente, você poderá reutilizar a conexão TCP, o que, por sua vez, melhorará o desempenho.

Certificados SSL

O certificado SSL é um recurso de segurança que vem com urls seguros. Quando você usa Requests, ele também verifica os certificados SSL para o URL https fornecido. A verificação SSL é ativada por padrão na biblioteca de solicitações e gerará um erro se o certificado não estiver presente.

Autenticação

A autenticação HTTP está no lado do servidor solicitando algumas informações de autenticação, como nome de usuário e senha, quando o cliente solicita um URL. Esta é uma segurança adicional para a solicitação e a resposta sendo trocadas entre o cliente e o servidor.

Vantagens de usar a biblioteca de solicitações Python

A seguir estão as vantagens de usar a biblioteca de solicitações do Python -

• Fácil de usar e buscar os dados do URL fornecido.

• A biblioteca de solicitações pode ser usada para extrair os dados do site.

• Usando solicitações, você pode obter, postar, excluir e atualizar os dados do URL fornecido.

• O tratamento dos cookies e da sessão é muito fácil.

• A segurança também é garantida com a ajuda do suporte do módulo de autenticação.

Neste capítulo, trabalharemos na instalação de Requests. Para começar a trabalhar com o módulo Requests, precisamos primeiro instalar o Python. Então, vamos trabalhar para seguir -

• Instale Python
• Solicitações de instalação

Instalando Python

Vá para o site oficial do Python: https://www.python.org/downloads/conforme mostrado abaixo e clique na versão mais recente disponível para Windows, Linux / Unix e Mac OS. Baixe o Python de acordo com seu sistema operacional de 64 ou 32 bits disponível com você.

Depois de fazer o download, clique no arquivo .exe e siga as etapas para instalar o python em seu sistema.

O gerenciador de pacotes python, ou seja, pip também será instalado por padrão com a instalação acima. Para fazê-lo funcionar globalmente em seu sistema, adicione diretamente a localização de python à variável PATH. O mesmo é mostrado no início da instalação para lembrar de marcar a caixa de seleção que diz ADD to PATH. Caso você se esqueça de verificar, siga as etapas fornecidas abaixo para adicionar ao PATH.

Para adicionar ao PATH, siga os passos -

Clique com o botão direito no ícone do seu computador e clique em propriedades> Configurações avançadas do sistema.

Ele exibirá a tela conforme mostrado abaixo -

Clique em Variáveis ​​de ambiente como mostrado acima. Ele exibirá a tela conforme mostrado abaixo -

Selecione o caminho e clique no botão Editar, adicione o caminho da localização do seu python no final. Agora, vamos verificar a versão do python.

Verificando a versão python

E:\prequests>python --version
Python 3.7.3

Solicitações de instalação

Agora que instalamos o python, vamos instalar o Requests.

Assim que o python estiver instalado, o gerenciador de pacotes python, ou seja, o pip também será instalado. A seguir está o comando para verificar a versão do pip.

E:\prequests>pip --version
pip 19.1.1 from c:\users\xxxxx\appdata\local\programs\python\python37\lib\site-p
ackages\pip (python 3.7)

Temos o pip instalado e a versão é 19.1.1. Agora, usaremos o pip para instalar o módulo Requests.

O comando é dado abaixo−

pip install requests

E:\prequests>pip install requests
Requirement already satisfied: requests in c:\users\xxxx\appdata\local\programs
\python\python37\lib\site-packages (2.22.0)
Requirement already satisfied: certifi>=2017.4.17 in c:\users\kamat\appdata\loca
l\programs\python\python37\lib\site-packages (from requests) (2019.3.9)
Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in c:\use
rs\xxxxx\appdata\local\programs\python\python37\lib\site-packages (from requests
) (1.25.3)
Requirement already satisfied: idna<2.9,>=2.5 in c:\users\xxxxxxx\appdata\local\pr
ograms\python\python37\lib\site-packages (from requests) (2.8)
Requirement already satisfied: chardet<3.1.0,>=3.0.2 in c:\users\xxxxx\appdata\l
ocal\programs\python\python37\lib\site-packages (from requests) (3.0.4)

Já temos o módulo instalado, então no prompt de comando diz Requisito já atendido; se não estiver instalado, ele baixará os pacotes necessários para a instalação.

Para verificar os detalhes do módulo de solicitações instalado, você pode usar o seguinte comando−

pip show requests
E:\prequests>pip show requests
Name: requests
Version: 2.22.0
Summary: Python HTTP for Humans.
Home-page: http://python-requests.org
Author: Kenneth Reitz
Author-email: [email protected]
License: Apache 2.0
Location: c:\users\xxxxx\appdata\local\programs\python\python37\lib\site-package
S
Requires: certifi, idna, urllib3, chardet
Required-by:

A versão do módulo Requests é 2.22.0.

Python's Requests é uma biblioteca HTTP que nos ajudará a trocar dados entre o cliente e o servidor. Considere que você tem uma IU com um formulário, no qual você precisa inserir os detalhes do usuário, então, depois de inseri-los, você deve enviar os dados, que nada mais são do que uma solicitação Http POST ou PUT do cliente ao servidor para salvar os dados.

Quando quiser os dados, você precisa buscá-los no servidor, o que é novamente uma solicitação Http GET. A troca de dados entre o cliente quando este solicita os dados e o servidor respondendo com os dados solicitados, esta relação entre o cliente e o servidor é muito importante.

A solicitação é feita para o URL fornecido e pode ser um URL seguro ou não seguro.

A solicitação da URL pode ser feita usando GET, POST, PUT, DELETE. O mais comumente usado é o método GET, usado principalmente quando você deseja buscar dados do servidor.

Você também pode enviar dados para a URL como uma string de consulta, por exemplo -

https://jsonplaceholder.typicode.com/users?id=9&username=Delphine

Então, aqui, estamos passando id = 9 e username = Delphine para a URL. Todos os valores são enviados no par chave / valor após o ponto de interrogação (?) E vários parâmetros são passados ​​para a URL separados por &.

Usando a biblioteca de solicitações, a URL é chamada da seguinte maneira, usando um dicionário de string.

Onde os dados para a URL são enviados como um dicionário de strings. Se você quiser passar id = 9 e username = Delphine, você pode fazer o seguinte−

payload = {'id': '9', 'username': 'Delphine'}

A biblioteca de pedidos é chamada da seguinte maneira -

res = requests.get('https://jsonplaceholder.typicode.com/users', params=payload')

Usando POST, podemos fazer o seguinte−

res = requests.post('https://jsonplaceholder.typicode.com/users', data = {'id':'9', 'username':'Delphine'})

Usando PUT

res = requests.put('https://jsonplaceholder.typicode.com/users', data = {'id':'9', 'username':'Delphine'})

Usando DELETE

res = requests.delete('https://jsonplaceholder.typicode.com/users')

A resposta da solicitação Http pode ser em formato de texto codificado, formato binário, formato json ou resposta bruta. Os detalhes da solicitação e resposta são explicados em detalhes nos próximos capítulos.

Neste capítulo, vamos entender como trabalhar com o módulo de requisições. Vamos analisar o seguinte

• Fazendo solicitações HTTP.
• Passando parâmetros para solicitações HTTP.

Fazendo solicitações HTTP

Para fazer uma solicitação Http, precisamos primeiro importar o módulo de solicitação como mostrado abaixo−

import requests

Vamos agora ver como fazer uma chamada para URL usando o módulo de solicitações.

Deixe-nos usar o URL- https://jsonplaceholder.typicode.com/users no código, para testar o Módulo de Solicitações.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.status_code)

O url− https://jsonplaceholder.typicode.com/usersé chamado usando o método requests.get (). O objeto de resposta da URL é armazenado na variável getdata. Quando imprimimos a variável, ela fornece o código de resposta 200, o que significa que obtivemos a resposta com sucesso.

Resultado

E:\prequests>python makeRequest.py
<Response [200]>

Para obter o conteúdo da resposta, podemos fazer isso usando getdata.content como mostrado abaixo

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)

getdata.content, imprimirá todos os dados disponíveis na resposta.

Resultado

E:\prequests>python makeRequest.py
b'[\n {\n  "id": 1,\n  "name": "Leanne Graham",\n  "username": "Bret",\n
"email": "[email protected]",\n  "address": {\n  "street": "Kulas Light
",\n  "suite": "Apt. 556",\n  "city": "Gwenborough",\n  "zipcode": "
92998-3874",\n  "geo": {\n "lat": "-37.3159",\n  "lng": "81.149
6"\n }\n },\n  "phone": "1-770-736-8031 x56442",\n  "website": "hild
egard.org",\n  "company": {\n "name": "Romaguera-Crona",\n  "catchPhr
ase": "Multi-layered client-server neural-net",\n  "bs": "harness real-time
e-markets"\n }\n }

Passando parâmetros para solicitações HTTP

Apenas solicitar o URL não é suficiente, também precisamos passar parâmetros para o URL.

Os parâmetros são geralmente passados ​​como par chave / valor, por exemplo -

 https://jsonplaceholder.typicode.com/users?id=9&username=Delphine

Portanto, temos id = 9 e username = Delphine. Agora, veremos como passar esses dados para o módulo Http de solicitações.

Exemplo

import requests
payload = {'id': 9, 'username': 'Delphine'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users', params=payload)
print(getdata.content)

Os detalhes são armazenados na carga útil do objeto no par chave / valor e passados ​​para params, dentro do método get ().

Resultado

E:\prequests>python makeRequest.py
b'[\n {\n "id": 9,\n "name": "Glenna Reichert",\n "username": "Delphin
e",\n "email": "[email protected]",\n "address": {\n "street":
"Dayna Park",\n "suite": "Suite 449",\n "city": "Bartholomebury",\n
"zipcode": "76495-3109",\n "geo": {\n "lat": "24.6463",\n
"lng": "-168.8889"\n }\n },\n "phone": "(775)976-6794 x41206",\n "
website": "conrad.com",\n "company": {\n "name": "Yost and Sons",\n
"catchPhrase": "Switchable contextually-based project",\n "bs": "aggregate
real-time technologies"\n }\n }\n]'

Agora estamos obtendo os detalhes dos detalhes id = 9 e username = Delphine na resposta.

Se você quiser ver como fica a URL após passar os parâmetros, fazendo uso do objeto de resposta para a URL.

Exemplo

import requests
payload = {'id': 9, 'username': 'Delphine'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users', params=payload)
print(getdata.url)

Resultado

E:\prequests>python makeRequest.py
https://jsonplaceholder.typicode.com/users?id=9&username=Delphine

Neste capítulo, entraremos em mais detalhes sobre a resposta recebida do módulo de solicitações. Discutiremos os seguintes detalhes−

• Obtendo uma resposta
• Resposta JSON
• Resposta RAW
• Resposta Binária

Obtendo uma resposta

Faremos uma solicitação ao URL usando o método request.get ().

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users');

O getdata possui o objeto de resposta. Ele contém todos os detalhes da resposta. Podemos obter uma resposta de 2 maneiras usando (. Texto ) e (. Conteúdo ). O uso de response.text fornecerá os dados de volta em formato de texto, conforme mostrado abaixo−

Exemplo

E:\prequests>python makeRequest.py
[
 {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
  }
},

Você verá que a resposta é a mesma, como deveria aparecer no navegador quando você visualiza o código-fonte da URL como mostrado abaixo-

Você também pode experimentar o URL .html e ver o conteúdo usando response.text; será o mesmo que visualizar o conteúdo de origem do URL .html no navegador.

Agora, vamos tentar response.content para o mesmo URL e ver a saída.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)

Resultado

E:\prequests>python makeRequest.py
b'[\n {\n "id": 1,\n "name": "Leanne Graham",\n "username": "Bret",\n
"email": "[email protected]",\n "address": {\n "street": "Kulas Light
",\n "suite": "Apt. 556",\n "city": "Gwenborough",\n "zipcode": "
92998-3874",\n "geo": {\n "lat": "-37.3159",\n "lng": "81.149
6"\n }\n },\n "phone": "1-770-736-8031 x56442",\n "website": "hild
egard.org",\n "company": {\n "name": "Romaguera-Crona",\n "catchPhr
ase": "Multi-layered client-server neural-net",\n "bs": "harness real-time
e-markets"\n }\n },\n {\n "id": 2,\n "name": "Ervin Howell",\n "us
ername": "Antonette",\n "email": "[email protected]",\n "address": {\n
"street": "Victor Plains",\n "suite": "Suite 879",\n "city": "Wisoky
burgh",\n "zipcode": "90566-7771",\n "geo": {\n "lat": "-43.950
9",\n "lng": "-34.4618"\n }\n },\n "phone": "010-692-6593 x091
25",\n "website": "anastasia.net",\n "company": {\n "name": "Deckow-C
rist",\n "catchPhrase": "Proactive didactic contingency",\n "bs": "syn
ergize scalable supply-chains"\n }\n },\n {\n "id": 3,\n "name": "Cle
mentine Bauch",\n "username": "Samantha",\n "email":
"[email protected]",
\n "address": {\n "street": "Douglas Extension",\n "suite": "Suite
847",\n "city": "McKenziehaven",\n "zipcode": "59590-4157",\n "ge
o": {\n "lat": "-68.6102",\n "lng": "-47.0653"\n }\n },\n

A resposta é dada em bytes. Você receberá uma cartabno início da resposta. Com o módulo de solicitações, você pode obter a codificação usada e também alterar a codificação, se necessário. Por exemplo, para obter a codificação, você pode usar response.encoding.

print(getdata.encoding)

Resultado

utf-8

Você pode alterar a codificação da seguinte maneira - você pode usar a codificação de sua escolha.

getdata.encoding = 'ISO-8859-1'

Resposta JSON

Você também pode obter a resposta para a solicitação Http no formato json usando o método response.json () da seguinte maneira -

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.json())

Resultado

E:\prequests>python makeRequest.py
[{'id': 1, 'name': 'Leanne Graham', 'username': 'Bret', 'email': 'Sincere@april.
biz', 'address': {'street': 'Kulas Light', 'suite': 'Apt. 556', 'city': 'Gwenbor
ough', 'zipcode': '92998-3874', 'geo': {'lat': '-37.3159', 'lng': '81.1496'}},
'
phone': '1-770-736-8031 x56442', 'website': 'hildegard.org', 'company': {'name':
'Romaguera-Crona', 'catchPhrase': 'Multi-layered client-server neural-net', 'bs
': 'harness real-time e-markets'}}]

Resposta RAW

No caso de precisar da resposta bruta para o URL Http, você pode usar response.raw, também adicione stream=True dentro do método get, conforme mostrado abaixo−

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', stream=True)
print(getdata.raw)

Resultado

E:\prequests>python makeRequest.py
<urllib3.response.HTTPResponse object at 0x000000A8833D7B70>

Para ler mais conteúdo dos dados brutos, você pode fazer da seguinte maneira -

print(getdata.raw.read(50))

Resultado

E:\prequests>python makeRequest.py
b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x95\x98[o\xe38\x12\x85\xdf\xe7W\x10y\
xda\x01F\x82.\xd4m\x9f\xdc\x9dd\xba\xb7\x93\xf4\x06q\xef4\x06\x83A@K\x15\x89m'

Resposta Binária

Para obter uma resposta binária, podemos usar response.content.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)

Resultado

E:\prequests>python makeRequest.py
b'[\n {\n "id": 1,\n "name": "Leanne Graham",\n "username": "Bret",\n
"email": "[email protected]",\n "address": {\n "street": "Kulas Light
",\n "suite": "Apt. 556",\n "city": "Gwenborough",\n "zipcode": "
92998-3874",\n "geo": {\n "lat": "-37.3159",\n "lng": "81.149
6"\n }\n },\n "phone": "1-770-736-8031 x56442",\n "website": "hild
egard.org",\n "company": {\n "name": "Romaguera-Crona",\n "catchPhr
ase": "Multi-layered client-server neural-net",\n "bs": "harness real-time
e-markets"\n }\n },\n {\n "id": 2,\n "name": "Ervin Howell",\n "us
ername": "Antonette",\n "email": "[email protected]",\n "address": {\n
"street": "Victor Plains",\n "suite": "Suite 879",\n "city": "Wisoky
burgh",\n "zipcode": "90566-7771",\n "geo": {\n "lat": "-43.950
9",\n "lng": "-34.4618"\n }\n },\n "phone": "010-692-6593 x091
25",\n "website": "anastasia.net",\n "company": {\n "name": "Deckow-C
rist",\n "catchPhrase": "Proactive didactic contingency",\n "bs": "syn
ergize scalable supply-chains"\n }\n },\n {\n "id": 3,\n "name": "Cle
mentine Bauch",\n "username": "Samantha",\n "email": "[email protected]",
\n "address": {\n "street": "Douglas Extension",\n "suite": "Suite
847",\n "city": "McKenziehaven",\n "zipcode": "59590-4157",\n "ge
o": {\n "lat": "-68.6102",\n "lng": "-47.0653"\n }\n },\n

A resposta é dada em bytes. Você receberá uma cartabno início da resposta. A resposta binária é usada principalmente para solicitações não textuais.

Solicitações - cabeçalhos de solicitações HTTP

No capítulo anterior, vimos como fazer a solicitação e obter a resposta. Este capítulo explorará um pouco mais a seção de cabeçalho da URL. Então, vamos dar uma olhada no seguinte

• Noções básicas sobre cabeçalhos de solicitação
• Cabeçalhos personalizados
• Cabeçalhos de resposta

Noções básicas sobre cabeçalhos de solicitação

Acesse qualquer URL no navegador, inspecione-o e verifique na guia de rede da ferramenta de desenvolvedor.

Você receberá cabeçalhos de resposta, cabeçalhos de solicitação, carga útil, etc.

Por exemplo, considere o seguinte URL−

https://jsonplaceholder.typicode.com/users

Você pode obter os detalhes do cabeçalho da seguinte maneira -

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', stream=True)
print(getdata.headers)

Resultado

E:\prequests>python makeRequest.py
{'Date': 'Sat, 30 Nov 2019 05:15:00 GMT', 'Content-Type': 'application/json; cha
rset=utf-8', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'Set-Co
okie': '__cfduid=d2b84ccf43c40e18b95122b0b49f5cf091575090900; expires=Mon, 30-De
c-19 05:15:00 GMT; path=/; domain=.typicode.com; HttpOnly', 'X-Powered-By': 'Exp
ress', 'Vary': 'Origin, Accept-Encoding', 'Access-Control-Allow-Credentials': 't
rue', 'Cache-Control': 'max-age=14400', 'Pragma': 'no-cache', 'Expires': '-1', '
X-Content-Type-Options': 'nosniff', 'Etag': 'W/"160d-1eMSsxeJRfnVLRBmYJSbCiJZ1qQ
"', 'Content-Encoding': 'gzip', 'Via': '1.1 vegur', 'CF-Cache-Status': 'HIT', 'A
ge': '2271', 'Expect-CT': 'max-age=604800, report-uri="https://report-uri.cloudf
lare.com/cdn-cgi/beacon/expect-ct"', 'Server': 'cloudflare', 'CF-RAY': '53da574f
f99fc331-SIN'}

Para ler qualquer cabeçalho http, você pode fazer o seguinte−

getdata.headers["Content-Encoding"] // gzip

Cabeçalhos personalizados

Você também pode enviar cabeçalhos ao URL sendo chamado, conforme mostrado abaixo.

Exemplo

import requests
headers = {'x-user': 'test123'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users', headers=headers)

Os cabeçalhos passados ​​devem estar no formato string, bytestring ou Unicode. O comportamento da solicitação não mudará de acordo com os cabeçalhos personalizados passados.

Cabeçalhos de resposta

Os cabeçalhos de resposta são semelhantes aos abaixo quando você verifica a URL na ferramenta de desenvolvedor do navegador, guia de rede

Para obter os detalhes dos cabeçalhos do módulo de solicitações, use. Response.headers são mostrados abaixo−

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.headers)

Resultado

E:\prequests>python makeRequest.py
{'Date': 'Sat, 30 Nov 2019 06:08:10 GMT', 'Content-Type': 'application/json; cha
rset=utf-8', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'Set-Co
okie': '__cfduid=de1158f1a5116f3754c2c353055694e0d1575094090; expires=Mon, 30-De
c-19 06:08:10 GMT; path=/; domain=.typicode.com; HttpOnly', 'X-Powered-By': 'Exp
ress', 'Vary': 'Origin, Accept-Encoding', 'Access-Control-Allow-Credentials': 't
rue', 'Cache-Control': 'max-age=14400', 'Pragma': 'no-cache', 'Expires': '-1', '
X-Content-Type-Options': 'nosniff', 'Etag': 'W/"160d-1eMSsxeJRfnVLRBmYJSbCiJZ1qQ
"', 'Content-Encoding': 'gzip', 'Via': '1.1 vegur', 'CF-Cache-Status': 'HIT', 'A
ge': '5461', 'Expect-CT': 'max-age=604800, report-uri="https://report-uri.cloudf
lare.com/cdn-cgi/beacon/expect-ct"', 'Server': 'cloudflare', 'CF-RAY': '53daa52f
3b7ec395-SIN'}

Você pode obter qualquer cabeçalho específico que desejar da seguinte maneira -

print(getdata.headers["Expect-CT"])

Resultado

max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/exp
ect-ct

You can also get the header details by using the get() method.

print(getdata.headers.get("Expect-CT"))

Resultado

max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/exp
ect-ct

Solicitações - Tratamento de solicitações GET

Este capítulo se concentrará mais nas solicitações GET, que são as mais comuns e usadas com frequência. O funcionamento do GET no módulo de requisições é muito fácil. Aqui está um exemplo simples sobre como trabalhar com a URL usando o método GET.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)
getdata.content, will print all the data available in the response.

Resultado

E:\prequests>python makeRequest.py
b'[\n {\n "id": 1,\n "name": "Leanne Graham",\n "username": "Bret",\n
"email": "[email protected]",\n "address": {\n "street": "Kulas Light
",\n "suite": "Apt. 556",\n "city": "Gwenborough",\n "zipcode": "
92998-3874",\n "geo": {\n "lat": "-37.3159",\n "lng": "81.149
6"\n }\n },\n "phone": "1-770-736-8031 x56442",\n "website": "hild
egard.org",\n "company": {\n "name": "Romaguera-Crona",\n "catchPhr
ase": "Multi-layered client-server neural-net",\n "bs": "harness real-time
e-markets"\n }\n }

Você também pode passar parâmetros para o método get usando o atributo param como mostrado abaixo−

import requests
payload = {'id': 9, 'username': 'Delphine'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users',
params=payload)
print(getdata.content)

Os detalhes são armazenados na carga útil do objeto no par chave / valor e passados ​​para params, dentro do método get ().

Resultado

E:\prequests>python makeRequest.py
b'[\n {\n "id": 9,\n "name": "Glenna Reichert",\n "username": "Delphin
e",\n "email": "[email protected]",\n "address": {\n "street":
"Dayna Park",\n "suite": "Suite 449",\n "city": "Bartholomebury",\n
"zipcode": "76495-3109",\n "geo": {\n "lat": "24.6463",\n
"lng": "-168.8889"\n }\n },\n "phone": "(775)976-6794 x41206",\n "
website": "conrad.com",\n "company": {\n "name": "Yost and Sons",\n
"catchPhrase": "Switchable contextually-based project",\n "bs": "aggregate
real-time technologies"\n }\n }\n]'

Tratamento de solicitações POST, PUT, PATCH e DELETE

Neste capítulo, vamos entender como usar o método POST usando a biblioteca de solicitações e também passar parâmetros para a URL.

Usando POST

Para a solicitação PUT, a biblioteca Requests possui o método requests.post (), o exemplo dele é mostrado abaixo:

pedidos de importação

myurl = 'https://postman-echo.com/post'
myparams = {'name': 'ABC', 'email':'[email protected]'}
res = requests.post(myurl, data=myparams)
print(res.text)

Resultado

E:\prequests>python makeRequest.py
{"args":{},"data":"","files":{},"form":{"name":"ABC","email":"[email protected]"},"headers":{"x-forwarded-proto":"https","host":"postman-echo.com","content-length":"30","accept":"*/*","accept-encoding":"gzip,deflate","content-type":"application/x-www-form-urlencoded","user-agent":"python-requests/2.22.0","x-forwarded-port":"443"},"json":{"name":"ABC","email":"[email protected]"},"url":"https://postman-echo.com/post"}

No exemplo mostrado acima, você pode passar os dados do formulário como um par de valores-chave para o parâmetro de dados dentro de requests.post (). Veremos também como trabalhar com PUT, PATCH e DELETE no módulo de requisições.

Usando PUT

Para a solicitação PUT, a biblioteca Requests possui o método requests.put (), o exemplo dele é mostrado abaixo.

import requests
myurl = 'https://postman-echo.com/put'
myparams = {'name': 'ABC', 'email':'[email protected]'}
res = requests.put(myurl, data=myparams)
print(res.text)

Resultado

E:\prequests>python makeRequest.py
{"args":{},"data":"","files":{},"form":{"name":"ABC","email":"[email protected]"},"h
eaders":{"x-forwarded-proto":"https","host":"postman-echo.com","content-length":
"30","accept":"*/*","accept-encoding":"gzip, deflate","content-type":"applicatio
n/x-www-form-urlencoded","user-agent":"python-requests/2.22.0","x-forwarded-port
":"443"},"json":{"name":"ABC","email":"[email protected]"},"url":"https://postman-ec ho.com/put"}

Usando PATCH

Para a solicitação PATCH, a biblioteca Requests possui o método requests.patch (), o exemplo dele é mostrado abaixo.

import requests
myurl = https://postman-echo.com/patch'
res = requests.patch(myurl, data="testing patch")
print(res.text)

Resultado

E:\prequests>python makeRequest.py
{"args":{},"data":{},"files":{},"form":{},"headers":{"x-forwarded-proto":"https"
,"host":"postman-echo.com","content-length":"13","accept":"*/*","accept-encoding
":"gzip, deflate","user-agent":"python-requests/2.22.0","x-forwarded-port":"443"
},"json":null,"url":"https://postman-echo.com/patch"}

Usando DELETE

Para a solicitação DELETE, a biblioteca Requests possui o método requests.delete (), cujo exemplo é mostrado abaixo.

import requests
myurl = 'https://postman-echo.com/delete'
res = requests.delete(myurl, data="testing delete")
print(res.text)

Resultado

E:\prequests>python makeRequest.py
{"args":{},"data":{},"files":{},"form":{},"headers":{"x-forwarded-proto":"https"
,"host":"postman-echo.com","content-length":"14","accept":"*/*","accept-encoding
":"gzip, deflate","user-agent":"python-requests/2.22.0","x-forwarded-port":"443"
},"json":null,"url":"https://postman-echo.com/delete"}

Solicitações - Upload de arquivo

Neste capítulo, faremos upload de um arquivo usando request e leremos o conteúdo do arquivo enviado. Podemos fazer isso usando ofiles param conforme mostrado no exemplo abaixo.

Vamos usar o http://httpbin.org/postar para enviar o arquivo.

Exemplo

import requests
myurl = 'https://httpbin.org/post'
files = {'file': open('test.txt', 'rb')}
getdata = requests.post(myurl, files=files)
print(getdata.text)

Test.txt

File upload test using Requests

Exemplo

var total = [0, 1, 2, 3].reduceRight(function(a, b){ return a + b; }); 
console.log("total is : " + total );

Resultado

E:\prequests>python makeRequest.py
{
  "args": {},
  "data": "",
  "files": {
   "file": "File upload test using Requests"
  },
  "form": {},
  "headers": {
   "Accept": "*/*",
   "Accept-Encoding": "gzip, deflate",
   "Content-Length": "175",
   "Content-Type": "multipart/form-data; 
boundary=28aee3a9d15a3571fb80d4d2a94bf
d33",
   "Host": "httpbin.org",
   "User-Agent": "python-requests/2.22.0"
  },
  "json": null,
  "origin": "117.223.63.135, 117.223.63.135",
  "url": "https://httpbin.org/post"
}

Também é possível enviar o conteúdo do arquivo como mostrado abaixo−

Exemplo

import requests
myurl = 'https://httpbin.org/post'
files = {'file': ('test1.txt', 'Welcome to TutorialsPoint')}
getdata = requests.post(myurl, files=files)
print(getdata.text)

Resultado

E:\prequests>python makeRequest.py
{
  "args": {},
  "data": "",
  "files": {
   "file": "Welcome to TutorialsPoint"
},
"form": {},
"headers": {
   "Accept": "*/*",
   "Accept-Encoding": "gzip, deflate",
   "Content-Length": "170",
   "Content-Type": "multipart/form-data; boundary=f2837238286fe40e32080aa7e172b
e4f",
  "Host": "httpbin.org",
  "User-Agent": "python-requests/2.22.0"
},
  "json": null,
  "origin": "117.223.63.135, 117.223.63.135",
  "url": "https://httpbin.org/post"
}

Solicitações - Trabalhando com Cookies

Este capítulo discutirá como lidar com cookies. Você pode obter os cookies, bem como enviar seus cookies enquanto chama o URL usando a biblioteca de solicitações.

O url, https://jsonplaceholder.typicode.com/users quando acessamos o navegador, podemos obter os detalhes dos cookies conforme mostrado abaixo−

Você pode ler os cookies conforme mostrado abaixo-

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.cookies["__cfduid"])

Resultado

E:\prequests>python makeRequest.py
d1733467caa1e3431fb7f768fa79ed3741575094848

Você também pode enviar cookies quando fazemos uma solicitação.

Exemplo

import requests
cookies = dict(test='test123')
getdata = requests.get('https://httpbin.org/cookies',cookies=cookies)
print(getdata.text)

Resultado

E:\prequests>python makeRequest.py
{
   "cookies": {
   "test": "test123"
}
}

Solicitações - Trabalhando com erros

Este capítulo discutirá como lidar com os erros que ocorrem ao trabalhar com a biblioteca de solicitações Http. É sempre uma boa prática administrar os erros para todos os casos possíveis.

Exceção de erro

O módulo de solicitações fornece os seguintes tipos de exceção de erro -

ConnectionError- Será gerado, se houver algum erro de conexão. Por exemplo, a rede falhou, erro de DNS, então a biblioteca Request irá gerar a exceção ConnectionError.

Response.raise_for_status()- Com base no código de status, por exemplo, 401, 404, ele gerará HTTPError para o url solicitado.

HTTPError- Este erro será gerado para uma resposta inválida para a solicitação feita.

Timeout- Erros levantados para um tempo limite para a URL solicitada.

TooManyRedirects- Se o limite for ultrapassado para redirecionamentos máximos, ocorrerá o erro TooManyRedirects.

Exemplo

Aqui está um exemplo de erros mostrados para timeout−

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=0.001)
print(getdata.text)

Resultado

raise ConnectTimeout(e, request=request)
requests.exceptions.ConnectTimeout: HTTPSConnectionPool(host='jsonplaceholder.ty
picode.com', port=443): Max retries exceeded with url: /users (Caused by Connect
TimeoutError(<urllib3.connection.VerifiedHTTPSConnection object at
0x000000B02AD
E76A0>, 'Connection to jsonplaceholder.typicode.com timed out. (connect timeout= 0.001)'))

Solicitações - Tratamento de tempos limite

Timeouts podem ser facilmente adicionados ao URL que você está solicitando. Acontece que você está usando um URL de terceiros e aguardando uma resposta. É sempre uma boa prática fornecer um tempo limite no URL, pois podemos querer que o URL responda dentro de um intervalo de tempo com uma resposta ou erro. Não fazer isso pode fazer com que a solicitação seja aguardada indefinidamente.

Podemos dar tempo limite para a URL usando o parâmetro de tempo limite e o valor é passado em segundos, conforme mostrado no exemplo abaixo−

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=0.001)
print(getdata.text)

Resultado

raise ConnectTimeout(e, request=request)
requests.exceptions.ConnectTimeout: HTTPSConnectionPool(host='jsonplaceholder.ty
picode.com', port=443): Max retries exceeded with url: /users (Caused by Connect
TimeoutError(<urllib3.connection.VerifiedHTTPSConnection object at 0x000000B02AD
E76A0>, 'Connection to jsonplaceholder.typicode.com timed out. (connect timeout=
0.001)'))

O tempo limite fornecido é o seguinte−

getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=0.001)

A execução lança um erro de tempo limite de conexão, conforme mostrado na saída. O tempo limite fornecido é 0,001, o que não é possível para a solicitação de obter a resposta e gera um erro. Agora, vamos aumentar o tempo limite e verificar.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=1.000)
print(getdata.text)

Resultado

E:\prequests>python makeRequest.py
[
 {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
 }

Com um tempo limite de 1 segundo, podemos obter a resposta para o URL solicitado.

Solicitações - Tratamento de redirecionamento

Este capítulo dará uma olhada em como a biblioteca Request lida com o caso de redirecionamento de url.

Exemplo

import requests
getdata = requests.get('http://google.com/')
print(getdata.status_code)
print(getdata.history)

O url− http://google.com será redirecionado usando o código de status 301 (movido permanentemente) para https://www.google.com/. O redirecionamento será salvo no histórico.

Resultado

Quando o código acima é executado, obtemos o seguinte resultado−

E:\prequests>python makeRequest.py
200
[<Response [301]>]

Você pode parar o redirecionamento de um URL usando allow_redirects=False. Pode ser feito nos métodos GET, POST, OPTIONS, PUT, DELETE, PATCH usados.

Exemplo

Aqui está um exemplo do mesmo.

import requests
getdata = requests.get('http://google.com/', allow_redirects=False)
print(getdata.status_code)
print(getdata.history)
print(getdata.text)

Agora, se você verificar a saída, o redirecionamento não será permitido e obterá um código de status 301.

Resultado

E:\prequests>python makeRequest.py
301
[]
<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
<TITLE>301 Moved</TITLE></HEAD><BODY>
<H1>301 Moved</H1>
The document has moved
<A HREF="http://www.google.com/">here</A>.
</BODY></HTML>

Solicitações - Histórico de tratamento

Você pode obter o histórico de um determinado URL usando response.history. Se o URL fornecido tiver algum redirecionamento, o mesmo será armazenado no histórico.

Para a história

import requests
getdata = requests.get('http://google.com/')
print(getdata.status_code)
print(getdata.history)

Resultado

E:\prequests>python makeRequest.py
200
[<Response [301]>]

o response.historypropriedade terá os detalhes dos objetos de resposta que foram feitos com base na solicitação. Os valores presentes serão classificados dos mais antigos aos mais novos. oresponse.history propriedade rastreia todo o redirecionamento feito na URL solicitada.

Solicitações - Tratamento de sessões

Para manter os dados entre as solicitações, você precisa de sessões. Portanto, se o mesmo host for chamado repetidamente, você pode reutilizar a conexão TCP que, por sua vez, melhorará o desempenho. Vamos ver agora como manter cookies em solicitações feitas usando sessões.

Adicionando cookies usando sessão

import requests
req = requests.Session()
cookies = dict(test='test123')
getdata = req.get('https://httpbin.org/cookies',cookies=cookies)
print(getdata.text)

Resultado

E:\prequests>python makeRequest.py
{
   "cookies": {
   "test": "test123"
}
}

Usando a sessão, você pode preservar os dados dos cookies nas solicitações. Também é possível passar dados de cabeçalhos usando a sessão como mostrado abaixo−

Exemplo

import requests
req = requests.Session()
req.headers.update({'x-user1': 'ABC'})
headers = {'x-user2': 'XYZ'}
getdata = req.get('https://httpbin.org/headers', headers=headers)    
print(getdata.headers)

Solicitações - Certificação SSL

O certificado SSL é um recurso de segurança que vem com urls seguros. Quando você usa a biblioteca Requests, ela também verifica os certificados SSL para o URL https fornecido. A verificação SSL é habilitada por padrão no módulo de solicitações e gerará um erro se o certificado não estiver presente.

Trabalhar com URL seguro

A seguir está o exemplo de como trabalhar com URL seguro -

import requests
getdata = requests.get(https://jsonplaceholder.typicode.com/users)
print(getdata.text)

Resultado

E:\prequests>python makeRequest.py
[
   {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Estamos obtendo facilmente uma resposta do URL https acima, porque o módulo de solicitação pode verificar o certificado SSL.

Você pode desativar a verificação SSL simplesmente adicionando verify = False conforme mostrado no exemplo abaixo.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', verify=False)
print(getdata.text)

Você obterá a saída, mas também fornecerá uma mensagem de aviso de que o certificado SSL não foi verificado e a adição de verificação de certificado é recomendada.

Resultado

E:\prequests>python makeRequest.py
connectionpool.py:851: InsecureRequestWarning: Unverified HTTPS request is being
made. Adding certificate verification is strongly advised. See: https://urllib3
   .readthedocs.io/en/latest/advanced-usage.htm  l#ssl-warnings
 InsecureRequestWarning)
[
 {
  "id": 1,
   "name": "Leanne Graham",
   "username": "Bret", 
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered   client-server neural-net",
   "bs": "harness real-time e-markets"
  }
 }
]

Você também pode verificar o certificado SSL hospedando-o em sua extremidade e fornecendo o caminho usando verify param como mostrado abaixo.

Exemplo

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', verify='C:\Users\AppData\Local\certificate.txt')
print(getdata.text)

Resultado

E:\prequests>python makeRequest.py
[
  {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered   client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Solicitações - autenticação

Este capítulo discutirá os tipos de autenticação disponíveis no módulo Solicitações.

Vamos discutir o seguinte

• Trabalho de autenticação em solicitações HTTP

• Autenticação Básica

• Autenticação Digest

• Autenticação OAuth2

Trabalho de autenticação em solicitações HTTP

A autenticação HTTP está no lado do servidor solicitando algumas informações de autenticação, como nome de usuário e senha, quando o cliente solicita um URL. Esta é uma segurança adicional para o pedido e a resposta que está sendo trocada entre o cliente e o servidor.

Do lado do cliente, essas informações adicionais de autenticação, ou seja, nome de usuário e senha, podem ser enviadas nos cabeçalhos, que posteriormente serão validados no lado do servidor. A resposta será entregue do lado do servidor apenas quando a autenticação for válida.

A biblioteca Requests tem mais comumente usado autenticação em requests.auth, que são Basic Authentication ( HTTPBasicAuth ) e Digest Authentication ( HTTPDigestAuth ).

Autenticação Básica

Esta é a forma mais simples de fornecer autenticação ao servidor. Para trabalhar com autenticação básica, vamos usar a classe HTTPBasicAuth disponível com a biblioteca de solicitações.

Exemplo

Aqui está um exemplo prático de como usá-lo.

import requests
from requests.auth import HTTPBasicAuth
response_data = requests.get('httpbin.org/basic-auth/admin/admin123', auth=HTTPDigestAuth('admin', 'admin123'))
print(response_data.text)

Estamos ligando para o url, https://httpbin.org/basic-auth/admin/admin123com usuário como admin e senha como admin123 .

Portanto, este URL não funcionará sem autenticação, ou seja, usuário e senha. Depois de fornecer a autenticação usando o parâmetro auth, apenas o servidor retornará a resposta.

Resultado

E:\prequests>python makeRequest.py
{
   "authenticated": true,
   "user": "admin"
}

Autenticação Digest

Esta é outra forma de autenticação disponível com solicitações. Vamos usar a classe HTTPDigestAuth a partir de solicitações.

Exemplo

import requests
from requests.auth import HTTPDigestAuth
response_data = requests.get('https://httpbin.org/digest-auth/auth/admin/admin123>, auth=HTTPDigestAuth('admin', 'admin123'))
print(response_data.text)

Resultado

E:\prequests>python makeRequest.py
{
   "authenticated": true,
   "user": "admin"
}

Autenticação OAuth2

Para usar a autenticação OAuth2, precisamos da biblioteca “requests_oauth2”. Para instalar “requests_oauth2” faça o seguinte−

pip install requests_oauth2

A tela em seu terminal durante a instalação será algo como mostrado abaixo−

E:\prequests>pip install requests_oauth2
Collecting requests_oauth2
Downloading https://files.pythonhosted.org/packages/52/dc/01c3c75e6e7341a2c7a9
71d111d7105df230ddb74b5d4e10a3dabb61750c/requests-oauth2-0.3.0.tar.gz
Requirement already satisfied: requests in c:\users\xyz\appdata\local\programs
\python\python37\lib\site-packages (from requests_oauth2) (2.22.0)
Requirement already satisfied: six in c:\users\xyz\appdata\local\programs\pyth
on\python37\lib\site-packages (from requests_oauth2) (1.12.0)
Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in c:\use
rs\xyz\appdata\local\programs\python\python37\lib\site-packages (from requests
->requests_oauth2) (1.25.3)
Requirement already satisfied: certifi>=2017.4.17 in c:\users\xyz\appdata\loca
l\programs\python\python37\lib\site-packages (from requests->requests_oauth2) (2
019.3.9)
Requirement already satisfied: chardet<3.1.0,>=3.0.2 in c:\users\xyz\appdata\l
ocal\programs\python\python37\lib\site-packages (from requests->requests_oauth2)
(3.0.4)
Requirement already satisfied: idna<2.9,>=2.5 in c:\users\xyz\appdata\local\pr
ograms\python\python37\lib\site-packages (from requests->requests_oauth2) (2.8)
Building wheels for collected packages: requests-oauth2
Building wheel for requests-oauth2 (setup.py) ... done
Stored in directory: C:\Users\xyz\AppData\Local\pip\Cache\wheels\90\ef\b4\43
3743cbbc488463491da7df510d41c4e5aa28213caeedd586
Successfully built requests-oauth2

Concluímos a instalação do “requests-oauth2”. Para utilizar as API's do Google, Twitter é necessário o seu consentimento e o mesmo é feito utilizando a autenticação OAuth2.

Para autenticação OAuth2, precisaremos do ID do cliente e de uma chave secreta. Os detalhes de como obtê-lo são mencionados emhttps://developers.google.com/identity/protocols/OAuth2.

Mais tarde, faça login no Console de API do Google, que está disponível em https://console.developers.google.com/e obtenha o ID do cliente e a chave secreta.

Exemplo

Aqui está um exemplo de como usar "requests-oauth2".

import requests
from requests_oauth2.services import GoogleClient
google_auth = GoogleClient(
   client_id="xxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com",
redirect_uri="http://localhost/auth/success.html",
)
a = google_auth.authorize_url(
   scope=["profile", "email"],
   response_type="code",
)
res = requests.get(a)
print(res.url)

Não poderemos redirecionar para o URL fornecido, pois é necessário fazer o login na conta do Gmail, mas aqui, você verá pelo exemplo que google_auth funciona e o URL autorizado é fornecido.

Resultado

E:\prequests>python oauthRequest.py
https://accounts.google.com/o/oauth2/auth?redirect_uri=
http%3A%2F%2Flocalhost%2Fauth%2Fsuccess.html&
client_id=xxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com&
scope=profile+email&response_type=code

Solicitações - Ganchos de evento

Podemos adicionar eventos à URL solicitada usando ganchos de eventos. No exemplo abaixo, vamos adicionar uma função de retorno de chamada que será chamada quando a resposta estiver disponível.

Exemplo

Para adicionar o retorno de chamada, precisamos fazer uso do parâmetro hooks conforme mostrado no exemplo abaixo−

mport requests
def printData(r, *args, **kwargs):
   print(r.url)
   print(r.text)
getdata = requests.get('https://jsonplaceholder.typicode.com/users', 
hooks={'response': printData})

Resultado

E:\prequests>python makeRequest.py
https://jsonplaceholder.typicode.com/users
[
{
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
    "lat": "-37.3159",
    "lng": "81.1496"
   }
  }, 
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Você também pode chamar várias funções de retorno de chamada como mostrado abaixo−

Exemplo

import requests
def printRequestedUrl(r, *args, **kwargs):
   print(r.url)
def printData(r, *args, **kwargs):
   print(r.text)
getdata = requests.get('https://jsonplaceholder.typicode.com/users', hooks={'response': [printRequestedUrl, printData]})

Resultado

E:\prequests>python makeRequest.py
https://jsonplaceholder.typicode.com/users
[
  {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
 }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
    "bs": "harness real-time e-markets"
   }
  }
]

Você também pode adicionar o gancho à sessão criada como mostrado abaixo-

Exemplo

import requests
def printData(r, *args, **kwargs):
print(r.text)
s = requests.Session()
s.hooks['response'].append(printData)
s.get('https://jsonplaceholder.typicode.com/users')

Resultado

E:\prequests>python makeRequest.py
[
 {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Solicitações - proxy

Até agora, vimos clientes se conectando e conversando diretamente com o servidor. Usando proxy, a interação acontece da seguinte maneira -

• O cliente envia uma solicitação ao proxy.

• O proxy envia a solicitação ao servidor.

• O servidor envia de volta a resposta ao proxy.

• O proxy enviará uma resposta de volta ao cliente.

Usar Http-proxy é uma segurança adicional atribuída para gerenciar a troca de dados entre o cliente e o servidor. As bibliotecas de solicitações também têm provisão para lidar com proxy, usando o parâmetro de proxies conforme mostrado abaixo−

Exemplo

import requests
proxies = {
'http': 'http://localhost:8080'
}
res = requests.get('http://httpbin.org/', proxies=proxies)
print(res.status_code)

O pedido irá encaminhar para ('http://localhost:8080 URL.

Resultado

200

Solicitações - Web Scraping usando solicitações

Já vimos como podemos obter dados de um determinado URL usando a biblioteca de solicitações Python. Tentaremos retirar os dados do site deTutorialspoint que está disponível em https://www.tutorialspoint.com/tutorialslibrary.htm usando o seguinte

• Biblioteca de Pedidos

• Bela biblioteca de sopa de python

Já instalamos a biblioteca Requests, vamos agora instalar o pacote Beautiful soup. Aqui está o site oficial debeautiful soup disponível em https://www.crummy.com/software/BeautifulSoup/bs4/doc/ caso você queira explorar mais algumas funcionalidades da bela sopa.

Instalando Beautifulsoup

Veremos como instalar a Beautiful Soup abaixo−

E:\prequests>pip install beautifulsoup4
Collecting beautifulsoup4
Downloading https://files.pythonhosted.org/packages/3b/c8/a55eb6ea11cd7e5ac4ba
cdf92bac4693b90d3ba79268be16527555e186f0/beautifulsoup4-4.8.1-py3-none-any.whl (
101kB)
|████████████████████████████████| 102kB 22kB/s
Collecting soupsieve>=1.2 (from beautifulsoup4)
Downloading https://files.pythonhosted.org/packages/81/94/03c0f04471fc245d08d0
a99f7946ac228ca98da4fa75796c507f61e688c2/soupsieve-1.9.5-py2.py3-none-any.whl
Installing collected packages: soupsieve, beautifulsoup4
Successfully installed beautifulsoup4-4.8.1 soupsieve-1.9.5

Agora temos a biblioteca de solicitações de python e a bela sopa instalada.

Vamos agora escrever o código, que eliminará os dados do URL fornecido.

Raspagem da web

import requests
from bs4 import BeautifulSoup
res = requests.get('https://www.tutorialspoint.com/tutorialslibrary.htm')
print("The status code is ", res.status_code)
print("\n")
soup_data = BeautifulSoup(res.text, 'html.parser')
print(soup_data.title)
print("\n")
print(soup_data.find_all('h4'))

Usando a biblioteca de solicitações, podemos buscar o conteúdo do URL fornecido e uma bela biblioteca de sopas ajuda a analisá-lo e buscar os detalhes da maneira que quisermos.

Você pode usar uma bela biblioteca de sopa para buscar dados usando tag Html, classe, id, seletor css e muitas outras maneiras. A seguir está o resultado obtido, no qual imprimimos o título da página e também todas as tags h4 da página.

Resultado

E:\prequests>python makeRequest.py
The status code is 200
<title>Free Online Tutorials and Courses</title>
[<h4>Academic</h4>, <h4>Computer Science</h4>, <h4>Digital Marketing</h4>, <h4>M
onuments</h4>,<h4>Machine Learning</h4>, <h4>Mathematics</h4>, <h4>Mobile Devel
opment</h4>,<h4>SAP</h4>, <h4>Software Quality</h4>, <h4>Big Data & Analyti
cs</h4>, <h4>Databases</h4>, <h4>Engineering Tutorials</h4>, <h4>Mainframe Devel
opment</h4>, <h4>Microsoft Technologies</h4>, <h4>Java Technologies</h4>,<h4>XM
L Technologies</h4>, <h4>Python Technologies</h4>, <h4>Sports</h4>, <h4>Computer
Programming</h4>,<h4>DevOps</h4>, <h4>Latest Technologies</h4>, <h4>Telecom</h4>, <h4>Exams Syllabus</h4>, <h4>UPSC IAS Exams</h4>, <h4>Web Development</h4>,
<h4>Scripts</h4>, <h4>Management</h4>,<h4>Soft Skills</h4>, <h4>Selected Readin
g</h4>, <h4>Misc</h4>]