12 APIs - Parte 1: Consumindo APIs REST

De pedir comida por delivery para consumir dados da internet: conectando seu Python com o mundo!

12.1 O que você vai aprender neste capítulo?

O que são APIs e como elas funcionam na prática
Como fazer requisições HTTP usando Python
Biblioteca requests: instalação e uso básico para consumir APIs
Trabalhando com JSON: como processar dados retornados pelas APIs
Status codes: entendendo códigos de resposta HTTP (200, 404, 500)
Tratamento de erros: como lidar com problemas nas requisições
APIs públicas práticas: ViaCEP, OpenWeatherMap, CoinGecko
Projetos reais: criar aplicações que consomem dados da internet

🎓 Vindo do Capítulo 11? Perfeito! Agora que você sabe usar módulos e bibliotecas, vamos conectar seu Python com o mundo!

🎯 Meta: Ao final deste capítulo, você vai conseguir criar aplicações Python que consomem dados de APIs REST e trabalham com informações da internet.

⚠️ Por que isso importa: APIs são a base da internet moderna! Sem elas, não teríamos aplicativos como Instagram, WhatsApp ou Google Maps. Aqui você aprende a usar essa tecnologia poderosa!

12.1.1 Fluxo de uma Requisição HTTP

Para entender melhor como funciona o processo de comunicação com APIs, vamos visualizar o fluxo completo:

┌─────────────┐    HTTP Request     ┌─────────────┐
│   Cliente   │ ──────────────────► │    Servidor │
│  (Python)   │                     │             │
│             │                     │             │
│             │                     │             │
│             │ ◄────────────────── │             │
│             │    HTTP Response    │             │
└─────────────┘                     └─────────────┘
       ▲                                   │
       │                                   │
       │                                   ▼
       │                            ┌─────────────┐
       │                            │   Banco de  │
       │                            │   Dados     │
       │                            │             │
       │                            └─────────────┘
       │                                   ▲
       │                                   │
       │                                   │
       └───────────────────────────────────┘
                Dados processados

Explicação do fluxo:

Cliente (seu código Python) faz uma requisição HTTP
Servidor recebe e processa a requisição
Servidor consulta o banco de dados se necessário
Servidor retorna os dados como resposta HTTP
Cliente recebe e processa os dados

Exemplo prático:

1. Cliente: "GET /api/usuarios/123" (solicita dados do usuário 123)
2. Servidor: Processa requisição
3. Servidor: Consulta banco de dados
4. Servidor: Retorna JSON com dados do usuário
5. Cliente: Processa dados recebidos

Este fluxo acontece toda vez que você consome uma API, seja para buscar dados, criar novos registros, atualizar informações ou deletar dados.

12.2 De Pedir Comida por Delivery para Consumir APIs

12.2.1 Analogia Perfeita: Delivery de Comida

Imagine que você quer pedir uma pizza:

Você (Cliente): Abre o app do iFood
App (API): Mostra o cardápio dos restaurantes
Restaurante (Servidor): Recebe seu pedido e prepara a pizza
App (API): Informa o status do pedido
Entregador: Traz a pizza até você

Em programação, funciona assim:

Seu código Python (Cliente): Faz uma requisição para uma API
API: Processa a requisição e retorna dados
Seu código: Recebe os dados e os usa no seu programa

12.2.2 O que são APIs?

API significa Application Programming Interface (Interface de Programação de Aplicações).

É como um cardápio de restaurante:

📋 Cardápio (API): Lista o que você pode pedir
🍕 Pratos (Endpoints): Cada item que você pode solicitar
📞 Garçom (HTTP): Como você faz o pedido
🍽️ Comida (Dados): O que você recebe de volta

12.2.3 Tipos de APIs que vamos usar

REST APIs: Mais comuns, usam HTTP
JSON: Formato de dados mais popular
HTTP Methods: GET (buscar), POST (criar), PUT (atualizar), DELETE (remover)

💡 Exemplo prático: Quando você abre o Instagram, o app faz várias chamadas para APIs: - Buscar suas fotos - Carregar stories dos amigos
- Verificar notificações - Atualizar o feed

12.3 Fazendo sua Primeira Requisição HTTP

12.3.1 Instalando a biblioteca `requests`

Primeiro, vamos instalar a biblioteca que nos permite fazer requisições HTTP:

pip install requests

12.3.2 Primeira requisição: Buscar informações de um usuário do GitHub

import requests

# Fazer uma requisição GET para a API do GitHub
response = requests.get('https://api.github.com/users/octocat')

# Verificar se a requisição foi bem-sucedida
print(f"Status Code: {response.status_code}")
print(f"Dados recebidos: {response.json()}")

Saída esperada:

Status Code: 200
Dados recebidos: {
    'login': 'octocat',
    'id': 583231,
    'node_id': 'MDQ6VXNlcjU4MzIzMQ==',
    'avatar_url': 'https://github.com/images/error/octocat_happy.gif',
    'gravatar_id': '',
    'url': 'https://api.github.com/users/octocat',
    'html_url': 'https://github.com/octocat',
    'followers_url': 'https://api.github.com/users/octocat/followers',
    'following_url': 'https://api.github.com/users/octocat/following{/other_user}',
    'gists_url': 'https://api.github.com/users/octocat/gists{/gist_id}',
    'starred_url': 'https://api.github.com/users/octocat/starred{/owner}{/repo}',
    'subscriptions_url': 'https://api.github.com/users/octocat/subscriptions',
    'organizations_url': 'https://api.github.com/users/octocat/orgs',
    'repos_url': 'https://api.github.com/users/octocat/repos',
    'events_url': 'https://api.github.com/users/octocat/events{/privacy}',
    'received_events_url': 'https://api.github.com/users/octocat/received_events',
    'type': 'User',
    'site_admin': False,
    'name': 'The Octocat',
    'company': 'GitHub',
    'blog': 'https://github.blog',
    'location': 'San Francisco',
    'email': None,
    'hireable': None,
    'bio': 'GitHub\'s mascot',
    'twitter_username': None,
    'public_repos': 8,
    'public_gists': 8,
    'followers': 3938,
    'following': 9,
    'created_at': '2011-01-25T18:44:36Z',
    'updated_at': '2022-03-22T14:07:15Z'
}

12.3.3 Entendendo a resposta

# Acessar dados específicos
dados = response.json()

print(f"Nome: {dados['name']}")
print(f"Empresa: {dados['company']}")
print(f"Localização: {dados['location']}")
print(f"Repositórios públicos: {dados['public_repos']}")
print(f"Seguidores: {dados['followers']}")

💡 O que aconteceu? 1. Fizemos uma requisição GET para https://api.github.com/users/octocat 2. A API retornou status 200 (sucesso) 3. Recebemos dados em formato JSON 4. Convertemos os dados para um dicionário Python 5. Acessamos informações específicas

12.4 Status Codes - Entendendo as Respostas

12.4.1 O que são Status Codes?

Status codes são códigos numéricos que indicam se a requisição foi bem-sucedida ou não. É como um semáforo para suas requisições!

12.4.2 Principais Status Codes

Código	Significado	Analogia
200	✅ Sucesso	Pedido entregue com sucesso
201	✅ Criado	Novo pedido criado
400	❌ Erro do cliente	Pedido mal feito
401	❌ Não autorizado	Precisa de login
404	❌ Não encontrado	Prato não existe no cardápio
500	❌ Erro do servidor	Cozinha em problemas

12.4.3 Exemplo prático com tratamento de erros

import requests

def buscar_usuario_github(username):
    """Busca informações de um usuário do GitHub"""
    url = f'https://api.github.com/users/{username}'
    
    try:
        response = requests.get(url)
        
        if response.status_code == 200:
            dados = response.json()
            print(f"✅ Usuário encontrado: {dados['name']}")
            return dados
        elif response.status_code == 404:
            print(f"❌ Usuário '{username}' não encontrado")
            return None
        else:
            print(f"⚠️ Erro inesperado: {response.status_code}")
            return None
            
    except requests.exceptions.RequestException as e:
        print(f"🚫 Erro de conexão: {e}")
        return None

# Testando a função
usuario = buscar_usuario_github('octocat')
if usuario:
    print(f"Bio: {usuario['bio']}")

12.4.4 Testando diferentes cenários

# Usuário que existe
buscar_usuario_github('octocat')

# Usuário que não existe
buscar_usuario_github('usuario_inexistente_12345')

# URL inválida (para testar erro de conexão)
try:
    response = requests.get('https://api.github.com/usuarios/octocat')
    print(f"Status: {response.status_code}")
except requests.exceptions.RequestException as e:
    print(f"Erro: {e}")

💡 Dica: Sempre trate os diferentes status codes! É como verificar se o pedido chegou corretamente antes de comer!

12.5 APIs Públicas Práticas - Conectando com o Mundo Real

12.5.1 ViaCEP - Buscar endereço por CEP

import requests

def buscar_cep(cep):
    """Busca endereço pelo CEP usando ViaCEP"""
    url = f'https://viacep.com.br/ws/{cep}/json/'
    
    try:
        response = requests.get(url)
        
        if response.status_code == 200:
            dados = response.json()
            
            if 'erro' not in dados:
                print(f"📍 CEP: {dados['cep']}")
                print(f"📍 Logradouro: {dados['logradouro']}")
                print(f"📍 Bairro: {dados['bairro']}")
                print(f"📍 Cidade: {dados['localidade']}")
                print(f"📍 Estado: {dados['uf']}")
                return dados
            else:
                print(f"❌ CEP {cep} não encontrado")
                return None
        else:
            print(f"⚠️ Erro na requisição: {response.status_code}")
            return None
            
    except requests.exceptions.RequestException as e:
        print(f"🚫 Erro de conexão: {e}")
        return None

# Testando
endereco = buscar_cep('01310-100')  # CEP da Av. Paulista

12.5.2 OpenWeatherMap - Consultar clima

def consultar_clima(cidade, api_key):
    """Consulta clima de uma cidade usando OpenWeatherMap"""
    url = f'https://api.openweathermap.org/data/2.5/weather'
    params = {
        'q': cidade,
        'appid': api_key,
        'units': 'metric',
        'lang': 'pt_br'
    }
    
    try:
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            dados = response.json()
            
            print(f"🌤️ Clima em {dados['name']}, {dados['sys']['country']}")
            print(f"🌡️ Temperatura: {dados['main']['temp']}°C")
            print(f"🌡️ Sensação térmica: {dados['main']['feels_like']}°C")
            print(f"💧 Umidade: {dados['main']['humidity']}%")
            print(f"🌬️ Vento: {dados['wind']['speed']} m/s")
            print(f"☁️ Descrição: {dados['weather'][0]['description']}")
            
            return dados
        else:
            print(f"⚠️ Erro na requisição: {response.status_code}")
            return None
            
    except requests.exceptions.RequestException as e:
        print(f"🚫 Erro de conexão: {e}")
        return None

# Para usar, você precisa de uma API key gratuita em openweathermap.org
# clima = consultar_clima('São Paulo', 'sua_api_key_aqui')

12.5.3 CoinGecko - Preços de criptomoedas

def consultar_preco_cripto(moeda='bitcoin'):
    """Consulta preço de criptomoedas usando CoinGecko"""
    url = f'https://api.coingecko.com/api/v3/simple/price'
    params = {
        'ids': moeda,
        'vs_currencies': 'usd,brl',
        'include_24hr_change': 'true'
    }
    
    try:
        response = requests.get(url, params=params)
        
        if response.status_code == 200:
            dados = response.json()
            
            if moeda in dados:
                preco_usd = dados[moeda]['usd']
                preco_brl = dados[moeda]['brl']
                variacao = dados[moeda]['usd_24h_change']
                
                print(f"💰 {moeda.title()}")
                print(f"💵 Preço em USD: ${preco_usd:,.2f}")
                print(f"🇧🇷 Preço em BRL: R$ {preco_brl:,.2f}")
                print(f"📈 Variação 24h: {variacao:+.2f}%")
                
                return dados
            else:
                print(f"❌ Moeda '{moeda}' não encontrada")
                return None
        else:
            print(f"⚠️ Erro na requisição: {response.status_code}")
            return None
            
    except requests.exceptions.RequestException as e:
        print(f"🚫 Erro de conexão: {e}")
        return None

# Testando
preco = consultar_preco_cripto('bitcoin')
preco_ethereum = consultar_preco_cripto('ethereum')

12.5.4 JSONPlaceholder - API de teste

def listar_posts():
    """Lista posts de exemplo usando JSONPlaceholder"""
    url = 'https://jsonplaceholder.typicode.com/posts'
    
    try:
        response = requests.get(url)
        
        if response.status_code == 200:
            posts = response.json()
            
            print(f"📝 Encontrados {len(posts)} posts:")
            for i, post in enumerate(posts[:5]):  # Mostrar apenas os 5 primeiros
                print(f"{i+1}. {post['title']}")
                print(f"   ID: {post['id']}, User: {post['userId']}")
                print()
            
            return posts
        else:
            print(f"⚠️ Erro na requisição: {response.status_code}")
            return None
            
    except requests.exceptions.RequestException as e:
        print(f"🚫 Erro de conexão: {e}")
        return None

# Testando
posts = listar_posts()

💡 Dica: Essas APIs são gratuitas e não precisam de autenticação! Perfeitas para aprender e testar seus códigos!

12.6 Exercícios Práticos (respostas no final da página)

🚀 Hora de praticar! Aqui estão 25 exercícios organizados por dificuldade. Cada exercício tem solução completa com explicação linha por linha!

12.6.1 MUITO FÁCIL (Nível 1)

1. Informações Básicas do GitHub Crie uma função que busca informações de um usuário do GitHub e mostra apenas o nome e número de seguidores.

Exemplo: Input → "octocat" | Output → Nome: The Octocat, Seguidores: 3938

2. Buscar CEP Específico Use a API do ViaCEP para buscar o endereço do CEP 20040-020 (Rio de Janeiro).

Exemplo: Input → "20040-020" | Output → Rua da Carioca, Centro - Rio de Janeiro - RJ

3. Preço do Bitcoin Crie uma função que consulta o preço atual do Bitcoin usando CoinGecko.

Exemplo: Output → Bitcoin: $45,230.50 | R$ 245,890.75

4. Listar Posts Use a API JSONPlaceholder para listar os títulos dos 3 primeiros posts.

Exemplo: Output → 1. sunt aut facere, 2. qui est esse, 3. ea molestias quasi

5. Verificar Usuário GitHub Crie uma função que verifica se um usuário do GitHub existe (retorna True/False).

Exemplo: Input → "octocat" | Output → True

12.6.2 FÁCIL (Nível 2)

6. Conversor de CEP Formatado Crie um conversor de CEP que busca o endereço e formata de forma bonita.

Exemplo: Input → "01310-100" | Output → 📍 ENDEREÇO ENCONTRADO - Avenida Paulista, Bela Vista - São Paulo - SP

7. Comparar Criptomoedas Crie uma função que compara preços de Bitcoin e Ethereum.

Exemplo: Output → Bitcoin: $45,230.50 | Ethereum: $3,120.75

8. Gerador de Citações Crie um gerador de citações aleatórias usando a API “quotable.io”.

Exemplo: Output → "The only way to do great work is to love what you do." - Steve Jobs

9. Informações de País Crie uma função que busca informações de um país usando a API “restcountries.com”.

Exemplo: Input → "Brazil" | Output → País: Brasil, Capital: Brasília, População: 212,559,417

10. Verificador de Sites Crie um verificador de status de sites que testa se uma URL está funcionando.

Exemplo: Input → "https://google.com" | Output → Site funcionando: Status 200

12.6.3 MÉDIO (Nível 3)

11. Sistema de Clima Crie um sistema de consulta de clima que aceita múltiplas cidades.

Exemplo: Input → ["São Paulo", "Rio de Janeiro"] | Output → SP: 25°C, RJ: 28°C

12. Tracker de Criptomoedas Crie um tracker de criptomoedas que monitora Bitcoin, Ethereum e Litecoin.

Exemplo: Output → Bitcoin: $45,230, Ethereum: $3,120, Litecoin: $145

13. Gerador de Perfis Crie um gerador de perfis aleatórios usando a API “randomuser.me”.

Exemplo: Output → Nome: João Silva, Email: joao@email.com, País: Brasil

14. Busca de Filmes Crie um sistema de busca de filmes usando a API “OMDb” (Open Movie Database).

Exemplo: Input → "The Matrix" | Output → Filme: The Matrix, Ano: 1999, Diretor: Lana Wachowski

15. Conversor de Moedas Crie um conversor de moedas que usa uma API de câmbio em tempo real.

Exemplo: Input → 100, "USD", "BRL" | Output → $100.00 = R$ 545.00

12.6.4 DIFÍCIL (Nível 4)

16. Sistema de Alertas de Cripto Crie um sistema de notificações de preços de criptomoedas com alertas.

Exemplo: Input → Bitcoin > $50,000 | Output → 🚨 ALERTA: Bitcoin atingiu $50,230!

17. Dashboard do GitHub Crie um dashboard de informações do GitHub que mostra estatísticas de um usuário.

Exemplo: Input → "octocat" | Output → Repositórios: 8, Seguidores: 3938, Seguindo: 9

18. Sistema de Backup Crie um sistema de backup de dados que salva informações de APIs em arquivos JSON.

Exemplo: Output → Dados salvos em backup_github_2024-01-15.json

19. Comparador de Preços Crie um comparador de preços de produtos usando APIs de e-commerce.

Exemplo: Input → "iPhone 15" | Output → Loja A: R$ 8,999, Loja B: R$ 9,299

20. Monitor de Sites Crie um sistema de monitoramento de sites que verifica status periodicamente.

Exemplo: Output → Google: ✅ Online, GitHub: ✅ Online, Site X: ❌ Offline

12.6.5 MUITO DIFÍCIL (Nível 5)

21. Análise de Sentimentos Crie um sistema completo de análise de sentimentos de tweets usando APIs.

Exemplo: Input → "Python é incrível!" | Output → Sentimento: Positivo (85%)

22. Bot de Telegram Crie um bot de Telegram que responde com informações de APIs.

Exemplo: Input → "/cep 01310-100" | Output → 📍 Avenida Paulista, Bela Vista - São Paulo - SP

23. Sistema de Recomendação Crie um sistema de recomendação de filmes baseado em APIs de dados.

Exemplo: Input → "The Matrix" | Output → Filmes similares: Inception, Interstellar, Blade Runner

24. Dashboard Web Crie um dashboard web que exibe dados de múltiplas APIs em tempo real.

Exemplo: Output → Dashboard com clima, criptomoedas e notícias atualizadas

25. Sistema de Automação Crie um sistema de automação que integra várias APIs para um workflow completo.

Exemplo: Output → Workflow executado: Clima consultado → Email enviado → Dados salvos

12.7 Respostas e Explicações

12.7.1 MUITO FÁCIL (Nível 1)

1. Informações Básicas do GitHub

import requests

def info_github_basica(username):
    """Busca informações básicas de um usuário do GitHub"""
    url = f'https://api.github.com/users/{username}'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            print(f"Nome: {dados['name']}")
            print(f"Seguidores: {dados['followers']}")
            return dados
        else:
            print(f"Usuário não encontrado: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
info_github_basica('octocat')

Explicação linha por linha:

Linha 1: import requests - Importa biblioteca requests para fazer requisições HTTP
Linha 3: def info_github_basica(username): - Define função que recebe username como parâmetro
Linha 4: """Busca informações básicas de um usuário do GitHub""" - Docstring explicando função
Linha 5: url = f'https://api.github.com/users/{username}' - Monta URL da API do GitHub com username
Linha 7: try: - Inicia bloco try para tratamento de erros
Linha 8: response = requests.get(url) - Faz requisição GET para a URL da API
Linha 9: if response.status_code == 200: - Verifica se requisição foi bem-sucedida (status 200)
Linha 10: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 11: print(f"Nome: {dados['name']}") - Mostra nome do usuário
Linha 12: print(f"Seguidores: {dados['followers']}") - Mostra número de seguidores

2. Buscar CEP Específico

def buscar_cep_especifico():
    """Busca o CEP 20040-020 (Rio de Janeiro)"""
    cep = '20040-020'
    url = f'https://viacep.com.br/ws/{cep}/json/'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            print(f"📍 {dados['logradouro']}, {dados['bairro']}")
            print(f"📍 {dados['localidade']} - {dados['uf']}")
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
buscar_cep_especifico()

Explicação linha por linha:

Linha 1: def buscar_cep_especifico(): - Define função para buscar CEP específico
Linha 2: """Busca o CEP 20040-020 (Rio de Janeiro)""" - Docstring explicando função
Linha 3: cep = '20040-020' - Define CEP específico do Rio de Janeiro
Linha 4: url = f'https://viacep.com.br/ws/{cep}/json/' - Monta URL da API ViaCEP
Linha 6: try: - Inicia bloco try para tratamento de erros
Linha 7: response = requests.get(url) - Faz requisição GET para ViaCEP
Linha 8: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 9: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: print(f"📍 {dados['logradouro']}, {dados['bairro']}") - Mostra logradouro e bairro
Linha 11: print(f"📍 {dados['localidade']} - {dados['uf']}") - Mostra cidade e estado

3. Preço do Bitcoin

def preco_bitcoin():
    """Consulta preço atual do Bitcoin"""
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {'ids': 'bitcoin', 'vs_currencies': 'usd,brl'}
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            preco_usd = dados['bitcoin']['usd']
            preco_brl = dados['bitcoin']['brl']
            
            print(f"💰 Bitcoin")
            print(f"💵 USD: ${preco_usd:,.2f}")
            print(f"🇧🇷 BRL: R$ {preco_brl:,.2f}")
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
preco_bitcoin()

Explicação linha por linha:

Linha 1: def preco_bitcoin(): - Define função para consultar preço do Bitcoin
Linha 2: """Consulta preço atual do Bitcoin""" - Docstring explicando função
Linha 3: url = 'https://api.coingecko.com/api/v3/simple/price' - URL da API CoinGecko
Linha 4: params = {'ids': 'bitcoin', 'vs_currencies': 'usd,brl'} - Parâmetros para buscar Bitcoin em USD e BRL
Linha 6: try: - Inicia bloco try para tratamento de erros
Linha 7: response = requests.get(url, params=params) - Faz requisição GET com parâmetros
Linha 8: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 9: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: preco_usd = dados['bitcoin']['usd'] - Extrai preço em USD
Linha 11: preco_brl = dados['bitcoin']['brl'] - Extrai preço em BRL

4. Listar Posts

def listar_posts():
    """Lista títulos dos 3 primeiros posts usando JSONPlaceholder"""
    url = 'https://jsonplaceholder.typicode.com/posts'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            posts = response.json()
            
            print("📝 Primeiros 3 posts:")
            for i, post in enumerate(posts[:3]):
                print(f"{i+1}. {post['title']}")
            
            return posts
        else:
            printiguém(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
listar_posts()

Explicação linha por linha:

Linha 1: def listar_posts(): - Define função para listar posts
Linha 2: """Lista títulos dos 3 primeiros posts usando JSONPlaceholder""" - Docstring explicando função
Linha 3: url = 'https://jsonplaceholder.typicode.com/posts' - URL da API JSONPlaceholder
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: posts = response.json() - Converte resposta JSON em lista de posts
Linha 10: print("📝 Primeiros 3 posts:") - Mostra cabeçalho
Linha 11: for i, post in enumerate(posts[:3]): - Percorre apenas os 3 primeiros posts
Linha 12: print(f"{i+1}. {post['title']}") - Mostra título de cada post numerado

5. Verificar Usuário GitHub

def verificar_usuario_github(username):
    """Verifica se um usuário do GitHub existe"""
    url = f'https://api.github.com/users/{username}'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            print(f"✅ Usuário '{username}' existe")
            return True
        elif response.status_code == 404:
            print(f"❌ Usuário '{username}' não existe")
            return False
        else:
            print(f"⚠️ Erro inesperado: {response.status_code}")
            return False
    except requests.exceptions.RequestException as e:
        print(f"🚫 Erro de conexão: {e}")
        return False

# Testando
verificar_usuario_github('octocat')
verificar_usuario_github('usuario_inexistente_12345')

Explicação linha por linha:

Linha 1: def verificar_usuario_github(username): - Define função que recebe username como parâmetro
Linha 2: """Verifica se um usuário do GitHub existe""" - Docstring explicando função
Linha 3: url = f'https://api.github.com/users/{username}' - Monta URL da API do GitHub
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se usuário existe (status 200)
Linha 8: print(f"✅ Usuário '{username}' existe") - Mostra mensagem de sucesso
Linha 9: return True - Retorna True indicando que usuário existe
Linha 10: elif response.status_code == 404: - Verifica se usuário não existe (status 404)
Linha 11: print(f"❌ Usuário '{username}' não existe") - Mostra mensagem de erro
Linha 12: return False - Retorna False indicando que usuário não existe

12.7.2 FÁCIL (Nível 2)

6. Conversor de CEP Formatado

def conversor_cep_formatado(cep):
    """Busca CEP e formata de forma bonita"""
    url = f'https://viacep.com.br/ws/{cep}/json/'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            if 'erro' not in dados:
                print("=" * 50)
                print(f"📍 ENDEREÇO ENCONTRADO")
                print("=" * 50)
                print(f"CEP: {dados['cep']}")
                print(f"Logradouro: {dados['logradouro']}")
                print(f"Bairro: {dados['bairro']}")
                print(f"Cidade: {dados['localidade']}")
                print(f"Estado: {dados['uf']}")
                print("=" * 50)
                return dados
            else:
                print(f"❌ CEP {cep} não encontrado")
                return None
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
conversor_cep_formatado('01310-100')

Explicação linha por linha:

Linha 1: def conversor_cep_formatado(cep): - Define função que recebe CEP como parâmetro
Linha 2: """Busca CEP e formata de forma bonita""" - Docstring explicando função
Linha 3: url = f'https://viacep.com.br/ws/{cep}/json/' - Monta URL da API ViaCEP
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: if 'erro' not in dados: - Verifica se CEP foi encontrado (sem erro)
Linha 11: print("=" * 50) - Imprime linha separadora
Linha 12: print(f"📍 ENDEREÇO ENCONTRADO") - Mostra cabeçalho formatado
Linha 13: print("=" * 50) - Imprime linha separadora
Linhas 14-18: Mostra informações do endereço formatadas

7. Comparar Criptomoedas

def comparar_criptos():
    """Compara preços de Bitcoin e Ethereum"""
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {
        'ids': 'bitcoin,ethereum',
        'vs_currencies': 'usd,brl'
    }
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            
            btc_usd = dados['bitcoin']['usd']
            btc_brl = dados['bitcoin']['brl']
            eth_usd = dados['ethereum']['usd']
            eth_brl = dados['ethereum']['brl']
            
            print("💰 COMPARAÇÃO DE CRIPTOMOEDAS")
            print("=" * 40)
            print(f"Bitcoin:  ${btc_usd:,.2f} | R$ {btc_brl:,.2f}")
            print(f"Ethereum: ${eth_usd:,.2f} | R$ {eth_brl:,.2f}")
            print("=" * 40)
            
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
comparar_criptos()

Explicação linha por linha:

Linha 1: def comparar_criptos(): - Define função para comparar criptomoedas
Linha 2: """Compara preços de Bitcoin e Ethereum""" - Docstring explicando função
Linha 3: url = 'https://api.coingecko.com/api/v3/simple/price' - URL da API CoinGecko
Linhas 4-7: Define parâmetros para buscar Bitcoin e Ethereum em USD e BRL
Linha 9: try: - Inicia bloco try para tratamento de erros
Linha 10: response = requests.get(url, params=params) - Faz requisição GET com parâmetros
Linha 11: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 12: dados = response.json() - Converte resposta JSON em dicionário Python
Linhas 14-17: Extrai preços de Bitcoin e Ethereum em USD e BRL
Linha 19: print("💰 COMPARAÇÃO DE CRIPTOMOEDAS") - Mostra cabeçalho formatado
Linha 20: print("=" * 40) - Imprime linha separadora
Linhas 21-22: Mostra preços formatados de ambas as moedas

8. Gerador de Citações

def gerar_citacao():
    """Gera uma citação aleatória usando quotable.io"""
    url = 'https://api.quotable.io/random'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            citacao = dados['content']
            autor = dados['author']
            
            print(f'"{citacao}"')
            print(f"- {autor}")
            
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
gerar_citacao()

Explicação linha por linha:

Linha 1: def gerar_citacao(): - Define função para gerar citação aleatória
Linha 2: """Gera uma citação aleatória usando quotable.io""" - Docstring explicando função
Linha 3: url = 'https://api.quotable.io/random' - URL da API quotable.io
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: citacao = dados['content'] - Extrai conteúdo da citação
Linha 11: autor = dados['author'] - Extrai autor da citação
Linha 13: print(f'"{citacao}"') - Mostra citação entre aspas
Linha 14: print(f"- {autor}") - Mostra autor com hífen

9. Informações de País

def buscar_pais(nome_pais):
    """Busca informações de um país usando restcountries.com"""
    url = f'https://restcountries.com/v3.1/name/{nome_pais}'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            pais = dados[0]  # Primeiro resultado
            nome_oficial = pais['name']['official']
            capital = pais['capital'][0] if pais['capital'] else 'N/A'
            populacao = pais['population']
            
            print(f"País: {nome_oficial}")
            print(f"Capital: {capital}")
            print(f"População: {populacao:,}")
            
            return pais
        else:
            print(f"País não encontrado: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
buscar_pais('Brazil')

Explicação linha por linha:

Linha 1: def buscar_pais(nome_pais): - Define função que recebe nome do país como parâmetro
Linha 2: """Busca informações de um país usando restcountries.com""" - Docstring explicando função
Linha 3: url = f'https://restcountries.com/v3.1/name/{nome_pais}' - Monta URL da API restcountries
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: dados = response.json() - Converte resposta JSON em lista de países
Linha 10: pais = dados[0] - Pega primeiro país da lista
Linha 11: nome_oficial = pais['name']['official'] - Extrai nome oficial do país
Linha 12: capital = pais['capital'][0] if pais['capital'] else 'N/A' - Extrai capital (primeira da lista)
Linha 13: populacao = pais['population'] - Extrai população do país

10. Verificador de Sites

def verificar_site(url):
    """Verifica se um site está funcionando"""
    try:
        response = requests.get(url, timeout=10)
        print(f"Site funcionando: Status {response.status_code}")
        return True
    except requests.exceptions.RequestException as e:
        print(f"Site com problemas: {e}")
        return False

# Testando
verificar_site('https://google.com')
verificar_site('https://site-inexistente.com')

Explicação linha por linha:

Linha 1: def verificar_site(url): - Define função que recebe URL como parâmetro
Linha 2: """Verifica se um site está funcionando""" - Docstring explicando função
Linha 3: try: - Inicia bloco try para tratamento de erros
Linha 4: response = requests.get(url, timeout=10) - Faz requisição GET com timeout de 10 segundos
Linha 5: print(f"Site funcionando: Status {response.status_code}") - Mostra status se site funcionar
Linha 6: return True - Retorna True se site funcionar
Linha 7: except requests.exceptions.RequestException as e: - Captura erros de requisição
Linha 8: print(f"Site com problemas: {e}") - Mostra erro se site não funcionar
Linha 9: return False - Retorna False se site não funcionar

12.7.3 MÉDIO (Nível 3)

11. Sistema de Clima

def consultar_clima_multiplas_cidades(cidades, api_key):
    """Consulta clima de múltiplas cidades"""
    resultados = {}
    
    for cidade in cidades:
        url = 'https://api.openweathermap.org/data/2.5/weather'
        params = {
            'q': cidade,
            'appid': api_key,
            'units': 'metric',
            'lang': 'pt_br'
        }
        
        try:
            response = requests.get(url, params=params)
            if response.status_code == 200:
                dados = response.json()
                temperatura = dados['main']['temp']
                resultados[cidade] = temperatura
                print(f"{cidade}: {temperatura}°C")
            else:
                print(f"Erro ao consultar {cidade}: {response.status_code}")
        except requests.exceptions.RequestException as e:
            print(f"Erro de conexão para {cidade}: {e}")
    
    return resultados

# Testando (precisa de API key)
# clima = consultar_clima_multiplas_cidades(['São Paulo', 'Rio de Janeiro'], 'sua_api_key')

Explicação linha por linha:

Linha 1: def consultar_clima_multiplas_cidades(cidades, api_key): - Define função que recebe lista de cidades e API key
Linha 2: """Consulta clima de múltiplas cidades""" - Docstring explicando função
Linha 3: resultados = {} - Inicializa dicionário para armazenar resultados
Linha 5: for cidade in cidades: - Percorre cada cidade da lista
Linha 6: url = 'https://api.openweathermap.org/data/2.5/weather' - URL da API OpenWeatherMap
Linhas 7-12: Define parâmetros para consulta de clima
Linha 14: try: - Inicia bloco try para tratamento de erros
Linha 15: response = requests.get(url, params=params) - Faz requisição GET com parâmetros
Linha 16: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 17: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 18: temperatura = dados['main']['temp'] - Extrai temperatura dos dados
Linha 19: resultados[cidade] = temperatura - Armazena temperatura no dicionário
Linha 20: print(f"{cidade}: {temperatura}°C") - Mostra temperatura da cidade

12. Tracker de Criptomoedas

def tracker_criptomoedas():
    """Monitora preços de Bitcoin, Ethereum e Litecoin"""
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {
        'ids': 'bitcoin,ethereum,litecoin',
        'vs_currencies': 'usd'
    }
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            
            print("💰 TRACKER DE CRIPTOMOEDAS")
            print("=" * 35)
            print(f"Bitcoin:  ${dados['bitcoin']['usd']:,.2f}")
            print(f"Ethereum: ${dados['ethereum']['usd']:,.2f}")
            print(f"Litecoin: ${dados['litecoin']['usd']:,.2f}")
            print("=" * 35)
            
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
tracker_criptomoedas()

Explicação linha por linha:

Linha 1: def tracker_criptomoedas(): - Define função para monitorar criptomoedas
Linha 2: """Monitora preços de Bitcoin, Ethereum e Litecoin""" - Docstring explicando função
Linha 3: url = 'https://api.coingecko.com/api/v3/simple/price' - URL da API CoinGecko
Linhas 4-7: Define parâmetros para buscar Bitcoin, Ethereum e Litecoin em USD
Linha 9: try: - Inicia bloco try para tratamento de erros
Linha 10: response = requests.get(url, params=params) - Faz requisição GET com parâmetros
Linha 11: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 12: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 14: print("💰 TRACKER DE CRIPTOMOEDAS") - Mostra cabeçalho formatado
Linha 15: print("=" * 35) - Imprime linha separadora
Linhas 16-18: Mostra preços formatados das três criptomoedas

13. Gerador de Perfis

def gerar_perfil_aleatorio():
    """Gera um perfil aleatório usando randomuser.me"""
    url = 'https://randomuser.me/api/'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            usuario = dados['results'][0]
            nome = f"{usuario['name']['first']} {usuario['name']['last']}"
            email = usuario['email']
            pais = usuario['location']['country']
            
            print(f"Nome: {nome}")
            print(f"Email: {email}")
            print(f"País: {pais}")
            
            return usuario
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
gerar_perfil_aleatorio()

Explicação linha por linha:

Linha 1: def gerar_perfil_aleatorio(): - Define função para gerar perfil aleatório
Linha 2: """Gera um perfil aleatório usando randomuser.me""" - Docstring explicando função
Linha 3: url = 'https://randomuser.me/api/' - URL da API randomuser.me
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: usuario = dados['results'][0] - Pega primeiro usuário da lista de resultados
Linha 11: nome = f"{usuario['name']['first']} {usuario['name']['last']}" - Monta nome completo
Linha 12: email = usuario['email'] - Extrai email do usuário
Linha 13: pais = usuario['location']['country'] - Extrai país do usuário

14. Busca de Filmes

def buscar_filme(titulo, api_key):
    """Busca informações de um filme usando OMDb"""
    url = 'https://www.omdbapi.com/'
    params = {
        'apikey': api_key,
        't': titulo
    }
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            
            if dados['Response'] == 'True':
                print(f"Filme: {dados['Title']}")
                print(f"Ano: {dados['Year']}")
                print(f"Diretor: {dados['Director']}")
                print(f"Nota: {dados['imdbRating']}/10")
                
                return dados
            else:
                print(f"Filme '{titulo}' não encontrado")
                return None
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando (precisa de API key)
# filme = buscar_filme('The Matrix', 'sua_api_key')

Explicação linha por linha:

Linha 1: def buscar_filme(titulo, api_key): - Define função que recebe título e API key
Linha 2: """Busca informações de um filme usando OMDb""" - Docstring explicando função
Linha 3: url = 'https://www.omdbapi.com/' - URL da API OMDb
Linhas 4-7: Define parâmetros para busca do filme
Linha 9: try: - Inicia bloco try para tratamento de erros
Linha 10: response = requests.get(url, params=params) - Faz requisição GET com parâmetros
Linha 11: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 12: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 14: if dados['Response'] == 'True': - Verifica se filme foi encontrado
Linhas 15-18: Mostra informações do filme encontrado
Linha 20: else: - Se filme não foi encontrado
Linha 21: print(f"Filme '{titulo}' não encontrado") - Mostra mensagem de erro

15. Conversor de Moedas

def conversor_moedas(valor, moeda_origem, moeda_destino):
    """Converte moedas usando API de câmbio em tempo real"""
    url = 'https://api.exchangerate-api.com/v4/latest/USD'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            # Se origem não for USD, converte primeiro para USD
            if moeda_origem != 'USD':
                taxa_origem = dados['rates'][moeda_origem]
                valor_usd = valor / taxa_origem
            else:
                valor_usd = valor
            
            # Converte para moeda de destino
            taxa_destino = dados['rates'][moeda_destino]
            valor_convertido = valor_usd * taxa_destino
            
            print(f"${valor:.2f} {moeda_origem} = ${valor_convertido:.2f} {moeda_destino}")
            
            return valor_convertido
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
conversor_moedas(100, 'USD', 'BRL')

Explicação linha por linha:

Linha 1: def conversor_moedas(valor, moeda_origem, moeda_destino): - Define função para conversão de moedas
Linha 2: """Converte moedas usando API de câmbio em tempo real""" - Docstring explicando função
Linha 3: url = 'https://api.exchangerate-api.com/v4/latest/USD' - URL da API de câmbio
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: # Se origem não for USD, converte primeiro para USD - Comentário explicativo
Linha 11: if moeda_origem != 'USD': - Verifica se moeda origem não é USD
Linha 12: taxa_origem = dados['rates'][moeda_origem] - Obtém taxa da moeda origem
Linha 13: valor_usd = valor / taxa_origem - Converte valor para USD
Linha 15: taxa_destino = dados['rates'][moeda_destino] - Obtém taxa da moeda destino
Linha 16: valor_convertido = valor_usd * taxa_destino - Converte valor para moeda destino

12.7.4 DIFÍCIL (Nível 4)

16. Sistema de Alertas de Cripto

def sistema_alertas_cripto(moeda, preco_alerta):
    """Sistema de notificações de preços de criptomoedas"""
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {'ids': moeda, 'vs_currencies': 'usd'}
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            preco_atual = dados[moeda]['usd']
            
            if preco_atual > preco_alerta:
                print(f"🚨 ALERTA: {moeda.title()} atingiu ${preco_atual:,.2f}!")
                print(f"💰 Preço atual: ${preco_atual:,.2f}")
                print(f"🎯 Preço alerta: ${preco_alerta:,.2f}")
                print(f"📈 Diferença: +${preco_atual - preco_alerta:,.2f}")
                
                return True  # Alerta disparado
            else:
                print(f"📊 {moeda.title()}: ${preco_atual:,.2f} (alerta: ${preco_alerta:,.2f})")
                return False  # Alerta não disparado
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
sistema_alertas_cripto('bitcoin', 50000)

Explicação linha por linha:

Linha 1: def sistema_alertas_cripto(moeda, preco_alerta): - Define função para sistema de alertas
Linha 2: """Sistema de notificações de preços de criptomoedas""" - Docstring explicando função
Linha 3: url = 'https://api.coingecko.com/api/v3/simple/price' - URL da API CoinGecko
Linha 4: params = {'ids': moeda, 'vs_currencies': 'usd'} - Parâmetros para buscar moeda em USD
Linha 6: try: - Inicia bloco try para tratamento de erros
Linha 7: response = requests.get(url, params=params) - Faz requisição GET com parâmetros
Linha 8: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 9: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: preco_atual = dados[moeda]['usd'] - Extrai preço atual da moeda
Linha 12: if preco_atual > preco_alerta: - Verifica se preço atual superou alerta
Linha 13: print(f"🚨 ALERTA: {moeda.title()} atingiu ${preco_atual:,.2f}!") - Mostra alerta
Linhas 14-16: Mostra detalhes do alerta (preço atual, alerta, diferença)

17. Dashboard do GitHub

def dashboard_github(username):
    """Dashboard de informações do GitHub"""
    url = f'https://api.github.com/users/{username}'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            print("📊 DASHBOARD DO GITHUB")
            print("=" * 40)
            print(f"👤 Usuário: {dados['name']}")
            print(f"📁 Repositórios: {dados['public_repos']}")
            print(f"👥 Seguidores: {dados['followers']}")
            print(f"👥 Seguindo: {dados['following']}")
            print(f"⭐ Gists: {dados['public_gists']}")
            print(f"🏢 Empresa: {dados['company'] or 'N/A'}")
            print(f"📍 Local: {dados['location'] or 'N/A'}")
            print(f"📝 Bio: {dados['bio'] or 'N/A'}")
            print("=" * 40)
            
            return dados
        else:
            print(f"Usuário não encontrado: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
dashboard_github('octocat')

Explicação linha por linha:

Linha 1: def dashboard_github(username): - Define função para dashboard do GitHub
Linha 2: """Dashboard de informações do GitHub""" - Docstring explicando função
Linha 3: url = f'https://api.github.com/users/{username}' - Monta URL da API do GitHub
Linha 5: try: - Inicia bloco try para tratamento de erros
Linha 6: response = requests.get(url) - Faz requisição GET para API
Linha 7: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 8: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 10: print("📊 DASHBOARD DO GITHUB") - Mostra cabeçalho formatado
Linha 11: print("=" * 40) - Imprime linha separadora
Linhas 12-19: Mostra informações formatadas do usuário
Linha 21: return dados - Retorna dados do usuário

18. Sistema de Backup

import json
from datetime import datetime

def backup_dados_api(url, nome_arquivo):
    """Salva dados de API em arquivo JSON"""
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            # Criar nome do arquivo com timestamp
            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
            nome_completo = f"backup_{nome_arquivo}_{timestamp}.json"
            
            # Salvar dados em arquivo JSON
            with open(nome_completo, 'w', encoding='utf-8') as arquivo:
                json.dump(dados, arquivo, indent=2, ensure_ascii=False)
            
            print(f"✅ Dados salvos em {nome_completo}")
            print(f"📁 Tamanho: {len(str(dados))} caracteres")
            
            return nome_completo
        else:
            print(f"Erro na API: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
backup_dados_api('https://api.github.com/users/octocat', 'github')

Explicação linha por linha:

Linha 1: import json - Importa módulo json para trabalhar com arquivos JSON
Linha 2: from datetime import datetime - Importa datetime para timestamp
Linha 4: def backup_dados_api(url, nome_arquivo): - Define função para backup de dados
Linha 5: """Salva dados de API em arquivo JSON""" - Docstring explicando função
Linha 6: try: - Inicia bloco try para tratamento de erros
Linha 7: response = requests.get(url) - Faz requisição GET para API
Linha 8: if response.status_code == 200: - Verifica se requisição foi bem-sucedida
Linha 9: dados = response.json() - Converte resposta JSON em dicionário Python
Linha 11: # Criar nome do arquivo com timestamp - Comentário explicativo
Linha 12: timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") - Cria timestamp atual
Linha 13: nome_completo = f"backup_{nome_arquivo}_{timestamp}.json" - Monta nome do arquivo
Linha 15: # Salvar dados em arquivo JSON - Comentário explicativo
Linha 16: with open(nome_completo, 'w', encoding='utf-8') as arquivo: - Abre arquivo para escrita
Linha 17: json.dump(dados, arquivo, indent=2, ensure_ascii=False) - Salva dados em JSON

19. Comparador de Preços

def comparador_precos_produto(produto):
    """Compara preços de produtos (simulado)"""
    # Simulando preços de diferentes lojas
    lojas = {
        'Loja A': 8999.00,
        'Loja B': 9299.00,
        'Loja C': 8799.00,
        'Loja D': 9199.00
    }
    
    print(f"💰 COMPARAÇÃO DE PREÇOS: {produto}")
    print("=" * 50)
    
    menor_preco = min(lojas.values())
    maior_preco = max(lojas.values())
    
    for loja, preco in lojas.items():
        if preco == menor_preco:
            print(f"🏆 {loja}: R$ {preco:,.2f} (MENOR PREÇO!)")
        elif preco == maior_preco:
            print(f"💸 {loja}: R$ {preco:,.2f} (MAIOR PREÇO)")
        else:
            print(f"📊 {loja}: R$ {preco:,.2f}")
    
    print("=" * 50)
    print(f"💡 Economia máxima: R$ {maior_preco - menor_preco:,.2f}")
    
    return lojas

# Testando
comparador_precos_produto('iPhone 15')

Explicação linha por linha:

Linha 1: def comparador_precos_produto(produto): - Define função para comparar preços
Linha 2: """Compara preços de produtos (simulado)""" - Docstring explicando função
Linha 3: # Simulando preços de diferentes lojas - Comentário explicativo
Linhas 4-9: Define dicionário com preços simulados de diferentes lojas
Linha 11: print(f"💰 COMPARAÇÃO DE PREÇOS: {produto}") - Mostra cabeçalho formatado
Linha 12: print("=" * 50) - Imprime linha separadora
Linha 14: menor_preco = min(lojas.values()) - Encontra menor preço
Linha 15: maior_preco = max(lojas.values()) - Encontra maior preço
Linha 17: for loja, preco in lojas.items(): - Percorre lojas e preços
Linha 18: if preco == menor_preco: - Verifica se é o menor preço
Linha 19: print(f"🏆 {loja}: R$ {preco:,.2f} (MENOR PREÇO!)") - Destaca menor preço

20. Monitor de Sites

import time

def monitor_sites(urls, intervalo=60):
    """Monitora status de sites periodicamente"""
    print(f"🔍 Iniciando monitoramento de {len(urls)} sites...")
    print(f"⏰ Intervalo: {intervalo} segundos")
    print("=" * 50)
    
    while True:
        for url in urls:
            try:
                response = requests.get(url, timeout=10)
                status = "✅ Online" if response.status_code == 200 else "⚠️ Problema"
                print(f"{status} - {url} (Status: {response.status_code})")
            except requests.exceptions.RequestException:
                print(f"❌ Offline - {url}")
        
        print("-" * 50)
        print(f"⏰ Próxima verificação em {intervalo} segundos...")
        time.sleep(intervalo)

# Testando (comentado para não executar infinitamente)
# monitor_sites(['https://google.com', 'https://github.com', 'https://python.org'])

Explicação linha por linha:

Linha 1: import time - Importa módulo time para delays
Linha 3: def monitor_sites(urls, intervalo=60): - Define função para monitorar sites
Linha 4: """Monitora status de sites periodicamente""" - Docstring explicando função
Linha 5: print(f"🔍 Iniciando monitoramento de {len(urls)} sites...") - Mostra início do monitoramento
Linha 6: print(f"⏰ Intervalo: {intervalo} segundos") - Mostra intervalo de verificação
Linha 7: print("=" * 50) - Imprime linha separadora
Linha 9: while True: - Loop infinito para monitoramento contínuo
Linha 10: for url in urls: - Percorre cada URL da lista
Linha 11: try: - Inicia bloco try para tratamento de erros
Linha 12: response = requests.get(url, timeout=10) - Faz requisição GET com timeout
Linha 13: status = "✅ Online" if response.status_code == 200 else "⚠️ Problema" - Define status
Linha 14: print(f"{status} - {url} (Status: {response.status_code})") - Mostra status do site

12.8 Módulo `time` - Controlando Tempo e Delays

📌 Quando ler esta seção: Esta seção é importante para exercícios de monitoramento e automação. O módulo time permite controlar o tempo de execução e criar delays.

12.8.1 O que é o módulo `time`?

O módulo time do Python oferece várias funções para trabalhar com tempo. É muito útil para:

Criar delays entre operações
Medir tempo de execução
Controlar frequência de requisições
Implementar sistemas de monitoramento

12.8.2 Importando o módulo time

import time

12.8.3 Principais Funções do módulo time

12.8.3.1 1. `time.sleep(segundos)` - Criar delays

A função mais usada é sleep(), que pausa a execução por um número específico de segundos:

import time

print("Iniciando processo...")
time.sleep(2)  # Pausa por 2 segundos
print("Processo concluído!")

Exemplos práticos:

import time

# Delay de 1 segundo
print("Contando...")
time.sleep(1)
print("1 segundo se passou!")

# Delay de meio segundo
time.sleep(0.5)
print("Mais meio segundo...")

# Delay de 3 segundos
time.sleep(3)
print("3 segundos se passaram!")

12.8.3.2 2. `time.time()` - Obter timestamp

Retorna o tempo atual como um número (segundos desde 1º de janeiro de 1970):

import time

# Timestamp atual
agora = time.time()
print(f"Timestamp atual: {agora}")

# Usar para medir tempo de execução
inicio = time.time()
# ... seu código aqui ...
fim = time.time()
tempo_execucao = fim - inicio
print(f"Tempo de execução: {tempo_execucao:.2f} segundos")

12.8.4 Exemplos Práticos

12.8.4.1 1. Monitoramento com delays

import time

def monitorar_sistema():
    print("Iniciando monitoramento...")
    
    for i in range(5):
        print(f"Verificação {i+1}/5")
        # Simular verificação
        time.sleep(1)  # Aguardar 1 segundo entre verificações
    
    print("Monitoramento concluído!")

monitorar_sistema()

12.8.4.2 2. Medir tempo de requisições

import time
import requests

def medir_requisicao(url):
    print(f"Fazendo requisição para: {url}")
    
    inicio = time.time()
    try:
        response = requests.get(url)
        fim = time.time()
        
        tempo_total = fim - inicio
        print(f"Requisição concluída em {tempo_total:.2f} segundos")
        print(f"Status: {response.status_code}")
        
    except requests.exceptions.RequestException as e:
        fim = time.time()
        tempo_total = fim - inicio
        print(f"Erro após {tempo_total:.2f} segundos: {e}")

# Exemplo de uso
medir_requisicao("https://api.github.com")

12.8.4.3 3. Sistema de alertas com delays

import time
import random

def sistema_alertas():
    alertas = 0
    
    for i in range(10):
        # Simular verificação de condição
        valor = random.randint(1, 10)
        
        if valor > 7:
            alertas += 1
            print(f"⚠️ ALERTA #{alertas}: Valor crítico detectado: {valor}")
        else:
            print(f"✅ Verificação {i+1}: Sistema OK (valor: {valor})")
        
        # Aguardar 2 segundos entre verificações
        time.sleep(2)
    
    print(f"\nTotal de alertas: {alertas}")

sistema_alertas()

12.8.4.4 4. Controle de taxa de requisições

import time
import requests

def fazer_requisicoes_controladas(urls):
    print("Fazendo requisições com controle de taxa...")
    
    for i, url in enumerate(urls, 1):
        print(f"Requisição {i}/{len(urls)}: {url}")
        
        try:
            response = requests.get(url)
            print(f"Status: {response.status_code}")
        except requests.exceptions.RequestException as e:
            print(f"Erro: {e}")
        
        # Aguardar 1 segundo entre requisições (para não sobrecarregar o servidor)
        if i < len(urls):  # Não aguardar após a última requisição
            print("Aguardando 1 segundo...")
            time.sleep(1)
    
    print("Todas as requisições concluídas!")

# Exemplo de uso
urls = [
    "https://api.github.com",
    "https://httpbin.org/json",
    "https://api.github.com/users"
]

fazer_requisicoes_controladas(urls)

12.8.5 Exemplos dos Exercícios

Muitos exercícios de monitoramento usam o módulo time:

# Exemplo do exercício de monitoramento de API
import time
import requests

def monitorar_api(url, intervalo=5, max_tentativas=10):
    print(f"Monitorando API: {url}")
    print(f"Intervalo: {intervalo} segundos")
    print(f"Máximo de tentativas: {max_tentativas}")
    print("-" * 40)
    
    tentativas = 0
    
    while tentativas < max_tentativas:
        tentativas += 1
        print(f"Tentativa {tentativas}/{max_tentativas}")
        
        try:
            response = requests.get(url, timeout=10)
            if response.status_code == 200:
                print("✅ API funcionando corretamente")
            else:
                print(f"⚠️ API retornou status: {response.status_code}")
        except requests.exceptions.RequestException as e:
            print(f"❌ Erro na API: {e}")
        
        # Aguardar antes da próxima verificação
        if tentativas < max_tentativas:
            print(f"Aguardando {intervalo} segundos...")
            time.sleep(intervalo)
    
    print("Monitoramento concluído!")

# Exemplo de uso
monitorar_api("https://api.github.com", intervalo=3, max_tentativas=5)

12.8.6 Dicas Importantes

Use time.sleep() para criar delays entre operações
Use time.time() para medir performance
Seja respeitoso com delays em requisições (não sobrecarregue servidores)
Use delays apropriados - muito pequenos podem causar problemas, muito grandes podem ser ineficientes

12.8.7 Quando Usar o módulo time

Use quando: - ✅ Precisar criar delays entre operações - ✅ Quiser medir tempo de execução - ✅ Estiver implementando sistemas de monitoramento - ✅ Quiser controlar taxa de requisições

Exemplos práticos: - Monitoramento de APIs - Sistemas de alertas - Controle de taxa de requisições - Medição de performance - Automação com delays

💡 Dica: O módulo time é essencial para criar sistemas robustos de monitoramento e automação. Sempre use delays apropriados para não sobrecarregar servidores!

12.9 Automação e Monitoramento Contínuo - Loops Infinitos e Sistemas de Alerta

📌 Quando ler esta seção: Esta seção é importante para exercícios avançados de monitoramento. Aprenda a criar sistemas que funcionam continuamente e detectam problemas automaticamente.

12.9.1 O que é Automação e Monitoramento?

Automação é a capacidade de fazer um programa funcionar sozinho, sem intervenção humana. Monitoramento é a observação contínua de sistemas para detectar problemas ou mudanças. Juntos, eles permitem criar sistemas inteligentes que:

Funcionam 24/7 sem parar
Detectam problemas automaticamente
Enviam alertas quando algo está errado
Tomam ações corretivas automaticamente

12.9.2 Loops Infinitos Controlados

12.9.2.1 Estrutura básica com `while True:`

import time

def monitoramento_basico():
    contador = 0
    
    while True:  # Loop infinito
        contador += 1
        print(f"Verificação #{contador}")
        
        # Simular verificação
        print("Sistema funcionando normalmente...")
        
        # Aguardar 5 segundos antes da próxima verificação
        time.sleep(5)
        
        # Para parar: Ctrl+C (KeyboardInterrupt)

# CUIDADO: Este código roda para sempre!
# monitoramento_basico()

12.9.2.2 Loop com condição de parada

import time

def monitoramento_controlado():
    contador = 0
    max_verificacoes = 10
    
    while contador < max_verificacoes:
        contador += 1
        print(f"Verificação {contador}/{max_verificacoes}")
        
        # Simular verificação
        print("Sistema OK")
        
        # Aguardar 2 segundos
        time.sleep(2)
    
    print("Monitoramento concluído!")

monitoramento_controlado()

12.9.3 Sistemas de Alerta

12.9.3.1 1. Sistema de alertas simples

import time
import random

def sistema_alertas():
    alertas = []
    contador = 0
    
    print("Iniciando sistema de monitoramento...")
    
    while contador < 20:  # 20 verificações
        contador += 1
        
        # Simular verificação de temperatura
        temperatura = random.randint(15, 40)
        
        print(f"Verificação {contador}: Temperatura = {temperatura}°C")
        
        # Verificar se temperatura está crítica
        if temperatura > 35:
            alerta = f"ALERTA: Temperatura crítica {temperatura}°C na verificação {contador}"
            alertas.append(alerta)
            print(f"⚠️ {alerta}")
        elif temperatura > 30:
            print(f"⚠️ Atenção: Temperatura alta {temperatura}°C")
        else:
            print("✅ Temperatura normal")
        
        # Aguardar 1 segundo
        time.sleep(1)
    
    # Relatório final
    print(f"\n=== RELATÓRIO FINAL ===")
    print(f"Total de verificações: {contador}")
    print(f"Total de alertas críticos: {len(alertas)}")
    
    if alertas:
        print("\nAlertas registrados:")
        for alerta in alertas:
            print(f"- {alerta}")
    else:
        print("✅ Nenhum alerta crítico registrado!")

sistema_alertas()

12.9.3.2 2. Sistema de monitoramento de API

import time
import requests

def monitorar_api_continuamente(url, intervalo=5, max_falhas=3):
    falhas_consecutivas = 0
    verificacoes = 0
    
    print(f"Monitorando API: {url}")
    print(f"Intervalo: {intervalo} segundos")
    print(f"Máximo de falhas consecutivas: {max_falhas}")
    print("-" * 50)
    
    while True:
        verificacoes += 1
        
        try:
            print(f"Verificação #{verificacoes}")
            response = requests.get(url, timeout=10)
            
            if response.status_code == 200:
                print("✅ API funcionando corretamente")
                falhas_consecutivas = 0  # Reset contador de falhas
            else:
                falhas_consecutivas += 1
                print(f"⚠️ API retornou status: {response.status_code}")
                
                if falhas_consecutivas >= max_falhas:
                    print(f"🚨 ALERTA: {max_falhas} falhas consecutivas!")
                    print("Ação necessária: Verificar API manualmente")
                    break
                    
        except requests.exceptions.RequestException as e:
            falhas_consecutivas += 1
            print(f"❌ Erro na API: {e}")
            
            if falhas_consecutivas >= max_falhas:
                print(f"🚨 ALERTA: {max_falhas} falhas consecutivas!")
                print("Ação necessária: Verificar conectividade")
                break
        
        # Aguardar antes da próxima verificação
        print(f"Aguardando {intervalo} segundos...")
        time.sleep(intervalo)
    
    print("Monitoramento interrompido!")

# Exemplo de uso (comentado para não executar infinitamente)
# monitorar_api_continuamente("https://api.github.com", intervalo=3, max_falhas=2)

12.9.4 Controle de Execução

12.9.4.1 1. Parar com tecla específica

import time
import sys

def monitoramento_com_controle():
    print("Sistema de monitoramento iniciado")
    print("Pressione 'q' + Enter para parar")
    
    contador = 0
    
    while True:
        contador += 1
        print(f"Verificação #{contador}")
        
        # Simular verificação
        print("Sistema funcionando...")
        
        # Aguardar 2 segundos
        time.sleep(2)
        
        # Verificar se usuário quer parar (simulação)
        # Em um sistema real, você usaria threading ou input não-bloqueante
        if contador >= 5:  # Simular parada após 5 verificações
            print("Parando monitoramento...")
            break
    
    print("Monitoramento finalizado!")

monitoramento_com_controle()

12.9.4.2 2. Sistema com horário de funcionamento

import time
from datetime import datetime

def monitoramento_com_horario():
    print("Sistema de monitoramento com horário")
    print("Funcionará das 8h às 18h")
    
    contador = 0
    
    while True:
        agora = datetime.now()
        hora_atual = agora.hour
        
        # Verificar se está no horário de funcionamento
        if 8 <= hora_atual < 18:
            contador += 1
            print(f"Verificação #{contador} - {agora.strftime('%H:%M:%S')}")
            print("Sistema funcionando...")
        else:
            print(f"Sistema em pausa - Hora atual: {hora_atual}:00")
            print("Retomando às 8h da manhã")
        
        # Aguardar 1 minuto
        time.sleep(60)
        
        # Para demonstração, parar após algumas verificações
        if contador >= 3:
            break
    
    print("Demonstração concluída!")

# monitoramento_com_horario()

12.9.5 Exemplos dos Exercícios

Muitos exercícios usam conceitos de automação:

# Exemplo do exercício de monitoramento de site
import time
import requests

def monitorar_sites(sites, intervalo=10):
    print("Iniciando monitoramento de sites...")
    
    while True:
        print(f"\n--- Verificação às {time.strftime('%H:%M:%S')} ---")
        
        for site in sites:
            try:
                response = requests.get(site, timeout=5)
                if response.status_code == 200:
                    print(f"✅ {site} - Online")
                else:
                    print(f"⚠️ {site} - Status: {response.status_code}")
            except requests.exceptions.RequestException:
                print(f"❌ {site} - Offline")
        
        print(f"Aguardando {intervalo} segundos...")
        time.sleep(intervalo)

# Lista de sites para monitorar
sites = [
    "https://www.google.com",
    "https://www.github.com",
    "https://www.python.org"
]

# Para demonstração, limitar execução
def demo_monitoramento():
    print("Demo de monitoramento (3 verificações):")
    for i in range(3):
        print(f"\nVerificação {i+1}/3")
        for site in sites:
            print(f"✅ {site} - Online (simulado)")
        time.sleep(2)
    print("Demo concluída!")

demo_monitoramento()

12.9.6 Dicas Importantes

Sempre use delays - loops infinitos sem delays consomem muito CPU
Implemente condições de parada - evite loops que nunca terminam
Use try-except - trate erros para evitar crashes
Seja respeitoso - não sobrecarregue servidores com muitas requisições
Log suas ações - registre o que está acontecendo para debug

12.9.7 Quando Usar Automação e Monitoramento

Use quando: - ✅ Precisar verificar sistemas continuamente - ✅ Quiser detectar problemas automaticamente - ✅ Estiver criando sistemas de alerta - ✅ Quiser automatizar tarefas repetitivas

Exemplos práticos: - Monitoramento de servidores - Verificação de APIs - Sistemas de alerta - Automação de tarefas

💡 Dica: Automação e monitoramento são fundamentais para sistemas profissionais. Sempre implemente controles de parada e tratamento de erros!

12.9.8 MUITO DIFÍCIL (Nível 5)

21. Análise de Sentimentos

def analise_sentimentos(texto):
    """Sistema de análise de sentimentos (simulado)"""
    # Simulando análise de sentimentos
    palavras_positivas = ['incrível', 'ótimo', 'excelente', 'fantástico', 'maravilhoso', 'perfeito']
    palavras_negativas = ['ruim', 'terrível', 'horrível', 'péssimo', 'odioso', 'detestável']
    
    texto_lower = texto.lower()
    score_positivo = sum(1 for palavra in palavras_positivas if palavra in texto_lower)
    score_negativo = sum(1 for palavra in palavras_negativas if palavra in texto_lower)
    
    if score_positivo > score_negativo:
        sentimento = "Positivo"
        porcentagem = min(85, 50 + (score_positivo - score_negativo) * 10)
    elif score_negativo > score_positivo:
        sentimento = "Negativo"
        porcentagem = min(85, 50 + (score_negativo - score_positivo) * 10)
    else:
        sentimento = "Neutro"
        porcentagem = 50
    
    print(f"📊 ANÁLISE DE SENTIMENTOS")
    print("=" * 30)
    print(f"Texto: '{texto}'")
    print(f"Sentimento: {sentimento}")
    print(f"Confiança: {porcentagem}%")
    print(f"Score positivo: {score_positivo}")
    print(f"Score negativo: {score_negativo}")
    print("=" * 30)
    
    return {
        'sentimento': sentimento,
        'porcentagem': porcentagem,
        'score_positivo': score_positivo,
        'score_negativo': score_negativo
    }

# Testando
analise_sentimentos("Python é incrível!")
analise_sentimentos("Este código está horrível")
analise_sentimentos("O tempo está normal hoje")

Explicação linha por linha:

Linha 1: def analise_sentimentos(texto): - Define função para análise de sentimentos
Linha 2: """Sistema de análise de sentimentos (simulado)""" - Docstring explicando função
Linha 3: # Simulando análise de sentimentos - Comentário explicativo
Linha 4: palavras_positivas = ['incrível', 'ótimo', 'excelente', 'fantástico', 'maravilhoso', 'perfeito'] - Define lista de palavras positivas
Linha 5: palavras_negativas = ['ruim', 'terrível', 'horrível', 'péssimo', 'odioso', 'efetável'] - Define lista de palavras negativas
Linha 7: texto_lower = texto.lower() - Converte texto para minúsculas
Linha 8: score_positivo = sum(1 for palavra in palavras_positivas if palavra in texto_lower) - Conta palavras positivas
Linha 9: score_negativo = sum(1 for palavra in palavras_negativas if palavra in texto_lower) - Conta palavras negativas
Linha 11: if score_positivo > score_negativo: - Verifica se sentimento é positivo
Linha 12: sentimento = "Positivo" - Define sentimento como positivo
Linha 13: porcentagem = min(85, 50 + (score_positivo - score_negativo) * 10) - Calcula porcentagem de confiança

22. Bot de Telegram

def bot_telegram_simulado(comando, parametro):
    """Simula bot de Telegram que responde com informações de APIs"""
    print(f"🤖 BOT TELEGRAM SIMULADO")
    print("=" * 40)
    print(f"Comando recebido: {comando}")
    print(f"Parâmetro: {parametro}")
    print()
    
    if comando == "/cep":
        # Simular busca de CEP
        print(f"📍 Buscando CEP: {parametro}")
        print(f"📍 Resultado: Avenida Paulista, Bela Vista - São Paulo - SP")
        
    elif comando == "/clima":
        # Simular consulta de clima
        print(f"🌤️ Consultando clima: {parametro}")
        print(f"🌤️ Resultado: {parametro} - 25°C, Ensolarado")
        
    elif comando == "/crypto":
        # Simular consulta de criptomoeda
        print(f"💰 Consultando cripto: {parametro}")
        print(f"💰 Resultado: {parametro.title()} - $45,230.50")
        
    elif comando == "/github":
        # Simular consulta do GitHub
        print(f"👤 Consultando GitHub: {parametro}")
        print(f"👤 Resultado: {parametro} - 8 repositórios, 3938 seguidores")
        
    else:
        print("❌ Comando não reconhecido")
        print("📋 Comandos disponíveis: /cep, /clima, /crypto, /github")
    
    print("=" * 40)

# Testando
bot_telegram_simulado("/cep", "01310-100")
bot_telegram_simulado("/clima", "São Paulo")
bot_telegram_simulado("/crypto", "bitcoin")
bot_telegram_simulado("/github", "octocat")

Explicação linha por linha:

Linha 1: def bot_telegram_simulado(comando, parametro): - Define função para simular bot de Telegram
Linha 2: """Simula bot de Telegram que responde com informações de APIs""" - Docstring explicando função
Linha 3: print(f"🤖 BOT TELEGRAM SIMULADO") - Mostra cabeçalho do bot
Linha 4: print("=" * 40) - Imprime linha separadora
Linha 5: print(f"Comando recebido: {comando}") - Mostra comando recebido
Linha 6: print(f"Parâmetro: {parametro}") - Mostra parâmetro do comando
Linha 9: if comando == "/cep": - Verifica se comando é para buscar CEP
Linha 10: # Simular busca de CEP - Comentário explicativo
Linha 11: print(f"📍 Buscando CEP: {parametro}") - Mostra busca de CEP
Linha 12: print(f"📍 Resultado: Avenida Paulista, Bela Vista - São Paulo - SP") - Mostra resultado simulado

23. Sistema de Recomendação

def sistema_recomendacao_filmes(filme_base):
    """Sistema de recomendação de filmes baseado em gênero"""
    # Base de dados simulada de filmes
    filmes = {
        'The Matrix': ['Ação', 'Ficção Científica'],
        'Inception': ['Ação', 'Ficção Científica', 'Thriller'],
        'Interstellar': ['Ficção Científica', 'Drama'],
        'Blade Runner': ['Ficção Científica', 'Thriller'],
        'Avatar': ['Ação', 'Ficção Científica', 'Aventura'],
        'Star Wars': ['Ação', 'Ficção Científica', 'Aventura'],
        'Titanic': ['Romance', 'Drama'],
        'Forrest Gump': ['Drama', 'Comédia'],
        'The Godfather': ['Drama', 'Crime'],
        'Pulp Fiction': ['Crime', 'Thriller']
    }
    
    if filme_base not in filmes:
        print(f"❌ Filme '{filme_base}' não encontrado na base de dados")
        return []
    
    generos_filme = filmes[filme_base]
    recomendacoes = []
    
    for filme, generos in filmes.items():
        if filme != filme_base:
            # Calcula similaridade baseada em gêneros em comum
            generos_comuns = set(generos_filme) & set(generos)
            if generos_comuns:
                score = len(generos_comuns) / len(generos_filme)
                recomendacoes.append((filme, score, list(generos_comuns)))
    
    # Ordena por score (similaridade)
    recomendacoes.sort(key=lambda x: x[1], reverse=True)
    
    print(f"🎬 RECOMENDAÇÕES PARA: {filme_base}")
    print("=" * 50)
    print(f"Gêneros: {', '.join(generos_filme)}")
    print()
    
    for i, (filme, score, generos_comuns) in enumerate(recomendacoes[:5], 1):
        print(f"{i}. {filme} (Similaridade: {score:.1%})")
        print(f"   Gêneros em comum: {', '.join(generos_comuns)}")
    
    print("=" * 50)
    
    return recomendacoes[:5]

# Testando
sistema_recomendacao_filmes('The Matrix')

Explicação linha por linha:

Linha 1: def sistema_recomendacao_filmes(filme_base): - Define função para sistema de recomendação
Linha 2: """Sistema de recomendação de filmes baseado em gênero""" - Docstring explicando função
Linha 3: # Base de dados simulada de filmes - Comentário explicativo
Linhas 4-15: Define dicionário com filmes e seus gêneros
Linha 17: if filme_base not in filmes: - Verifica se filme existe na base
Linha 18: print(f"❌ Filme '{filme_base}' não encontrado na base de dados") - Mostra erro se não encontrado
Linha 19: return [] - Retorna lista vazia se não encontrado
Linha 21: generos_filme = filmes[filme_base] - Obtém gêneros do filme base
Linha 22: recomendacoes = [] - Inicializa lista de recomendações
Linha 24: for filme, generos in filmes.items(): - Percorre todos os filmes
Linha 25: if filme != filme_base: - Verifica se não é o mesmo filme
Linha 26: # Calcula similaridade baseada em gêneros em comum - Comentário explicativo
Linha 27: generos_comuns = set(generos_filme) & set(generos) - Encontra gêneros em comum
Linha 28: if generos_comuns: - Verifica se há gêneros em comum
Linha 29: score = len(generos_comuns) / len(generos_filme) - Calcula score de similaridade
Linha 30: recomendacoes.append((filme, score, list(generos_comuns))) - Adiciona à lista de recomendações

24. Dashboard Web

def dashboard_web_simulado():
    """Simula dashboard web com dados de múltiplas APIs"""
    print("🌐 DASHBOARD WEB - DADOS EM TEMPO REAL")
    print("=" * 60)
    
    # Simular dados de diferentes APIs
    dados_clima = {
        'São Paulo': {'temp': 25, 'condicao': 'Ensolarado'},
        'Rio de Janeiro': {'temp': 28, 'condicao': 'Parcialmente nublado'},
        'Brasília': {'temp': 22, 'condicao': 'Chuvoso'}
    }
    
    dados_crypto = {
        'Bitcoin': {'preco': 45230.50, 'variacao': 2.5},
        'Ethereum': {'preco': 3120.75, 'variacao': -1.2},
        'Litecoin': {'preco': 145.80, 'variacao': 0.8}
    }
    
    dados_noticias = [
        {'titulo': 'Python 3.12 lançado', 'fonte': 'Python.org'},
        {'titulo': 'Nova API do GitHub', 'fonte': 'GitHub Blog'},
        {'titulo': 'Tendências de IA em 2024', 'fonte': 'Tech News'}
    ]
    
    # Seção Clima
    print("🌤️ CLIMA ATUAL")
    print("-" * 30)
    for cidade, dados in dados_clima.items():
        print(f"{cidade}: {dados['temp']}°C - {dados['condicao']}")
    
    print()
    
    # Seção Criptomoedas
    print("💰 CRIPTOMOEDAS")
    print("-" * 30)
    for moeda, dados in dados_crypto.items():
        variacao_emoji = "📈" if dados['variacao'] > 0 else "📉"
        print(f"{moeda}: ${dados['preco']:,.2f} {variacao_emoji} {dados['variacao']:+.1f}%")
    
    print()
    
    # Seção Notícias
    print("📰 NOTÍCIAS RECENTES")
    print("-" * 30)
    for i, noticia in enumerate(dados_noticias, 1):
        print(f"{i}. {noticia['titulo']}")
        print(f"   Fonte: {noticia['fonte']}")
    
    print()
    print("🔄 Atualizado em tempo real")
    print("=" * 60)
    
    return {
        'clima': dados_clima,
        'crypto': dados_crypto,
        'noticias': dados_noticias
    }

# Testando
dashboard_web_simulado()

Explicação linha por linha:

Linha 1: def dashboard_web_simulado(): - Define função para dashboard web simulado
Linha 2: """Simula dashboard web com dados de múltiplas APIs""" - Docstring explicando função
Linha 3: print("🌐 DASHBOARD WEB - DADOS EM TEMPO REAL") - Mostra cabeçalho do dashboard
Linha 4: print("=" * 60) - Imprime linha separadora
Linha 6: # Simular dados de diferentes APIs - Comentário explicativo
Linhas 7-11: Define dados simulados de clima para diferentes cidades
Linhas 13-17: Define dados simulados de criptomoedas
Linhas 19-23: Define dados simulados de notícias
Linha 25: # Seção Clima - Comentário explicativo
Linha 26: print("🌤️ CLIMA ATUAL") - Mostra cabeçalho da seção clima
Linha 27: print("-" * 30) - Imprime linha separadora
Linha 28: for cidade, dados in dados_clima.items(): - Percorre dados de clima
Linha 29: print(f"{cidade}: {dados['temp']}°C - {dados['condicao']}") - Mostra dados de clima

25. Sistema de Automação

def sistema_automacao_workflow():
    """Sistema de automação que integra várias APIs para um workflow completo"""
    print("🤖 SISTEMA DE AUTOMAÇÃO - WORKFLOW COMPLETO")
    print("=" * 60)
    
    # Passo 1: Consultar clima
    print("🌤️ Passo 1: Consultando clima...")
    clima = {'cidade': 'São Paulo', 'temp': 25, 'condicao': 'Ensolarado'}
    print(f"   ✅ Clima consultado: {clima['cidade']} - {clima['temp']}°C - {clima['condicao']}")
    
    # Passo 2: Verificar preços de criptomoedas
    print("💰 Passo 2: Verificando preços de criptomoedas...")
    crypto = {'bitcoin': 45230.50, 'ethereum': 3120.75}
    print(f"   ✅ Preços verificados: Bitcoin ${crypto['bitcoin']:,.2f}, Ethereum ${crypto['ethereum']:,.2f}")
    
    # Passo 3: Buscar notícias
    print("📰 Passo 3: Buscando notícias recentes...")
    noticias = ['Python 3.12 lançado', 'Nova API do GitHub', 'Tendências de IA']
    print(f"   ✅ {len(noticias)} notícias encontradas")
    
    # Passo 4: Enviar email (simulado)
    print("📧 Passo 4: Enviando relatório por email...")
    print("   ✅ Email enviado com sucesso para usuario@email.com")
    
    # Passo 5: Salvar dados
    print("💾 Passo 5: Salvando dados em arquivo...")
    print("   ✅ Dados salvos em relatorio_2024-01-15.json")
    
    # Passo 6: Notificar conclusão
    print("🔔 Passo 6: Enviando notificação...")
    print("   ✅ Notificação enviada: Workflow concluído com sucesso!")
    
    print()
    print("🎉 WORKFLOW EXECUTADO COM SUCESSO!")
    print("=" * 60)
    
    return {
        'clima': clima,
        'crypto': crypto,
        'noticias': noticias,
        'status': 'concluido'
    }

# Testando
sistema_automacao_workflow()

Explicação linha por linha:

Linha 1: def sistema_automacao_workflow(): - Define função para sistema de automação
Linha 2: """Sistema de automação que integra várias APIs para um workflow completo""" - Docstring explicando função
Linha 3: print("🤖 SISTEMA DE AUTOMAÇÃO - WORKFLOW COMPLETO") - Mostra cabeçalho do sistema
Linha 4: print("=" * 60) - Imprime linha separadora
Linha 6: # Passo 1: Consultar clima - Comentário explicativo
Linha 7: print("🌤️ Passo 1: Consultando clima...") - Mostra início do passo 1
Linha 8: clima = {'cidade': 'São Paulo', 'temp': 25, 'condicao': 'Ensolarado'} - Simula dados de clima
Linha 9: print(f" ✅ Clima consultado: {clima['cidade']} - {clima['temp']}°C - {clima['condicao']}") - Mostra resultado do passo 1
Linha 11: # Passo 2: Verificar preços de criptomoedas - Comentário explicativo
Linha 12: print("💰 Passo 2: Verificando preços de criptomoedas...") - Mostra início do passo 2
Linha 13: crypto = {'bitcoin': 45230.50, 'ethereum': 3120.75} - Simula dados de criptomoedas
Linha 14: print(f" ✅ Preços verificados: Bitcoin ${crypto['bitcoin']:,.2f}, Ethereum ${crypto['ethereum']:,.2f}") - Mostra resultado do passo 2

Gabarito

Solução: Informações básicas do GitHub

import requests

def info_github_basica(username):
    url = f'https://api.github.com/users/{username}'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            print(f"Nome: {dados['name']}")
            print(f"Seguidores: {dados['followers']}")
            return dados
        else:
            print(f"Usuário não encontrado: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
info_github_basica('octocat')

Conceitos-chave: requests.get(), tratamento de erros, status codes

12.10 Soluções de Exemplo

12.10.1 Nível 1: Soluções Básicas

Solução 1: Informações básicas do GitHub

import requests

def info_github_basica(username):
    """Busca informações básicas de um usuário do GitHub"""
    url = f'https://api.github.com/users/{username}'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            print(f"Nome: {dados['name']}")
            print(f"Seguidores: {dados['followers']}")
            return dados
        else:
            print(f"Usuário não encontrado: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
info_github_basica('octocat')

Solução 2: Buscar CEP específico

def buscar_cep_especifico():
    """Busca o CEP 20040-020 (Rio de Janeiro)"""
    cep = '20040-020'
    url = f'https://viacep.com.br/ws/{cep}/json/'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            print(f"📍 {dados['logradouro']}, {dados['bairro']}")
            print(f"📍 {dados['localidade']} - {dados['uf']}")
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
buscar_cep_especifico()

Solução 3: Preço do Bitcoin

def preco_bitcoin():
    """Consulta preço atual do Bitcoin"""
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {'ids': 'bitcoin', 'vs_currencies': 'usd,brl'}
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            preco_usd = dados['bitcoin']['usd']
            preco_brl = dados['bitcoin']['brl']
            
            print(f"💰 Bitcoin")
            print(f"💵 USD: ${preco_usd:,.2f}")
            print(f"🇧🇷 BRL: R$ {preco_brl:,.2f}")
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
preco_bitcoin()

12.10.2 Nível 2: Soluções Intermediárias

Solução 6: Conversor de CEP formatado

def conversor_cep_formatado(cep):
    """Busca CEP e formata de forma bonita"""
    url = f'https://viacep.com.br/ws/{cep}/json/'
    
    try:
        response = requests.get(url)
        if response.status_code == 200:
            dados = response.json()
            
            if 'erro' not in dados:
                print("=" * 50)
                print(f"📍 ENDEREÇO ENCONTRADO")
                print("=" * 50)
                print(f"CEP: {dados['cep']}")
                print(f"Logradouro: {dados['logradouro']}")
                print(f"Bairro: {dados['bairro']}")
                print(f"Cidade: {dados['localidade']}")
                print(f"Estado: {dados['uf']}")
                print("=" * 50)
                return dados
            else:
                print(f"❌ CEP {cep} não encontrado")
                return None
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
conversor_cep_formatado('01310-100')

Solução 7: Comparar Bitcoin e Ethereum

def comparar_criptos():
    """Compara preços de Bitcoin e Ethereum"""
    url = 'https://api.coingecko.com/api/v3/simple/price'
    params = {
        'ids': 'bitcoin,ethereum',
        'vs_currencies': 'usd,brl'
    }
    
    try:
        response = requests.get(url, params=params)
        if response.status_code == 200:
            dados = response.json()
            
            btc_usd = dados['bitcoin']['usd']
            btc_brl = dados['bitcoin']['brl']
            eth_usd = dados['ethereum']['usd']
            eth_brl = dados['ethereum']['brl']
            
            print("💰 COMPARAÇÃO DE CRIPTOMOEDAS")
            print("=" * 40)
            print(f"Bitcoin:  ${btc_usd:,.2f} | R$ {btc_brl:,.2f}")
            print(f"Ethereum: ${eth_usd:,.2f} | R$ {eth_brl:,.2f}")
            print("=" * 40)
            
            return dados
        else:
            print(f"Erro: {response.status_code}")
            return None
    except requests.exceptions.RequestException as e:
        print(f"Erro de conexão: {e}")
        return None

# Testando
comparar_criptos()

💡 Dica: Continue praticando com os exercícios dos níveis mais altos! Cada solução te ensina técnicas mais avançadas de consumo de APIs.

12.11 Próximos Passos: Continue Aprendendo!

Parabéns! Você agora domina o consumo de APIs REST com Python! 🎉

12.11.1 O que você aprendeu:

✅ Conceito de APIs: Como funcionam as interfaces de programação
✅ Requisições HTTP: Como fazer chamadas para APIs usando requests
✅ Status codes: Como interpretar respostas HTTP
✅ Trabalhando com JSON: Como processar dados retornados
✅ Tratamento de erros: Como lidar com problemas nas requisições
✅ APIs públicas: ViaCEP, GitHub, CoinGecko, JSONPlaceholder
✅ Projetos práticos: Aplicações que consomem dados da internet

12.11.2 Desafios para Continuar:

Explore mais APIs: Teste APIs de redes sociais, e-commerce, notícias
Crie projetos reais: Desenvolva aplicações que usam múltiplas APIs
Automatize tarefas: Use APIs para automatizar processos do dia a dia
Contribua com código aberto: Encontre projetos que consomem APIs

12.11.3 Próximo Capítulo:

No Capítulo 13, vamos aprender sobre APIs - Parte 2 (Criando suas APIs)! Você vai descobrir como:

Criar suas próprias APIs usando Flask
Implementar endpoints REST
Criar APIs de exemplo (lista de tarefas)
Testar APIs com navegador e Postman
Implementar boas práticas de desenvolvimento

🎯 batel.tech: Quer praticar mais? Acesse batel.tech e encontre projetos práticos para aplicar seus conhecimentos de consumo de APIs! Lá você pode colaborar com outros desenvolvedores e construir aplicações incríveis que se conectam com o mundo!

12.12 Referências Bibliográficas

Requests Documentation: Python HTTP Library
HTTP Status Codes: MDN Web Docs
JSON.org: JSON Data Format
REST API Tutorial: REST API Best Practices
GitHub API: GitHub REST API Documentation

Capítulo 12 concluído! 🎉 Agora você está pronto para consumir APIs e criar aplicações conectadas com o mundo. No próximo capítulo, vamos aprender a criar nossas próprias APIs!

12.1 O que você vai aprender neste capítulo?

12.1.1 Fluxo de uma Requisição HTTP

12.2 De Pedir Comida por Delivery para Consumir APIs

12.2.1 Analogia Perfeita: Delivery de Comida

12.2.2 O que são APIs?

12.2.3 Tipos de APIs que vamos usar

12.3 Fazendo sua Primeira Requisição HTTP

12.3.1 Instalando a biblioteca requests

12.3.2 Primeira requisição: Buscar informações de um usuário do GitHub

12.3.3 Entendendo a resposta

12.4 Status Codes - Entendendo as Respostas

12.4.1 O que são Status Codes?

12.4.2 Principais Status Codes

12.4.3 Exemplo prático com tratamento de erros

12.4.4 Testando diferentes cenários

12.5 APIs Públicas Práticas - Conectando com o Mundo Real

12.5.1 ViaCEP - Buscar endereço por CEP

12.5.2 OpenWeatherMap - Consultar clima

12.5.3 CoinGecko - Preços de criptomoedas

12.5.4 JSONPlaceholder - API de teste

12.6 Exercícios Práticos (respostas no final da página)

12.6.1 MUITO FÁCIL (Nível 1)

12.6.2 FÁCIL (Nível 2)

12.6.3 MÉDIO (Nível 3)

12.6.4 DIFÍCIL (Nível 4)

12.6.5 MUITO DIFÍCIL (Nível 5)

12.7 Respostas e Explicações

12.7.1 MUITO FÁCIL (Nível 1)

12.7.2 FÁCIL (Nível 2)

12.7.3 MÉDIO (Nível 3)

12.7.4 DIFÍCIL (Nível 4)

12.8 Módulo time - Controlando Tempo e Delays

12.8.1 O que é o módulo time?

12.8.2 Importando o módulo time

12.8.3 Principais Funções do módulo time

12.8.3.1 1. time.sleep(segundos) - Criar delays

12.8.3.2 2. time.time() - Obter timestamp

12.8.4 Exemplos Práticos

12.8.4.1 1. Monitoramento com delays

12.8.4.2 2. Medir tempo de requisições

12.8.4.3 3. Sistema de alertas com delays

12.8.4.4 4. Controle de taxa de requisições

12.8.5 Exemplos dos Exercícios

12.8.6 Dicas Importantes

12.8.7 Quando Usar o módulo time

12.9 Automação e Monitoramento Contínuo - Loops Infinitos e Sistemas de Alerta

12.9.1 O que é Automação e Monitoramento?

12.9.2 Loops Infinitos Controlados

12.9.2.1 Estrutura básica com while True:

12.9.2.2 Loop com condição de parada

12.9.3 Sistemas de Alerta

12.9.3.1 1. Sistema de alertas simples

12.9.3.2 2. Sistema de monitoramento de API

12.9.4 Controle de Execução

12.9.4.1 1. Parar com tecla específica

12.9.4.2 2. Sistema com horário de funcionamento

12.9.5 Exemplos dos Exercícios

12.9.6 Dicas Importantes

12.9.7 Quando Usar Automação e Monitoramento

12.9.8 MUITO DIFÍCIL (Nível 5)

12.10 Soluções de Exemplo

12.10.1 Nível 1: Soluções Básicas

12.10.2 Nível 2: Soluções Intermediárias

12.11 Próximos Passos: Continue Aprendendo!

12.11.1 O que você aprendeu:

12.11.2 Desafios para Continuar:

12.11.3 Próximo Capítulo:

12.12 Referências Bibliográficas

12.3.1 Instalando a biblioteca `requests`

12.8 Módulo `time` - Controlando Tempo e Delays

12.8.1 O que é o módulo `time`?

12.8.3.1 1. `time.sleep(segundos)` - Criar delays

12.8.3.2 2. `time.time()` - Obter timestamp

12.9.2.1 Estrutura básica com `while True:`