9 - Capítulo 9: APIs e Web Scraping

As requisições HTTP em Python permitem que você acesse e interaja com APIs, possibilitando o acesso a informações em tempo real e integração com serviços web. O módulo requests é uma ferramenta poderosa e fácil de usar para fazer requisições HTTP em Python. Com ele, você pode extrair dados de APIs, consumir informações de serviços online e realizar tarefas como web scraping para extrair informações de páginas da web. Lembre-se sempre de consultar a documentação da API que você está utilizando para entender os parâmetros, os headers e os métodos suportados, e também respeitar as políticas de uso e termos de serviço da API.

JSON é um formato de dados leve e de fácil leitura que é amplamente utilizado para transmitir informações estruturadas entre sistemas. Ele é baseado em JavaScript, mas é independente de linguagem, o que o torna muito popular para troca de dados em aplicativos web e APIs.

O formato JSON é composto por pares de chave-valor, onde as chaves são strings e os valores podem ser strings, números, booleanos, arrays ou outros objetos JSON. A estrutura é bastante semelhante aos dicionários em Python ou aos objetos em JavaScript.

9.2.1.1 - Exemplo de um objeto JSON simples

{
    "nome": "Alice",
    "idade": 30,
    "email": "alice@example.com"
}

9.2.1.2 - Utilizando JSON com APIs em Python

Ao fazer requisições para APIs, muitas vezes os dados são retornados no formato JSON. Para lidar com esses dados em Python, podemos usar a biblioteca requests para obter a resposta e o método .json() para converter o conteúdo da resposta em um objeto Python (normalmente um dicionário) a partir do JSON.

Exemplo de como utilizar JSON com a biblioteca requests em Python:

import requests

url = "https://api.example.com/data"
resposta = requests.get(url)

if resposta.status_code == 200:
    # Converter o conteúdo da resposta em JSON
    dados_json = resposta.json()
    print(dados_json)
else:
    print("Erro ao fazer a requisição:", resposta.status_code)

O método .json() analisa o conteúdo da resposta e retorna um objeto Python que pode ser manipulado como um dicionário ou uma lista, facilitando o acesso aos dados retornados pela API.

9.2.1.3 - Conclusão

As APIs e o formato JSON são fundamentais para a integração de aplicativos e a troca de dados entre sistemas.

Em Python, a biblioteca requests nos permite fazer requisições HTTP para acessar APIs e extrair informações.

O formato JSON é amplamente utilizado para transmitir dados estruturados em APIs e aplicações web.

A combinação do Python com APIs e JSON oferece aos desenvolvedores um poderoso conjunto de ferramentas para criar aplicativos que se integram perfeitamente com uma variedade de serviços e plataformas.

Certifique-se de que você tenha as bibliotecas requests e beautifulsoup4 instaladas em seu ambiente. Caso ainda não tenha, instale-as usando o gerenciador de pacotes pip:

pip install requests
pip install beautifulsoup4

Importar as bibliotecas:

import requests
from bs4 import BeautifulSoup

Fazer uma requisição HTTP para a página desejada:

Use a biblioteca requests para fazer uma requisição GET à página que você deseja fazer o web scraping.

url = "https://www.exemplo.com"
resposta = requests.get(url)

# Verificar se a requisição foi bem-sucedida (código de status 200)
if resposta.status_code == 200:
    # Parsear o conteúdo da página com BeautifulSoup
    pagina_html = resposta.content
    soup = BeautifulSoup(pagina_html, "html.parser")
else:
    print("Erro ao fazer a requisição:", resposta.status_code)

Use os métodos e funções do BeautifulSoup para extrair os dados desejados da página.

Exemplo de como extrair todos os links da página:

links = soup.find_all("a")

for link in links:
    print(link.get("href"))

Exemplo de como extrair o conteúdo de um elemento específico da página:

titulo = soup.find("h1").text
print(titulo)

9.3.2.1 - Conclusão

O BeautifulSoup é uma ferramenta poderosa para fazer web scraping em Python. Com ele, você pode extrair dados de páginas da web de forma fácil e eficiente, tornando possível obter informações estruturadas de sites e utilizá-las em seus projetos. Lembre-se sempre de verificar as políticas do site quanto ao scraping e respeitar as regras de uso ético e legal ao fazer web scraping.

Vamos supor que você queira criar um aplicativo que forneça informações meteorológicas para os usuários. Você pode utilizar uma API de previsão do tempo para obter dados atualizados sobre o clima em diferentes localizações.

Exemplo usando a API OpenWeatherMap:

import requests

def obter_previsao_do_tempo(cidade, chave_api):
    url = f"https://api.openweathermap.org/data/2.5/weather?q={cidade}&appid={chave_api}&units=metric"
    resposta = requests.get(url)

    if resposta.status_code == 200:
        dados = resposta.json()
        temperatura = dados["main"]["temp"]
        descricao = dados["weather"][0]["description"]
        print(f"Previsão do tempo em {cidade}: Temperatura: {temperatura}°C, Condição: {descricao}")
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

chave_api = "SUA_CHAVE_DE_API_AQUI"
obter_previsao_do_tempo("Sao_Paulo", chave_api)

Você pode usar APIs de plataformas de mídia social para postar conteúdo automaticamente ou obter informações sobre perfis de usuários.

Exemplo usando a API do Twitter (é necessário obter as credenciais de acesso do desenvolvedor do Twitter):

import requests
import tweepy

def postar_tweet(texto, chave_api, chave_secreta, token_acesso, token_secreto):
    auth = tweepy.OAuthHandler(chave_api, chave_secreta)
    auth.set_access_token(token_acesso, token_secreto)
    api = tweepy.API(auth)

    try:
        api.update_status(texto)
        print("Tweet postado com sucesso!")
    except tweepy.TweepError as e:
        print(f"Erro ao postar tweet: {e}")

chave_api = "SUA_CHAVE_DE_API_AQUI"
chave_secreta = "SUA_CHAVE_SECRETA_AQUI"
token_acesso = "SEU_TOKEN_DE_ACESSO_AQUI"
token_secreto = "SEU_TOKEN_SECRETO_AQUI"
postar_tweet("Olá, mundo! Estou usando uma API para postar este tweet!", chave_api, chave_secreta, token_acesso, token_secreto)

As APIs também são amplamente utilizadas em serviços de pagamento online para processar transações.

Exemplo usando a API do PayPal (é necessário obter as credenciais de acesso do desenvolvedor do PayPal):

import requests

def realizar_pagamento(valor, chave_api, chave_secreta):
    url = "https://api.sandbox.paypal.com/v1/payments/payment"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {chave_api}:{chave_secreta}"
    }
    dados = {
        "intent": "sale",
        "payer": {"payment_method": "paypal"},
        "transactions": [{"amount": {"total": valor, "currency": "USD"}}]
    }

    resposta = requests.post(url, headers=headers, json=dados)

    if resposta.status_code == 201:
        pagamento_id = resposta.json()["id"]
        print(f"Pagamento criado com sucesso! ID: {pagamento_id}")
    else:
        print("Erro ao fazer o pagamento:", resposta.status_code)

chave_api = "SUA_CHAVE_DE_API_AQUI"
chave_secreta = "SUA_CHAVE_SECRETA_AQUI"
realizar_pagamento("10.00", chave_api, chave_secreta)

Existem inúmeras APIs disponíveis que oferecem uma variedade de dados e serviços para integração em aplicativos. Abaixo estão mais alguns exemplos de uso de API em Python:

Você pode usar uma API de tradução para criar um aplicativo que traduza automaticamente textos para diferentes idiomas.

Exemplo usando a API do Google Cloud Translation:

from google.cloud import translate_v2 as translate

def traduzir_texto(texto, idioma_destino, chave_api):
    cliente = translate.Client.from_service_account_json(chave_api)
    resultado = cliente.translate(texto, target_language=idioma_destino)

    print(f"Texto original: {resultado['input']}")
    print(f"Texto traduzido: {resultado['translatedText']}")

chave_api = "Caminho_para_arquivo_de_credenciais.json"
traduzir_texto("Hello, world!", "es", chave_api)  # Traduzir para espanhol

Utilizando uma API de reconhecimento de fala, você pode criar aplicativos que transcrevam áudio em texto.

Exemplo usando a API do Google Cloud Speech-to-Text:

from google.cloud import speech

def transcrever_audio(caminho_audio, idioma, chave_api):
    cliente = speech.SpeechClient.from_service_account_json(chave_api)
    with open(caminho_audio, "rb") as arquivo_audio:
        conteudo_audio = arquivo_audio.read()

    audio = speech.RecognitionAudio(content=conteudo_audio)
    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
        sample_rate_hertz=16000,
        language_code=idioma,
    )

    resposta = cliente.recognize(config=config, audio=audio)

    for resultado in resposta.results:
        print(f"Transcrição: {resultado.alternatives[0].transcript}")

caminho_audio = "caminho_para_arquivo_de_audio.wav"
idioma = "pt-BR"
chave_api = "Caminho_para_arquivo_de_credenciais.json"
transcrever_audio(caminho_audio, idioma, chave_api)

Você pode utilizar uma API de análise de sentimento para determinar a polaridade de textos, identificando se são positivos, negativos ou neutros.

Exemplo usando a API Text Analytics do Azure:

from azure.ai.textanalytics import TextAnalyticsClient
from azure.core.credentials import AzureKeyCredential

def analisar_sentimento(texto, chave_api, endpoint):
    credencial = AzureKeyCredential(chave_api)
    cliente = TextAnalyticsClient(endpoint=endpoint, credential=credencial)

    resultado = cliente.analyze_sentiment(documents=[texto])[0]

    print(f"Texto: {texto}")
    print(f"Sentimento: {resultado.sentiment}")
    print(f"Pontuação positiva: {resultado.confidence_scores.positive}")
    print(f"Pontuação negativa: {resultado.confidence_scores.negative}")
    print(f"Pontuação neutra: {resultado.confidence_scores.neutral}")

chave_api = "SUA_CHAVE_DE_API_AQUI"
endpoint = "SEU_ENDPOINT_AQUI"
texto = "Eu amo esse filme!"
analisar_sentimento(texto, chave_api, endpoint)

Vamos continuar com mais exemplos práticos de uso de APIs em Python:

Você pode utilizar uma API de geolocalização para obter informações sobre coordenadas geográficas, endereços e locais próximos.

Exemplo usando a API Geocoding do Google Maps:

import requests

def obter_coordenadas(endereco, chave_api):
    endereco_formatado = endereco.replace(" ", "+")
    url = f"https://maps.googleapis.com/maps/api/geocode/json?address={endereco_formatado}&key={chave_api}"
    resposta = requests.get(url)

    if resposta.status_code == 200:
        dados = resposta.json()
        coordenadas = dados["results"][0]["geometry"]["location"]
        print(f"Coordenadas de {endereco}: Latitude: {coordenadas['lat']}, Longitude: {coordenadas['lng']}")
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

chave_api = "SUA_CHAVE_DE_API_AQUI"
obter_coordenadas("Av. Paulista, 100, Sao Paulo, SP, Brasil", chave_api)

Você pode utilizar uma API de cotações para obter informações atualizadas sobre taxas de câmbio de moedas e criptomoedas.

Exemplo usando a API CoinGecko para obter a cotação do Bitcoin:

import requests

def obter_cotacao_bitcoin():
    url = "https://api.coingecko.com/api/v3/simple/price"
    parametros = {"ids": "bitcoin", "vs_currencies": "usd"}
    resposta = requests.get(url, params=parametros)

    if resposta.status_code == 200:
        dados = resposta.json()
        cotacao = dados["bitcoin"]["usd"]
        print(f"Cotação do Bitcoin: ${cotacao}")
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

obter_cotacao_bitcoin()

Você pode utilizar uma API para consultar informações sobre filmes e séries, como sinopse, elenco, classificação e muito mais.

Exemplo usando a API OMDb (The Open Movie Database):

import requests

def consultar_filme(titulo, chave_api):
    url = f"http://www.omdbapi.com/?t={titulo}&apikey={chave_api}"
    resposta = requests.get(url)

    if resposta.status_code == 200:
        dados = resposta.json()
        print(f"Título: {dados['Title']}")
        print(f"Ano: {dados['Year']}")
        print(f"Classificação: {dados['Rated']}")
        print(f"Sinopse: {dados['Plot']}")
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

chave_api = "SUA_CHAVE_DE_API_AQUI"
consultar_filme("Inception", chave_api)

Você pode utilizar a API da Wikipedia para fazer pesquisas e obter informações sobre diversos tópicos.

Exemplo usando a API Wikipedia API:

import requests

def pesquisar_wikipedia(palavra_chave):
    url = f"https://pt.wikipedia.org/w/api.php"
    parametros = {
        "action": "query",
        "format": "json",
        "list": "search",
        "srsearch": palavra_chave
    }

    resposta = requests.get(url, params=parametros)

    if resposta.status_code == 200:
        dados = resposta.json()
        resultados = dados["query"]["search"]
        for resultado in resultados:
            print(f"Título: {resultado['title']}")
            print(f"Snippet: {resultado['snippet']}\n")
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

pesquisar_wikipedia("Linguagem de programação Python")

Exemplos práticos de uso de APIs incluindo text-to-speech:

Abaixo estão mais alguns exemplos práticos de uso de APIs, incluindo exemplos de texto para fala (text-to-speech):

Com uma API de texto para fala, você pode converter um texto em áudio e reproduzir o áudio em tempo real ou salvá-lo como um arquivo de áudio.

Exemplo usando a API Text-to-Speech da IBM Watson:

import requests

def texto_para_fala(texto, chave_api, url_servico):
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {chave_api}"
    }
    dados = {
        "text": texto
    }

    resposta = requests.post(url_servico, headers=headers, json=dados, stream=True)

    if resposta.status_code == 200:
        with open("audio.wav", "wb") as arquivo_audio:
            for parte in resposta.iter_content(chunk_size=1024):
                arquivo_audio.write(parte)
        print("Áudio salvo como audio.wav")
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

chave_api = "SUA_CHAVE_DE_API_AQUI"
url_servico = "URL_DO_SERVICO_TTS"
texto_para_fala("Olá, seja bem-vindo ao nosso aplicativo!", chave_api, url_servico)

Você pode utilizar APIs de análise de imagens para obter informações sobre o conteúdo de uma imagem, como identificação de objetos, detecção de rostos, classificação de emoções, entre outros.

Exemplo usando a API Computer Vision da Microsoft Azure:

import requests

def analisar_imagem(caminho_imagem, chave_api, endpoint):
    url = f"{endpoint}/vision/v3.0/analyze"
    headers = {
        "Content-Type": "application/octet-stream",
        "Ocp-Apim-Subscription-Key": chave_api
    }

    with open(caminho_imagem, "rb") as arquivo_imagem:
        imagem_bytes = arquivo_imagem.read()

    params = {
        "visualFeatures": "Categories,Description,Faces,Objects",
        "details": "Celebrities,Landmarks"
    }

    resposta = requests.post(url, headers=headers, params=params, data=imagem_bytes)

    if resposta.status_code == 200:
        dados = resposta.json()
        print("Descrição da imagem:", dados["description"]["captions"][0]["text"])
        print("Objetos detectados:")
        for objeto in dados["objects"]:
            print(objeto["object"])
    else:
        print("Erro ao fazer a requisição:", resposta.status_code)

caminho_imagem = "caminho_para_imagem.jpg"
chave_api = "SUA_CHAVE_DE_API_AQUI"
endpoint = "SEU_ENDPOINT_AQUI"
analisar_imagem(caminho_imagem, chave_api, endpoint)

É possível fazer text-to-speech (TTS) de forma gratuita e salvar o áudio como arquivo utilizando algumas APIs e bibliotecas disponíveis. Abaixo está um exemplo de como fazer text-to-speech e salvar o áudio em um arquivo usando a biblioteca gTTS (Google Text-to-Speech) em Python:

Instalação da biblioteca:

Certifique-se de ter a biblioteca gTTS instalada em seu ambiente. Caso ainda não tenha, instale-a usando o gerenciador de pacotes pip:

pip install gtts

Exemplo de uso do gTTS:

from gtts import gTTS
import os

def texto_para_fala(texto, nome_arquivo):
    tts = gTTS(text=texto, lang="pt", tld="com", slow=False)
    tts.save(nome_arquivo)

texto = "Olá! Este é um exemplo de texto para fala usando o gTTS."
nome_arquivo = "exemplo.mp3"
texto_para_fala(texto, nome_arquivo)

# Reproduzindo o áudio
os.system(f"start {nome_arquivo}")

O exemplo acima usa o gTTS para converter o texto em fala em português (idioma "pt") e salva o áudio no arquivo "exemplo.mp3". Depois, o áudio é reproduzido usando o comando os.system.

É importante ressaltar que algumas APIs e bibliotecas oferecem limitações de uso gratuito, como um número máximo de solicitações por dia ou restrições de recursos. Sempre verifique os termos de uso e limitações da API ou biblioteca específica que você está utilizando para garantir que está dentro dos limites do plano gratuito.

O exemplo acima utiliza o gTTS, que é uma biblioteca de código aberto e gratuita para text-to-speech. No entanto, se você estiver utilizando APIs específicas, é possível que algumas delas ofereçam um plano gratuito com limitações de uso. Sempre verifique a documentação da API para entender suas limitações e termos de uso.

Caso você precise fazer text-to-speech em grandes volumes ou com mais recursos avançados, considere verificar APIs comerciais especializadas em TTS que podem oferecer planos mais adequados às suas necessidades.

Para configurar o gTTS (Google Text-to-Speech) para usar uma voz masculina e ajustar a velocidade da fala, você pode passar os parâmetros tld (Top-Level Domain) e slow ao criar o objeto gTTS.

O parâmetro tld especifica o país da qual a voz será usada, e o parâmetro slow controla a velocidade da fala.

Neste exemplo, usamos lang="pt" para selecionar a voz em português e tld="com.br" para especificar o país dos servidores do Google no Brasil, que geralmente fornece a voz masculina em português.

Além disso, ao definir slow=False, a velocidade da fala será mais rápida. Caso deseje uma velocidade mais lenta, basta alterar para slow=True.

Lembre-se de que a disponibilidade de vozes pode variar dependendo da região e dos servidores do Google. Nem todas as línguas e regiões têm vozes masculinas disponíveis. Experimente diferentes valores para o parâmetro tld para encontrar a configuração que melhor se adapta às suas necessidades.