Python e APIs: como usar solicitações Python para criar aplicativos baseados em API

Olá! Você está procurando aprimorar suas habilidades em Python e aprender como integrar APIs poderosas em seus aplicativos? Então este guia é para você.

Vou orientá-lo no uso da fantástica biblioteca Python Requests para interagir com APIs da web de todos os tipos. Com algum conhecimento básico de Python e solicitações, você será capaz de:

Consulte dados de qualquer endpoint de API
Crie aplicativos que se integram a serviços populares como Twitter, Stripe, Twilio etc.
Automatize fluxos de trabalho conectando APIs
Desbloqueie toneladas de dados e funcionalidades úteis para aprimorar seus aplicativos Python

Parece emocionante, certo? Vamos mergulhar!

Por que usar APIs em Python?

Antes de entrarmos no código, vamos primeiro entender porque conectar-se a APIs é muito útil para desenvolvedores.

As APIs permitem que diferentes aplicativos de software se comuniquem entre si. Empresas e organizações expõem APIs para permitir que os desenvolvedores criem aplicativos com seus serviços com mais facilidade.

Aqui estão alguns dos principais motivos para usar APIs em seu código:

Economize tempo – Não reconstrua do zero algo que já existe como API!
Aproveite os dados – Acesse fontes de dados úteis, como clima, ações, mídias sociais e muito mais.
Estenda a funcionalidade – Integre mapas, pagamentos, notificações e muito mais.
Automatizar fluxos de trabalho – Conecte diferentes sistemas perfeitamente.
Crie aplicativos mais rapidamente – Concentre-se na lógica do seu aplicativo e não na infraestrutura subjacente.

Resumindo, APIs bem projetadas ajudam você a desenvolver aplicativos melhores e mais rápido.

De acordo com o Relatório sobre o estado da API de 2024 do Postman, a adoção de APIs públicas está crescendo rapidamente:

72% das organizações consomem APIs públicas como parte do seu negócio principal.
58% possuem APIs públicas.
As solicitações de API cresceram mais de 650% de 2020 a 2021 para os respondentes.

Com as APIs se tornando mais onipresentes em todos os setores, é um ótimo momento para aprimorar suas habilidades para se conectar a elas com Python.

Introdução às solicitações Python

Python possui bibliotecas fantásticas que facilitam o trabalho com APIs. O mais popular é pedidos.

Requests permite chamar APIs com apenas algumas linhas de código:

import requests

response = requests.get(‘https://api.data.gov/education‘)

Comparado com alternativas de nível inferior, como o integrado do Python urllib módulo, Solicitações economiza muito tempo e dores de cabeça.

Alguns recursos principais das solicitações:

API simples e elegante
Torna as solicitações HTTP extremamente fáceis
Suporte JSON integrado
Manipulação de cabeçalhos, parâmetros, autenticação
Novas tentativas automáticas em erros de rede
Vasta gama de recursos avançados

Para instalar o Requests, basta executar:

pip install requests

Então import requests em seu código e você estará pronto para começar a fazer chamadas de API!

Vejamos alguns exemplos simples.

Fazendo uma solicitação GET

A chamada de API mais comum é uma solicitação GET para recuperar dados de um endpoint.

Veja como fazer uma solicitação GET com Requests:

import requests 

response = requests.get(‘https://api.github.com/repos/requests/requests‘)

Isso enviará uma solicitação GET ao endpoint da API GitHub para recuperar dados no repositório de solicitações.

Voltamos um Response objeto que contém o código de status, cabeçalhos de resposta e dados.

Para imprimir o código de status da resposta:

print(response.status_code)

>>> 200

Um código de status 200 indica que nossa solicitação foi bem-sucedida. Existem muitos outros códigos de status que indicam erros ou falhas – abordaremos como lidar com eles mais tarde.

Para acessar os dados de resposta, basta ligar .json():

data = response.json()

print(data[‘stargazers_count‘])

>>> 64245

Os dados são analisados como JSON automaticamente. Isso torna o trabalho com APIs JSON muito simples.

Passando Parâmetros

Para muitas APIs, você precisa passar parâmetros para filtrar dados, paginar resultados e muito mais.

Passe os parâmetros como um dicionário para o params argumento:

params = {‘type‘: ‘owner‘, ‘sort‘: ‘updated‘}
response = requests.get(‘https://api.github.com/repos/kennethreitz/requests‘, 
                        params=params)

As solicitações codificam os parâmetros e os adicionam ao URL para você.

Você também pode passar parâmetros diretamente na URL:

response = requests.get(‘https://api.github.com/repos/kennethreitz/requests?type=owner&sort=updated‘)

De qualquer maneira funciona, mas passar um dicionário é considerado mais limpo.

Solicitações POST

Para criar recursos no servidor, você usaria uma solicitação POST.

Passe os dados para postar como um dicionário para o json parâmetro:

data = {‘name‘: ‘John Smith‘, ‘email‘: ‘[email protected]‘}
response = requests.post(‘https://api.example.com/users‘, json=data)

Isso codifica os dados como JSON e envia um POST para a API para criar um novo recurso de usuário.

Para POSTs você também deve validar o código de status retornado:

if response.status_code == 201:
  print(‘User created!‘)

O status 201 significa que o recurso foi criado com sucesso no servidor.

COLOCAR, PATCH, EXCLUIR

Além de GET e POST, os outros métodos HTTP comuns são:

PUT – Atualizar um recurso existente
PATCH – Atualização parcial de um recurso
EXCLUIR – Excluir um recurso

Eles funcionam de forma semelhante, basta chamar o método correspondente em requests:

# PUT - Update user
requests.put(‘https://api.example.com/users/123‘, json=updated_data) 

# PATCH - Partial update  
requests.patch(‘https://api.example.com/users/123‘, json=partial_data)

# DELETE - Delete user
requests.delete(‘https://api.example.com/users/123‘)

Agora você sabe fazer chamadas de API usando todos os métodos HTTP comuns!

Tratamento de respostas de API

Ao trabalhar com APIs, você precisa manipular os dados de resposta com base no código de status retornado pelo servidor.

As APIs usam códigos de status HTTP padrão para indicar sucesso, erros ou falhas. Alguns mais comuns incluem:

200 – OK – A solicitação foi bem-sucedida
201 – Criado – O recurso foi criado com sucesso
400 – Solicitação incorreta – A solicitação estava malformada ou faltavam dados
401 – Não autorizado – Autenticação necessária
403 – Proibido – Você não tem acesso a este recurso
404 – Não encontrado – O recurso não existe
500 – Erro do servidor – O servidor encontrou um erro inesperado

Você verifica o código de status no objeto Response:

response = requests.get(‘https://api.example.com/items/123‘)

if response.status_code == 200:
  # Success!
elif response.status_code == 404:
  # Notify user item does not exist

Para ser sucinto, recomendo agrupar todas as suas chamadas de Requests em uma função auxiliar como:

def make_api_request(endpoint):
  response = requests.get(endpoint)

  response.raise_for_status()

  return response.json()

Isso torna o código mais limpo, além de centralizar o tratamento de erros em um só lugar.

raise_for_status() gerará uma exceção se houver um código de erro HTTP como 500 ou 404, evitando que você verifique manualmente todas as vezes.

Autenticação com APIs

Muitas APIs exigem autenticação para restringir o acesso. Algumas formas comuns de autenticação de API incluem:

Chaves API – Passe uma chave de API exclusiva por meio de um cabeçalho ou parâmetro de solicitação
Autenticação básica – Passe um nome de usuário e senha com a solicitação
Tokens ao portador – Envie um token de portador OAuth 2.0 do provedor de autenticação
Autenticação resumida – Semelhante à autenticação básica, mas as credenciais são criptografadas

As solicitações simplificam o tratamento da autenticação.

Para usar uma chave de API, passe-a como cabeçalho:

headers = {‘Authorization‘: ‘Bearer YOUR_API_KEY‘}
response = requests.get(‘https://api.example.com‘, headers=headers)

Para autenticação básica, forneça o nome de usuário e a senha como uma tupla:

requests.get(‘https://api.example.com‘, 
            auth=(‘username‘, ‘password‘))

As solicitações tratarão a codificação de suas credenciais corretamente.

Para tokens ao portador de provedores OAuth como Facebook, Twitter, Google etc:

params = {‘access_token‘: ‘OAUTH_TOKEN‘}
requests.get(‘https://api.example.com‘, params=params)

Passe o token de acesso como parâmetro e Requests cuidará do resto.

A autenticação adequada é fundamental para acessar APIs com segurança em seus aplicativos e fluxos de trabalho Python.

Melhores práticas para trabalhar com APIs

Agora que você sabe como para chamar APIs com Python, vamos discutir algumas práticas recomendadas para trabalhar de maneira eficaz com elas:

Lide com erros com elegância

As APIs podem falhar de maneiras inesperadas – servidores caem, redes caem, provedores fazem alterações.

Ao fazer solicitações de API:

Use blocos try/except para detectar erros
Lidar com exceções comuns como ConnectionErrors
Verifique os códigos de status e lide com respostas diferentes de 200
Use uma estratégia de espera exponencial para repetir solicitações com falha

Isso garante que seu aplicativo seja degradado normalmente quando as APIs falharem.

Respeite os limites de taxa

Para evitar abusos, as APIs impõem limites de taxa nas solicitações por hora/dia.

Exceder esses limites bloqueará seu acesso, possivelmente permanentemente.

Para evitar isso:

Revise a documentação do limite de taxa e entenda sua cota
Limitar solicitações – só faça ligações quando necessário
Implementar um temporizador de espera se você atingir o limite para fazer uma pausa antes de tentar novamente
Nunca envie spam ou abuse da API! Isso levará a bloqueios.

Os limites de taxa protegem as APIs para que funcionem para todos os usuários. Respeite-os em seu uso.

Respostas de cache

As APIs podem ser lentas dependendo da conectividade. Para desempenho, considere armazenar respostas em cache, especialmente se os dados não mudarem com frequência.

Bibliotecas populares de cache Python incluem Redis, Memcached e SQLAlchemy.

O cache evita chamadas de rede desnecessárias para solicitações repetidas.

Exemplos e usos da API Python

Agora vamos dar uma olhada em alguns exemplos reais de APIs populares e como você pode acessá-las em Python.

API do Twitter

A API do Twitter permite consultar tweets, usuários, hashtags e análises. Você precisa solicitar uma conta de desenvolvedor do Twitter para obter credenciais de API.

Instale o choroso biblioteca para uma interface API do Twitter mais amigável:

pip install tweepy

Exemplo de busca de tweets para uma hashtag:

import tweepy

client = tweepy.Client(bearer_token=TWITTER_TOKEN)

tweets = client.search_recent_tweets(query="#python")

for tweet in tweets.data:
   print(tweet.text)

veja a documentos tweepy para mais detalhes.

API GitHub

A API GitHub permite acesso programático a repositórios, códigos, usuários do GitHub e muito mais, sem autenticação.

Exemplo de busca dos repositórios de um usuário:

import requests

response = requests.get(‘https://api.github.com/users/kennethreitz/repos‘)

for repo in response.json():
  print(repo[‘name‘])

veja a Documentos da API GitHub para mais casos de uso.

API de distribuição

A API Stripe permite incorporar pagamentos em aplicativos e sites.

Instale o listra biblioteca e importação:

pip install stripe

import stripe

Exemplo de criação de uma cobrança:

stripe.api_key = ‘STRIPE_SECRET_KEY‘ 

charge = stripe.Charge.create(
  amount=1000,
  currency=‘usd‘,
  source=‘tok_visa‘ # Token from Stripe.js
)

Stripe cuida do trabalho pesado de pagamentos para você.

See Documentos da API do Stripe para obter a referência completa da API.

Existem muitas outras APIs excelentes, como Slack, Twilio, Google Maps, AWS e muito mais! O segredo é encontrar a fonte de dados certa para seu aplicativo e aproveitar o poder das APIs.

Conclusão

Espero que este guia tenha fornecido uma visão geral útil sobre como fazer solicitações de API em Python usando a biblioteca Requests. Aqui estão algumas conclusões importantes:

pedidos simplifica a chamada de APIs – instale-a usando pip
Use métodos HTTP comuns como GET, POST, PUT, DELETE para operações CRUD
Passe parâmetros, autenticação, cabeçalhos e dados facilmente
Lidar com códigos de status e erros adequadamente
Implemente práticas recomendadas como limitação de taxa e armazenamento em cache
Integre APIs interessantes como Twitter, GitHub, Stripe e muito mais!

As APIs ajudam você a criar aplicativos melhores com mais rapidez, permitindo aproveitar dados e serviços existentes. Python e solicitações fornecem uma ótima maneira de desbloquear o poder das APIs em seu código.

Para os próximos passos, recomendo navegar no site oficial Solicita documentos, lendo os documentos da API de quaisquer serviços que você deseja integrar e revisando alguns repositórios usando APIs Python, como este.

Espero que você tenha achado este guia útil! Deixe-me saber se você tiver alguma outra dúvida sobre o uso de Python e APIs. Boa codificação!