Dominando as APIs do Python: Um guia abrangente para criar e usar APIs em Python

As APIs, ou interfaces de programação de aplicativos, são realmente os heróis do desenvolvimento moderno de software. Eles permitem que diferentes sistemas de software se comuniquem entre si, possibilitando a integração de serviços e a criação de aplicativos. Dominar APIs é uma habilidade importante para qualquer pessoa que queira trabalhar com dados em Python, especialmente se você for um desenvolvedor. Você pode se surpreender com as portas que se abrem porque, quando você aprende essa habilidade, pode criar aplicativos da Web, conectar-se a serviços externos ou até mesmo usar dados em tempo real em projetos de aprendizado de máquina.

Neste guia, exploraremos o mundo das APIs, aprenderemos como usá-las em Python, como criar a sua própria API com o FastAPI e como lidar com desafios comuns que certamente surgirão. Ao final deste tutorial, você terá uma sólida compreensão de como usar APIs em seus projetos, tornando seu processo de desenvolvimento mais eficiente e seus aplicativos mais avançados. Se você se sentir preso a todas as informações, experimente nosso curso Introduction to APIs in Python, que aborda cada parte em detalhes.

O que é uma API?

Uma API é como uma ponte entre diferentes aplicativos de software. Ele permite que esses aplicativos se comuniquem e compartilhem informações entre si.

Imagine uma API como um garçom em um restaurante. Você diz ao garçom o que deseja (seu pedido), e ele comunica sua solicitação à cozinha. A cozinha prepara a comida e o garçom a traz de volta para você. Da mesma forma, você envia uma solicitação a uma API, que processa a solicitação e retorna os resultados.

Para tornar isso mais concreto, vamos considerar alguns usos reais: Você pode, por exemplo, usar uma API pública para recuperar dados financeiros para uma análise do mercado de ações ou para acessar dados meteorológicos em tempo real para um modelo de previsão climática. Como você deve estar percebendo, as APIs são particularmente importantes para trabalhar com grandes conjuntos de dados e/ou quando você precisa de dados em tempo real; caso contrário, talvez você não tenha problemas com a integração.

Como funciona uma API Python. Imagem de Napkin.AI

Usando APIs em Python

O uso de APIs em Python é uma maneira poderosa de interagir com serviços externos, recuperar dados e integrar várias funcionalidades aos seus aplicativos. O Python torna o trabalho com APIs simples e eficiente, principalmente por meio da biblioteca desolicitações , que permite que você envie solicitações HTTP para interagir com APIs.

Introdução às APIs em Python

Em Python, a interação com APIs é um processo simples graças à biblioteca requests. Essa biblioteca simplifica o processo de envio de solicitações HTTP, permitindo que você se comunique com APIs e recupere ou envie dados.

Como fazer solicitações de API em Python

Antes de começar a fazer solicitações de API em Python, você precisará da bibliotecarequests. Você pode instalá-lo usando este comando:

pip install requests

Noções básicas de solicitações de API

Vamos combinar nosso exemplo conceitual envolvendo o restaurante com o que está realmente acontecendo no Python. Aqui está o detalhamento simplificado:

1. Encontre o lugar certo: Identifique o endpoint da API, que é o endereço da Web específico para o qual você enviará sua solicitação.

2. Faça seu pedido: Use a biblioteca requests do Python para enviar a solicitação à API. Você especificará o tipo de ação que deseja realizar (como obter ou enviar dados).

3. Obtenha seu alimento: A API enviará uma resposta, que você poderá processar para extrair as informações de que precisa.

Solicitações GET

Uma solicitação GET é o tipo mais comum de solicitação HTTP usada para recuperar dados de um servidor, semelhante a uma solicitação de informações; quando você digita um URL no navegador e pressiona Enter, está basicamente enviando uma solicitação GET para esse servidor, especificando o recurso desejado, que o servidor processa para localizar e preparar os dados solicitados antes de enviá-los de volta em um formato como JSON ou XML.

import requestsresponse = requests.get('https://api.example.com/data')data = response.json()print(data)

Neste exemplo, estamos enviando uma solicitação GET para uma API fictícia e imprimindo a resposta JSON. As solicitações GET são comumente usadas para buscar dados sem modificá-los.

Solicitações POST

Enquanto as solicitações GET recuperam dados, as solicitações POST enviam instruções a um servidor. Eles costumam ser usados para criar novos recursos (como adicionar um usuário) ou atualizar os existentes (como editar um perfil).

Imagine que você está preenchendo um formulário on-line para se inscrever em um serviço. Ao clicar em enviar, você está basicamente enviando uma solicitação POST com suas informações. Aqui está um exemplo simplificado:

# Data to send (like user information)data = {'name': 'John Doe', 'email': 'john.doe@example.com'}# Send the data to the API (replace the URL with the actual API endpoint)response = requests.post('https://api.example.com/users', json=data)# Check if the request was successful (usually a status code of 201 for creation)if response.status_code == 201:    print("User created successfully!")else:    print("Error:", response.status_code)

Este exemplo envia um dicionário com informações do usuário como dados JSON para a API. Em seguida, verificamos o código de status da resposta para ver se o usuário foi criado com êxito.

Tratamento de respostas

Quando você faz uma solicitação de API, o servidor envia de volta uma resposta que inclui duas informações importantes:

• Código de status: Um número que indica o sucesso ou a falha da solicitação. Por exemplo, 200 geralmente significa sucesso, enquanto 404 significa que o recurso não foi encontrado.
• Dados: As informações que você solicitou geralmente estão no formato JSON. É aqui que reside o conteúdo valioso.

Aqui está um exemplo em Python:

response = requests.get('https://api.example.com/data')if response.status_code == 200:    data = response.json()    print(data)   else:    print(f"Request failed with status code {response.status_code}")   

Entendendo os códigos de status da API do Python

Os códigos de status da API são respostas padronizadas que os servidores enviam de volta para indicar o resultado da solicitação de um cliente. Esses códigos ajudam os desenvolvedores a entender se uma solicitação foi bem-sucedida, se ocorreu um erro ou se é necessária uma ação adicional.

Códigos de status comuns

• 200 OK: Esse código de status indica que a solicitação foi bem-sucedida. Por exemplo, quando você faz uma solicitação GET para recuperar dados de uma API, uma resposta 200 OK significa que os dados foram obtidos corretamente.  

• 404 Não encontrado: Esse código é retornado quando o servidor não consegue encontrar o recurso solicitado. Por exemplo, se você tentar acessar um endpoint que não existe, receberá um erro 404 Not Found.

• 500 Erro interno do servidor: Esse código indica que algo deu errado no lado do servidor. É uma mensagem de erro genérica que pode ocorrer devido a vários problemas, como bugs no código do servidor ou problemas com o banco de dados.

Manipulação de diferentes códigos de status

O manuseio eficaz dos códigos de status da API nos aplicativos Python garante que o seu código se comporte de forma previsível e possa gerenciar os erros com elegância. Se a resposta for 200, prossiga com o processamento dos dados retornados. Ao encontrar um erro 404, verifique se o URL do endpoint está correto e, se necessário, implemente a lógica de fallback ou informe ao usuário que o recurso não está disponível. Para erros 500, considere tentar novamente a solicitação após um breve atraso ou registrar o erro para investigação posterior. No entanto, evite tentativas excessivas para não sobrecarregar o servidor.

Criação de APIs Python

A criação de APIs com Python permite que você crie interfaces de aplicativos poderosas e eficientes. A simplicidade e as bibliotecas robustas do Python fazem dele uma excelente opção para o desenvolvimento de APIs.

Introdução à FastAPI

Agora que você sabe como usar APIs, vamos explorar como podemos criar as nossas próprias. FastAPI é uma estrutura da Web moderna e rápida (de alto desempenho) para a criação de APIs com Python. Como o próprio nome indica, ele foi projetado para ser fácil de usar. Um aspecto que me agrada no FastAPI é que ele também gera automaticamente uma documentação interativa.

Configuração da FastAPI

Para começar, você precisará do Python e de seu gerenciador de pacotes, o pip, instalados. Em seguida, instale o FastAPI e o Uvicorn, um servidor ASGI de alto desempenho:

pip install fastapi uvicorn

Observação: Se você tiver problemas com a configuração do Python ou do pip, consulte nosso tutorial: Como atualizar o Python e o Pip no Windows, MacOS e Linux.

Criando uma API simples

Vamos criar uma API direta que retorne uma saudação simples:

from fastapi import FastAPIapp = FastAPI()@app.get("/")def read_root():    return {"Hello": "World"}

Para iniciar essa API, execute o seguinte comando:

uvicorn main:app --reload

Esse comando inicia o servidor Uvicorn, servindo sua API em http://127.0.0.1:8000. Ao acessar esse URL em seu navegador da Web, você receberá a resposta {"Hello": "World"}.

Recursos avançados do FastAPI

O FastAPI não se limita a criar APIs simples rapidamente; ele também oferece uma série de recursos avançados que o tornam adequado para aplicativos complexos e de alto desempenho. Aqui estão alguns dos principais recursos: 

Parâmetros de consulta

Na FastAPI, adicionar e manipular parâmetros de consulta é simples, graças à sua dependência das dicas de tipo do Python. Os parâmetros de consulta fazem parte do URL e são usados para passar dados opcionais para o endpoint da API, geralmente para filtrar ou modificar os dados retornados.

Adição de parâmetros de consulta

Para adicionar um parâmetro de consulta na FastAPI, você simplesmente o define como um argumento de função na sua função de operação de caminho. Se um parâmetro for opcional, você poderá atribuir a ele um valor padrão, como None. Por exemplo, digamos que você tenha um ponto de extremidade que recupera itens de um banco de dados. Você deseja permitir que os usuários filtrem itens por uma consulta de pesquisa:

app = FastAPI()@app.get("/items/")def read_items(q: str = None):    if q:        return {"items": ["Item 1", "Item 2", "Item 3"], "query": q}    return {"items": ["Item 1", "Item 2", "Item 3"]}

Neste exemplo, q é um parâmetro de consulta opcional. Se você fornecer um valor para q, ele filtrará os resultados com base nessa consulta. Se q não for fornecido, o ponto de extremidade retornará todos os itens.

Manipulação de parâmetros de consulta

A FastAPI lida automaticamente com os parâmetros de consulta, incluindo validação e conversão de tipos. Por exemplo, se você especificar um parâmetro de consulta como um número inteiro, a FastAPI validará se a entrada é realmente um número inteiro. Se a entrada não corresponder ao tipo esperado, a FastAPI retornará uma mensagem de erro clara.

Aqui está um exemplo com um parâmetro de consulta obrigatório e validação de tipo:

@app.get("/items/{item_id}")def read_item(item_id: int, q: str = None):    return {"item_id": item_id, "query": q}

Nesse caso, item_id é um parâmetro de caminho e q é um parâmetro de consulta opcional. A FastAPI garantirá que item_id seja um número inteiro e processará o parâmetro de consulta q, se fornecido.

Manipulação de diferentes métodos HTTP

A implementação de diferentes métodos HTTP, como GET, POST, PUT e DELETE, é simples e reflete a forma como você define rotas em outras estruturas. Cada método está vinculado a um tipo específico de operação, como recuperação de dados (GET), criação de novos dados (POST), atualização de dados existentes (PUT) ou exclusão de dados (DELETE).

Método GET

O método GET é usado para recuperar dados do servidor. Na FastAPI, você define um ponto de extremidade GET como este:

@app.get("/items/")def get_items():    return {"items": ["Item 1", "Item 2", "Item 3"]}

Método POST

O método POST é usado para criar novos dados. Você pode definir um ponto de extremidade POST e receber dados no corpo da solicitação:

@app.post("/items/")def create_item(item: dict):    return {"item": item}

Método PUT

O método PUT é usado para atualizar os dados existentes. Normalmente, você precisa de um identificador e dos novos dados:

@app.put("/items/{item_id}")def update_item(item_id: int, item: dict):    return {"item_id": item_id, "updated_item": item}

Método DELETE

O método DELETE é usado para remover dados. Na FastAPI, um ponto de extremidade DELETE é definido da seguinte forma:

@app.delete("/items/{item_id}")def delete_item(item_id: int):    return {"message": f"Item {item_id} deleted"}

Autenticação e segurança

A FastAPI oferece vários mecanismos para implementar a autenticação e a segurança:

• HTTP Basic Auth: Um método simples, mas geralmente não recomendado para ambientes de produção devido a questões de segurança.
• Chaves de API: Uma opção mais segura que envolve a geração de chaves exclusivas para os clientes.
• OAuth 2.0: Um padrão complexo, mas robusto, para autorização, comumente usado para integrações de terceiros.
• Tokens da Web JSON (JWT): Uma abordagem popular para representar reivindicações de forma segura entre duas partes.