13  APIs - Parte 2: Criando suas APIs com Flask

De consumir APIs para criar suas próprias: você virando o restaurante!

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

1. O que é Flask e como funciona na prática
2. Seu primeiro servidor: criando um “Hello World” web
3. Rotas e decoradores: como criar endpoints com @app.route()
4. Retornando JSON: como usar jsonify() para APIs
5. Métodos HTTP: GET, POST, PUT, DELETE em prática
6. Parâmetros de URL: como receber dados na URL
7. API completa: sistema de lista de tarefas funcionando
8. Boas práticas: status codes, validação e tratamento de erros

🎓 Vindo do Capítulo 12? Perfeito! Agora que você sabe consumir APIs, vamos criar as nossas próprias!

🎯 Meta: Ao final deste capítulo, você vai conseguir criar APIs REST completas usando Flask e implementar sistemas web funcionais.

⚠️ Por que isso importa: Criar APIs é como abrir seu próprio restaurante! Você define o cardápio (endpoints), prepara os pratos (lógica) e serve os clientes (requisições). Aqui você aprende a ser o chef!

13.2 De Cliente para Chef: Criando suas Próprias APIs

13.2.1 Analogia Perfeita: Você virando o Restaurante

No capítulo anterior, você era o cliente pedindo comida por delivery. Agora você vai ser o chef criando seu próprio restaurante!

Comparação:

Consumindo APIs (Cap 12)	Criando APIs (Cap 13)
🍕 Cliente pedindo pizza	👨‍🍳 Chef preparando pizza
📱 App fazendo requisições	🏪 Restaurante recebendo pedidos
📋 Cardápio de outros	📋 Seu próprio cardápio
🍽️ Recebendo comida	🍽️ Servindo comida

13.2.2 O que é Flask?

Flask é um framework web para Python. É como ter uma cozinha equipada para criar APIs:

• 🔧 Framework: Conjunto de ferramentas prontas
• 🌐 Web: Para criar aplicações que funcionam na internet
• 🐍 Python: Usa a linguagem que você já conhece
• ⚡ Simples: Fácil de aprender e usar

13.2.3 Por que Flask?

• ✅ Simples: Poucas linhas para criar uma API
• ✅ Flexível: Você controla tudo
• ✅ Popular: Muito usado na indústria
• ✅ Documentação: Bem documentado e com comunidade ativa

💡 Exemplo: Instagram, Netflix e Pinterest usam Flask (ou frameworks similares) para suas APIs!

13.3 Seu Primeiro Servidor Flask

13.3.1 Instalando o Flask

pip install flask

13.3.2 Primeiro servidor: “Hello World”

from flask import Flask

# Criar a aplicação Flask
app = Flask(__name__)

# Definir uma rota (endpoint)
@app.route('/')
def hello_world():
    return 'Hello, World!'

# Executar o servidor
if __name__ == '__main__':
    app.run(debug=True)

13.3.3 Executando o servidor

Salve o código em um arquivo app.py e execute:

python app.py

Saída esperada:

 * Running on http://127.0.0.1:5000
 * Debug mode: on

13.3.4 Testando sua API

1. Abra o navegador e vá para http://127.0.0.1:5000
2. Você verá: “Hello, World!”
3. Parabéns! Sua primeira API está funcionando! 🎉

13.3.5 Entendendo o código

from flask import Flask          # Importar Flask
app = Flask(__name__)            # Criar aplicação

@app.route('/')                 # Decorador: define a rota
def hello_world():              # Função que responde
    return 'Hello, World!'      # Retorna texto

if __name__ == '__main__':       # Só executa se rodar diretamente
    app.run(debug=True)         # Inicia servidor em modo debug

13.3.6 Criando mais rotas

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return 'Página inicial!'

@app.route('/sobre')
def sobre():
    return 'Esta é a página sobre!'

@app.route('/contato')
def contato():
    return 'Entre em contato conosco!'

if __name__ == '__main__':
    app.run(debug=True)

Teste no navegador:

• http://127.0.0.1:5000/ → “Página inicial!”
• http://127.0.0.1:5000/sobre → “Esta é a página sobre!”
• http://127.0.0.1:5000/contato → “Entre em contato conosco!”

💡 Dica: O debug=True faz o servidor reiniciar automaticamente quando você modifica o código!

13.4 Retornando JSON - Criando APIs Verdadeiras

13.4.1 Convertendo para API REST

from flask import Flask, jsonify

app = Flask(__name__)

# Retornar dados em formato JSON
@app.route('/api/usuario')
def get_usuario():
    usuario = {
        'nome': 'João Silva',
        'idade': 30,
        'email': 'joao@email.com',
        'cidade': 'São Paulo'
    }
    return jsonify(usuario)

# Retornar lista de dados
@app.route('/api/produtos')
def get_produtos():
    produtos = [
        {'id': 1, 'nome': 'Notebook', 'preco': 2500.00},
        {'id': 2, 'nome': 'Mouse', 'preco': 50.00},
        {'id': 3, 'nome': 'Teclado', 'preco': 120.00}
    ]
    return jsonify(produtos)

if __name__ == '__main__':
    app.run(debug=True)

13.4.2 API de Lista de Tarefas Completa

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
tarefas = [
    {'id': 1, 'titulo': 'Estudar Python', 'concluida': False},
    {'id': 2, 'titulo': 'Fazer exercícios', 'concluida': True},
    {'id': 3, 'titulo': 'Ler documentação', 'concluida': False}
]

# GET /api/tarefas - Listar todas as tarefas
@app.route('/api/tarefas', methods=['GET'])
def listar_tarefas():
    return jsonify(tarefas)

# GET /api/tarefas/<id> - Buscar tarefa específica
@app.route('/api/tarefas/<int:tarefa_id>', methods=['GET'])
def buscar_tarefa(tarefa_id):
    for tarefa in tarefas:
        if tarefa['id'] == tarefa_id:
            return jsonify(tarefa)
    return jsonify({'erro': 'Tarefa não encontrada'}), 404

# POST /api/tarefas - Criar nova tarefa
@app.route('/api/tarefas', methods=['POST'])
def criar_tarefa():
    dados = request.get_json()
    
    nova_tarefa = {
        'id': len(tarefas) + 1,
        'titulo': dados['titulo'],
        'concluida': False
    }
    
    tarefas.append(nova_tarefa)
    return jsonify(nova_tarefa), 201

# PUT /api/tarefas/<id> - Atualizar tarefa
@app.route('/api/tarefas/<int:tarefa_id>', methods=['PUT'])
def atualizar_tarefa(tarefa_id):
    dados = request.get_json()
    
    for tarefa in tarefas:
        if tarefa['id'] == tarefa_id:
            tarefa['titulo'] = dados.get('titulo', tarefa['titulo'])
            tarefa['concluida'] = dados.get('concluida', tarefa['concluida'])
            return jsonify(tarefa)
    
    return jsonify({'erro': 'Tarefa não encontrada'}), 404

# DELETE /api/tarefas/<id> - Deletar tarefa
@app.route('/api/tarefas/<int:tarefa_id>', methods=['DELETE'])
def deletar_tarefa(tarefa_id):
    for i, tarefa in enumerate(tarefas):
        if tarefa['id'] == tarefa_id:
            tarefas.pop(i)
            return jsonify({'mensagem': 'Tarefa deletada com sucesso'})
    
    return jsonify({'erro': 'Tarefa não encontrada'}), 404

if __name__ == '__main__':
    app.run(debug=True)

13.4.3 Testando sua API

1. Listar tarefas:

curl http://127.0.0.1:5000/api/tarefas

2. Criar nova tarefa:

curl -X POST http://127.0.0.1:5000/api/tarefas \
  -H "Content-Type: application/json" \
  -d '{"titulo": "Nova tarefa"}'

3. Atualizar tarefa:

curl -X PUT http://127.0.0.1:5000/api/tarefas/1 \
  -H "Content-Type: application/json" \
  -d '{"concluida": true}'

💡 Parabéns! Você criou uma API REST completa com operações CRUD (Create, Read, Update, Delete)!

13.5 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!

13.5.1 MUITO FÁCIL (Nível 1)

1. API Pessoal Crie uma API simples que retorna informações sobre você em JSON.

• Exemplo: GET /api/pessoal | Output → {"nome": "João", "idade": 25, "cidade": "São Paulo"}

2. API de Hora Crie uma rota /api/hora que retorna a hora atual.

• Exemplo: GET /api/hora | Output → {"hora": "14:30:25", "data": "2024-01-15"}

3. API de Números Crie uma rota /api/numeros que retorna uma lista de números de 1 a 10.

• Exemplo: GET /api/numeros | Output → [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4. API de Soma Crie uma rota /api/soma/<a>/<b> que soma dois números.

• Exemplo: GET /api/soma/5/3 | Output → {"resultado": 8}

5. API de Número Aleatório Crie uma rota /api/aleatorio que retorna um número aleatório entre 1 e 100.

• Exemplo: GET /api/aleatorio | Output → {"numero": 42}

13.5.2 FÁCIL (Nível 2)

6. API de Agenda Crie uma API de agenda de contatos com operações básicas.

• Exemplo: GET /api/contatos | Output → [{"id": 1, "nome": "João", "telefone": "11999999999"}]

7. API de Produtos Crie uma API de produtos de loja com nome, preço e categoria.

• Exemplo: GET /api/produtos | Output → [{"id": 1, "nome": "Notebook", "preco": 2500.00, "categoria": "Eletrônicos"}]

8. API de Notas Escolares Crie uma API de notas escolares com aluno, matéria e nota.

• Exemplo: GET /api/notas | Output → [{"aluno": "Ana", "materia": "Matemática", "nota": 8.5}]

9. API de Biblioteca Crie uma API de biblioteca com livros, autores e status de empréstimo.

• Exemplo: GET /api/livros | Output → [{"titulo": "Python para Iniciantes", "autor": "João Silva", "emprestado": false}]

10. API de Receitas Crie uma API de receitas culinárias com ingredientes e modo de preparo.

• Exemplo: GET /api/receitas | Output → [{"nome": "Bolo de Chocolate", "ingredientes": ["farinha", "açúcar", "chocolate"], "preparo": "Misture todos os ingredientes"}]

13.5.3 MÉDIO (Nível 3)

11. API de Sistema de Vendas Crie uma API de sistema de vendas com clientes, produtos e pedidos.

• Exemplo: GET /api/vendas | Output → [{"cliente": "João", "produto": "Notebook", "valor": 2500.00, "data": "2024-01-15"}]

12. API de Gerenciamento de Projetos Crie uma API de gerenciamento de projetos com tarefas e responsáveis.

• Exemplo: GET /api/projetos | Output → [{"nome": "Sistema Web", "tarefa": "Desenvolver API", "responsavel": "Ana", "status": "Em andamento"}]

13. API de Blog Crie uma API de blog com posts, comentários e categorias.

• Exemplo: GET /api/posts | Output → [{"titulo": "Introdução ao Flask", "categoria": "Python", "comentarios": 5}]

14. API de Academia Crie uma API de academia com alunos, treinos e exercícios.

• Exemplo: GET /api/treinos | Output → [{"aluno": "João", "exercicio": "Supino", "series": 3, "repeticoes": 12}]

15. API de Restaurante Crie uma API de restaurante com cardápio, pedidos e mesas.

• Exemplo: GET /api/cardapio | Output → [{"prato": "Pizza Margherita", "preco": 35.00, "categoria": "Pizzas"}]

13.5.4 DIFÍCIL (Nível 4)

16. API de E-commerce Crie uma API de e-commerce completa com carrinho de compras.

• Exemplo: POST /api/carrinho | Input → {"produto_id": 1, "quantidade": 2} | Output → {"total": 5000.00}

17. API de Rede Social Crie uma API de rede social com usuários, posts e seguidores.

• Exemplo: GET /api/usuarios/1/posts | Output → [{"conteudo": "Aprendendo Flask!", "likes": 15, "comentarios": 3}]

18. API de Sistema Bancário Crie uma API de sistema bancário com contas e transações.

• Exemplo: POST /api/transacoes | Input → {"conta_origem": 123, "conta_destino": 456, "valor": 100.00} | Output → {"status": "Sucesso"}

19. API de Hotel Crie uma API de hotel com reservas, quartos e hóspedes.

• Exemplo: GET /api/reservas | Output → [{"hospede": "João Silva", "quarto": "101", "checkin": "2024-01-15", "checkout": "2024-01-20"}]

20. API de Escola Crie uma API de escola com alunos, professores e disciplinas.

• Exemplo: GET /api/disciplinas | Output → [{"nome": "Matemática", "professor": "Ana Santos", "alunos": 30}]

13.5.5 MUITO DIFÍCIL (Nível 5)

21. API de Marketplace Crie uma API de marketplace com vendedores, compradores e produtos.

• Exemplo: GET /api/vendedores/1/produtos | Output → [{"nome": "Notebook", "preco": 2500.00, "estoque": 10}]

22. API de Sistema de Delivery Crie uma API de sistema de delivery com restaurantes e entregadores.

• Exemplo: POST /api/pedidos | Input → {"restaurante": "Pizza Hut", "entregador": "João", "endereco": "Rua A, 123"} | Output → {"pedido_id": 123, "tempo_estimado": 30}

23. API de Streaming Crie uma API de streaming com usuários, conteúdo e assinaturas.

• Exemplo: GET /api/conteudo | Output → [{"titulo": "Filme A", "genero": "Ação", "disponivel": true, "assinatura_necessaria": "Premium"}]

24. API de Sistema de Saúde Crie uma API de sistema de saúde com pacientes e consultas.

• Exemplo: GET /api/consultas | Output → [{"paciente": "João Silva", "medico": "Dr. Ana", "data": "2024-01-20", "especialidade": "Cardiologia"}]

25. API de Sistema de Transporte Crie uma API de sistema de transporte com rotas e passageiros.

• Exemplo: GET /api/rotas | Output → [{"origem": "São Paulo", "destino": "Rio de Janeiro", "distancia": 430, "tempo_estimado": "5h30min"}]

---

13.6 Respostas e Explicações

13.6.1 MUITO FÁCIL (Nível 1)

1. API Pessoal

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/pessoal')
def info_pessoal():
    """Retorna informações pessoais em JSON"""
    dados = {
        'nome': 'João Silva',
        'idade': 25,
        'cidade': 'São Paulo',
        'profissao': 'Desenvolvedor Python'
    }
    return jsonify(dados)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify - Importa Flask e jsonify para criar API e retornar JSON
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: @app.route('/api/pessoal') - Define rota para endpoint /api/pessoal
• Linha 6: def info_pessoal(): - Define função que será executada quando a rota for acessada
• Linha 7: """Retorna informações pessoais em JSON""" - Docstring explicando função
• Linhas 8-13: Define dicionário com informações pessoais
• Linha 14: return jsonify(dados) - Converte dicionário para JSON e retorna
• Linha 16: if __name__ == '__main__': - Verifica se arquivo está sendo executado diretamente
• Linha 17: app.run(debug=True) - Inicia servidor Flask em modo debug

2. API de Hora

from flask import Flask, jsonify
from datetime import datetime

app = Flask(__name__)

@app.route('/api/hora')
def hora_atual():
    """Retorna hora atual em JSON"""
    agora = datetime.now()
    dados = {
        'hora': agora.strftime('%H:%M:%S'),
        'data': agora.strftime('%Y-%m-%d'),
        'timestamp': agora.timestamp()
    }
    return jsonify(dados)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify - Importa Flask e jsonify
• Linha 2: from datetime import datetime - Importa datetime para trabalhar com datas
• Linha 4: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 6: @app.route('/api/hora') - Define rota para endpoint /api/hora
• Linha 7: def hora_atual(): - Define função para retornar hora atual
• Linha 8: """Retorna hora atual em JSON""" - Docstring explicando função
• Linha 9: agora = datetime.now() - Obtém data e hora atuais
• Linhas 10-14: Define dicionário com hora, data e timestamp formatados
• Linha 15: return jsonify(dados) - Retorna dados em formato JSON

3. API de Números

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/numeros')
def lista_numeros():
    """Retorna lista de números de 1 a 10"""
    numeros = list(range(1, 11))
    return jsonify(numeros)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify - Importa Flask e jsonify
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: @app.route('/api/numeros') - Define rota para endpoint /api/numeros
• Linha 6: def lista_numeros(): - Define função para retornar lista de números
• Linha 7: """Retorna lista de números de 1 a 10""" - Docstring explicando função
• Linha 8: numeros = list(range(1, 11)) - Cria lista de números de 1 a 10
• Linha 9: return jsonify(numeros) - Retorna lista em formato JSON

4. API de Soma

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/soma/<int:a>/<int:b>')
def somar_numeros(a, b):
    """Soma dois números recebidos como parâmetros na URL"""
    resultado = a + b
    return jsonify({'resultado': resultado})

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify - Importa Flask e jsonify
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: @app.route('/api/soma/<int:a>/<int:b>') - Define rota com parâmetros de URL (a e b como inteiros)
• Linha 6: def somar_numeros(a, b): - Define função que recebe parâmetros a e b
• Linha 7: """Soma dois números recebidos como parâmetros na URL""" - Docstring explicando função
• Linha 8: resultado = a + b - Calcula soma dos dois números
• Linha 9: return jsonify({'resultado': resultado}) - Retorna resultado em formato JSON

5. API de Número Aleatório

from flask import Flask, jsonify
import random

app = Flask(__name__)

@app.route('/api/aleatorio')
def numero_aleatorio():
    """Retorna um número aleatório entre 1 e 100"""
    numero = random.randint(1, 100)
    return jsonify({'numero': numero})

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify - Importa Flask e jsonify
• Linha 2: import random - Importa módulo random para gerar números aleatórios
• Linha 4: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 6: @app.route('/api/aleatorio') - Define rota para endpoint /api/aleatorio
• Linha 7: def numero_aleatorio(): - Define função para gerar número aleatório
• Linha 8: """Retorna um número aleatório entre 1 e 100""" - Docstring explicando função
• Linha 9: numero = random.randint(1, 100) - Gera número aleatório entre 1 e 100
• Linha 10: return jsonify({'numero': numero}) - Retorna número em formato JSON

13.6.2 FÁCIL (Nível 2)

6. API de Agenda

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
contatos = [
    {'id': 1, 'nome': 'João Silva', 'telefone': '11999999999', 'email': 'joao@email.com'},
    {'id': 2, 'nome': 'Maria Santos', 'telefone': '11888888888', 'email': 'maria@email.com'}
]

@app.route('/api/contatos', methods=['GET'])
def listar_contatos():
    """Lista todos os contatos"""
    return jsonify(contatos)

@app.route('/api/contatos', methods=['POST'])
def adicionar_contato():
    """Adiciona um novo contato"""
    dados = request.get_json()
    novo_contato = {
        'id': len(contatos) + 1,
        'nome': dados['nome'],
        'telefone': dados['telefone'],
        'email': dados['email']
    }
    contatos.append(novo_contato)
    return jsonify(novo_contato), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request para trabalhar com dados
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de contatos simulando banco de dados
• Linha 11: @app.route('/api/contatos', methods=['GET']) - Define rota GET para listar contatos
• Linha 12: def listar_contatos(): - Define função para listar contatos
• Linha 13: """Lista todos os contatos""" - Docstring explicando função
• Linha 14: return jsonify(contatos) - Retorna lista de contatos em JSON
• Linha 16: @app.route('/api/contatos', methods=['POST']) - Define rota POST para adicionar contato
• Linha 17: def adicionar_contato(): - Define função para adicionar contato
• Linha 18: """Adiciona um novo contato""" - Docstring explicando função
• Linha 19: dados = request.get_json() - Obtém dados JSON enviados na requisição

7. API de Produtos

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
produtos = [
    {'id': 1, 'nome': 'Notebook', 'preco': 2500.00, 'categoria': 'Eletrônicos'},
    {'id': 2, 'nome': 'Mouse', 'preco': 50.00, 'categoria': 'Acessórios'},
    {'id': 3, 'nome': 'Teclado', 'preco': 120.00, 'categoria': 'Acessórios'}
]

@app.route('/api/produtos', methods=['GET'])
def listar_produtos():
    """Lista todos os produtos"""
    return jsonify(produtos)

@app.route('/api/produtos', methods=['POST'])
def adicionar_produto():
    """Adiciona um novo produto"""
    dados = request.get_json()
    novo_produto = {
        'id': len(produtos) + 1,
        'nome': dados['nome'],
        'preco': dados['preco'],
        'categoria': dados['categoria']
    }
    produtos.append(novo_produto)
    return jsonify(novo_produto), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de produtos simulando banco de dados
• Linha 12: @app.route('/api/produtos', methods=['GET']) - Define rota GET para listar produtos
• Linha 13: def listar_produtos(): - Define função para listar produtos
• Linha 14: """Lista todos os produtos""" - Docstring explicando função
• Linha 15: return jsonify(produtos) - Retorna lista de produtos em JSON
• Linha 17: @app.route('/api/produtos', methods=['POST']) - Define rota POST para adicionar produto
• Linha 18: def adicionar_produto(): - Define função para adicionar produto
• Linha 19: """Adiciona um novo produto""" - Docstring explicando função
• Linha 20: dados = request.get_json() - Obtém dados JSON enviados na requisição

8. API de Notas Escolares

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
notas = [
    {'id': 1, 'aluno': 'Ana Silva', 'materia': 'Matemática', 'nota': 8.5},
    {'id': 2, 'aluno': 'João Santos', 'materia': 'Português', 'nota': 7.0},
    {'id': 3, 'aluno': 'Maria Costa', 'materia': 'História', 'nota': 9.2}
]

@app.route('/api/notas', methods=['GET'])
def listar_notas():
    """Lista todas as notas"""
    return jsonify(notas)

@app.route('/api/notas', methods=['POST'])
def adicionar_nota():
    """Adiciona uma nova nota"""
    dados = request.get_json()
    nova_nota = {
        'id': len(notas) + 1,
        'aluno': dados['aluno'],
        'materia': dados['materia'],
        'nota': dados['nota']
    }
    notas.append(nova_nota)
    return jsonify(nova_nota), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de notas simulando banco de dados
• Linha 12: @app.route('/api/notas', methods=['GET']) - Define rota GET para listar notas
• Linha 13: def listar_notas(): - Define função para listar notas
• Linha 14: """Lista todas as notas""" - Docstring explicando função
• Linha 15: return jsonify(notas) - Retorna lista de notas em JSON
• Linha 17: @app.route('/api/notas', methods=['POST']) - Define rota POST para adicionar nota
• Linha 18: def adicionar_nota(): - Define função para adicionar nota
• Linha 19: """Adiciona uma nova nota""" - Docstring explicando função
• Linha 20: dados = request.get_json() - Obtém dados JSON enviados na requisição

9. API de Biblioteca

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
livros = [
    {'id': 1, 'titulo': 'Python para Iniciantes', 'autor': 'João Silva', 'emprestado': False},
    {'id': 2, 'titulo': 'Flask Web Development', 'autor': 'Maria Santos', 'emprestado': True},
    {'id': 3, 'titulo': 'Django by Example', 'autor': 'Pedro Costa', 'emprestado': False}
]

@app.route('/api/livros', methods=['GET'])
def listar_livros():
    """Lista todos os livros"""
    return jsonify(livros)

@app.route('/api/livros/<int:livro_id>/emprestar', methods=['PUT'])
def emprestar_livro(livro_id):
    """Empresta um livro"""
    for livro in livros:
        if livro['id'] == livro_id:
            if livro['emprestado']:
                return jsonify({'erro': 'Livro já está emprestado'}), 400
            livro['emprestado'] = True
            return jsonify(livro)
    return jsonify({'erro': 'Livro não encontrado'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de livros simulando banco de dados
• Linha 12: @app.route('/api/livros', methods=['GET']) - Define rota GET para listar livros
• Linha 13: def listar_livros(): - Define função para listar livros
• Linha 14: """Lista todos os livros""" - Docstring explicando função
• Linha 15: return jsonify(livros) - Retorna lista de livros em JSON
• Linha 17: @app.route('/api/livros/<int:livro_id>/emprestar', methods=['PUT']) - Define rota PUT para emprestar livro
• Linha 18: def emprestar_livro(livro_id): - Define função para emprestar livro
• Linha 19: """Empresta um livro""" - Docstring explicando função
• Linha 20: for livro in livros: - Percorre lista de livros
• Linha 21: if livro['id'] == livro_id: - Verifica se ID do livro corresponde ao solicitado

10. API de Receitas

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
receitas = [
    {
        'id': 1,
        'nome': 'Bolo de Chocolate',
        'ingredientes': ['farinha', 'açúcar', 'chocolate', 'ovos', 'manteiga'],
        'preparo': 'Misture todos os ingredientes e asse por 30 minutos',
        'tempo_preparo': 45
    },
    {
        'id': 2,
        'nome': 'Pizza Margherita',
        'ingredientes': ['massa', 'molho de tomate', 'mozzarella', 'manjericão'],
        'preparo': 'Monte a pizza e asse por 15 minutos',
        'tempo_preparo': 30
    }
]

@app.route('/api/receitas', methods=['GET'])
def listar_receitas():
    """Lista todas as receitas"""
    return jsonify(receitas)

@app.route('/api/receitas', methods=['POST'])
def adicionar_receita():
    """Adiciona uma nova receita"""
    dados = request.get_json()
    nova_receita = {
        'id': len(receitas) + 1,
        'nome': dados['nome'],
        'ingredientes': dados['ingredientes'],
        'preparo': dados['preparo'],
        'tempo_preparo': dados['tempo_preparo']
    }
    receitas.append(nova_receita)
    return jsonify(nova_receita), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-20: Define lista de receitas simulando banco de dados
• Linha 22: @app.route('/api/receitas', methods=['GET']) - Define rota GET para listar receitas
• Linha 23: def listar_receitas(): - Define função para listar receitas
• Linha 24: """Lista todas as receitas""" - Docstring explicando função
• Linha 25: return jsonify(receitas) - Retorna lista de receitas em JSON
• Linha 27: @app.route('/api/receitas', methods=['POST']) - Define rota POST para adicionar receita
• Linha 28: def adicionar_receita(): - Define função para adicionar receita
• Linha 29: """Adiciona uma nova receita""" - Docstring explicando função
• Linha 30: dados = request.get_json() - Obtém dados JSON enviados na requisição

13.6.3 MÉDIO (Nível 3)

11. API de Sistema de Vendas

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
vendas = [
    {'id': 1, 'cliente': 'João Silva', 'produto': 'Notebook', 'valor': 2500.00, 'data': '2024-01-15'},
    {'id': 2, 'cliente': 'Maria Santos', 'produto': 'Mouse', 'valor': 50.00, 'data': '2024-01-16'}
]

@app.route('/api/vendas', methods=['GET'])
def listar_vendas():
    """Lista todas as vendas"""
    return jsonify(vendas)

@app.route('/api/vendas', methods=['POST'])
def registrar_venda():
    """Registra uma nova venda"""
    dados = request.get_json()
    nova_venda = {
        'id': len(vendas) + 1,
        'cliente': dados['cliente'],
        'produto': dados['produto'],
        'valor': dados['valor'],
        'data': dados['data']
    }
    vendas.append(nova_venda)
    return jsonify(nova_venda), 201

@app.route('/api/vendas/<int:venda_id>', methods=['GET'])
def buscar_venda(venda_id):
    """Busca uma venda específica"""
    for venda in vendas:
        if venda['id'] == venda_id:
            return jsonify(venda)
    return jsonify({'erro': 'Venda não encontrada'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de vendas simulando banco de dados
• Linha 11: @app.route('/api/vendas', methods=['GET']) - Define rota GET para listar vendas
• Linha 12: def listar_vendas(): - Define função para listar vendas
• Linha 13: """Lista todas as vendas""" - Docstring explicando função
• Linha 14: return jsonify(vendas) - Retorna lista de vendas em JSON
• Linha 16: @app.route('/api/vendas', methods=['POST']) - Define rota POST para registrar venda
• Linha 17: def registrar_venda(): - Define função para registrar venda
• Linha 18: """Registra uma nova venda""" - Docstring explicando função
• Linha 19: dados = request.get_json() - Obtém dados JSON enviados na requisição

12. API de Gerenciamento de Projetos

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
projetos = [
    {
        'id': 1,
        'nome': 'Sistema Web',
        'tarefas': [
            {'id': 1, 'nome': 'Desenvolver API', 'responsavel': 'Ana', 'status': 'Em andamento'},
            {'id': 2, 'nome': 'Criar interface', 'responsavel': 'João', 'status': 'Pendente'}
        ]
    }
]

@app.route('/api/projetos', methods=['GET'])
def listar_projetos():
    """Lista todos os projetos"""
    return jsonify(projetos)

@app.route('/api/projetos/<int:projeto_id>/tarefas', methods=['GET'])
def listar_tarefas_projeto(projeto_id):
    """Lista tarefas de um projeto específico"""
    for projeto in projetos:
        if projeto['id'] == projeto_id:
            return jsonify(projeto['tarefas'])
    return jsonify({'erro': 'Projeto não encontrado'}), 404

@app.route('/api/projetos/<int:projeto_id>/tarefas', methods=['POST'])
def adicionar_tarefa(projeto_id):
    """Adiciona uma nova tarefa a um projeto"""
    dados = request.get_json()
    for projeto in projetos:
        if projeto['id'] == projeto_id:
            nova_tarefa = {
                'id': len(projeto['tarefas']) + 1,
                'nome': dados['nome'],
                'responsavel': dados['responsavel'],
                'status': 'Pendente'
            }
            projeto['tarefas'].append(nova_tarefa)
            return jsonify(nova_tarefa), 201
    return jsonify({'erro': 'Projeto não encontrado'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-15: Define lista de projetos simulando banco de dados
• Linha 17: @app.route('/api/projetos', methods=['GET']) - Define rota GET para listar projetos
• Linha 18: def listar_projetos(): - Define função para listar projetos
• Linha 19: """Lista todos os projetos""" - Docstring explicando função
• Linha 20: return jsonify(projetos) - Retorna lista de projetos em JSON
• Linha 22: @app.route('/api/projetos/<int:projeto_id>/tarefas', methods=['GET']) - Define rota GET para listar tarefas de um projeto
• Linha 23: def listar_tarefas_projeto(projeto_id): - Define função para listar tarefas de um projeto
• Linha 24: """Lista tarefas de um projeto específico""" - Docstring explicando função
• Linha 25: for projeto in projetos: - Percorre lista de projetos
• Linha 26: if projeto['id'] == projeto_id: - Verifica se ID do projeto corresponde ao solicitado

13. API de Blog

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
posts = [
    {
        'id': 1,
        'titulo': 'Introdução ao Flask',
        'categoria': 'Python',
        'conteudo': 'Flask é um framework web para Python...',
        'comentarios': [
            {'id': 1, 'autor': 'João', 'texto': 'Ótimo post!'},
            {'id': 2, 'autor': 'Maria', 'texto': 'Muito útil!'}
        ]
    }
]

@app.route('/api/posts', methods=['GET'])
def listar_posts():
    """Lista todos os posts"""
    return jsonify(posts)

@app.route('/api/posts/<int:post_id>/comentarios', methods=['GET'])
def listar_comentarios(post_id):
    """Lista comentários de um post específico"""
    for post in posts:
        if post['id'] == post_id:
            return jsonify(post['comentarios'])
    return jsonify({'erro': 'Post não encontrado'}), 404

@app.route('/api/posts/<int:post_id>/comentarios', methods=['POST'])
def adicionar_comentario(post_id):
    """Adiciona um novo comentário a um post"""
    dados = request.get_json()
    for post in posts:
        if post['id'] == post_id:
            novo_comentario = {
                'id': len(post['comentarios']) + 1,
                'autor': dados['autor'],
                'texto': dados['texto']
            }
            post['comentarios'].append(novo_comentario)
            return jsonify(novo_comentario), 201
    return jsonify({'erro': 'Post não encontrado'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-18: Define lista de posts simulando banco de dados
• Linha 20: @app.route('/api/posts', methods=['GET']) - Define rota GET para listar posts
• Linha 21: def listar_posts(): - Define função para listar posts
• Linha 22: """Lista todos os posts""" - Docstring explicando função
• Linha 23: return jsonify(posts) - Retorna lista de posts em JSON
• Linha 25: @app.route('/api/posts/<int:post_id>/comentarios', methods=['GET']) - Define rota GET para listar comentários de um post
• Linha 26: def listar_comentarios(post_id): - Define função para listar comentários de um post
• Linha 27: """Lista comentários de um post específico""" - Docstring explicando função
• Linha 28: for post in posts: - Percorre lista de posts
• Linha 29: if post['id'] == post_id: - Verifica se ID do post corresponde ao solicitado

14. API de Academia

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
treinos = [
    {
        'id': 1,
        'aluno': 'João Silva',
        'exercicios': [
            {'nome': 'Supino', 'series': 3, 'repeticoes': 12, 'peso': 80},
            {'nome': 'Agachamento', 'series': 4, 'repeticoes': 10, 'peso': 100}
        ]
    }
]

@app.route('/api/treinos', methods=['GET'])
def listar_treinos():
    """Lista todos os treinos"""
    return jsonify(treinos)

@app.route('/api/treinos/<int:treino_id>/exercicios', methods=['GET'])
def listar_exercicios_treino(treino_id):
    """Lista exercícios de um treino específico"""
    for treino in treinos:
        if treino['id'] == treino_id:
            return jsonify(treino['exercicios'])
    return jsonify({'erro': 'Treino não encontrado'}), 404

@app.route('/api/treinos/<int:treino_id>/exercicios', methods=['POST'])
def adicionar_exercicio(treino_id):
    """Adiciona um novo exercício a um treino"""
    dados = request.get_json()
    for treino in treinos:
        if treino['id'] == treino_id:
            novo_exercicio = {
                'nome': dados['nome'],
                'series': dados['series'],
                'repeticoes': dados['repeticoes'],
                'peso': dados['peso']
            }
            treino['exercicios'].append(novo_exercicio)
            return jsonify(novo_exercicio), 201
    return jsonify({'erro': 'Treino não encontrado'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-16: Define lista de treinos simulando banco de dados
• Linha 18: @app.route('/api/treinos', methods=['GET']) - Define rota GET para listar treinos
• Linha 19: def listar_treinos(): - Define função para listar treinos
• Linha 20: """Lista todos os treinos""" - Docstring explicando função
• Linha 21: return jsonify(treinos) - Retorna lista de treinos em JSON
• Linha 23: @app.route('/api/treinos/<int:treino_id>/exercicios', methods=['GET']) - Define rota GET para listar exercícios de um treino
• Linha 24: def listar_exercicios_treino(treino_id): - Define função para listar exercícios de um treino
• Linha 25: """Lista exercícios de um treino específico""" - Docstring explicando função
• Linha 26: for treino in treinos: - Percorre lista de treinos
• Linha 27: if treino['id'] == treino_id: - Verifica se ID do treino corresponde ao solicitado

15. API de Restaurante

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
cardapio = [
    {'id': 1, 'prato': 'Pizza Margherita', 'preco': 35.00, 'categoria': 'Pizzas'},
    {'id': 2, 'prato': 'Hambúrguer Clássico', 'preco': 25.00, 'categoria': 'Lanches'},
    {'id': 3, 'prato': 'Salada Caesar', 'preco': 18.00, 'categoria': 'Saladas'}
]

pedidos = [
    {'id': 1, 'mesa': 5, 'itens': ['Pizza Margherita'], 'total': 35.00, 'status': 'Preparando'}
]

@app.route('/api/cardapio', methods=['GET'])
def listar_cardapio():
    """Lista o cardápio do restaurante"""
    return jsonify(cardapio)

@app.route('/api/pedidos', methods=['GET'])
def listar_pedidos():
    """Lista todos os pedidos"""
    return jsonify(pedidos)

@app.route('/api/pedidos', methods=['POST'])
def criar_pedido():
    """Cria um novo pedido"""
    dados = request.get_json()
    novo_pedido = {
        'id': len(pedidos) + 1,
        'mesa': dados['mesa'],
        'itens': dados['itens'],
        'total': dados['total'],
        'status': 'Recebido'
    }
    pedidos.append(novo_pedido)
    return jsonify(novo_pedido), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de cardápio simulando banco de dados
• Linha 12: pedidos = [] - Inicializa lista de pedidos
• Linha 14: @app.route('/api/cardapio', methods=['GET']) - Define rota GET para listar cardápio
• Linha 15: def listar_cardapio(): - Define função para listar cardápio
• Linha 16: """Lista o cardápio do restaurante""" - Docstring explicando função
• Linha 17: return jsonify(cardapio) - Retorna lista de cardápio em JSON
• Linha 19: @app.route('/api/pedidos', methods=['GET']) - Define rota GET para listar pedidos
• Linha 20: def listar_pedidos(): - Define função para listar pedidos
• Linha 21: """Lista todos os pedidos""" - Docstring explicando função
• Linha 22: return jsonify(pedidos) - Retorna lista de pedidos em JSON

13.6.4 DIFÍCIL (Nível 4)

16. API de E-commerce

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
produtos = [
    {'id': 1, 'nome': 'Notebook', 'preco': 2500.00, 'estoque': 10},
    {'id': 2, 'nome': 'Mouse', 'preco': 50.00, 'estoque': 50}
]

carrinhos = [
    {'id': 1, 'usuario': 'joao@email.com', 'itens': [{'produto_id': 1, 'quantidade': 2}], 'total': 5000.00}
]

@app.route('/api/produtos', methods=['GET'])
def listar_produtos():
    """Lista todos os produtos"""
    return jsonify(produtos)

@app.route('/api/carrinho/<int:carrinho_id>', methods=['GET'])
def ver_carrinho(carrinho_id):
    """Visualiza carrinho de compras"""
    for carrinho in carrinhos:
        if carrinho['id'] == carrinho_id:
            return jsonify(carrinho)
    return jsonify({'erro': 'Carrinho não encontrado'}), 404

@app.route('/api/carrinho/<int:carrinho_id>/adicionar', methods=['POST'])
def adicionar_ao_carrinho(carrinho_id):
    """Adiciona produto ao carrinho"""
    dados = request.get_json()
    for carrinho in carrinhos:
        if carrinho['id'] == carrinho_id:
            # Verificar se produto existe e tem estoque
            for produto in produtos:
                if produto['id'] == dados['produto_id']:
                    if produto['estoque'] >= dados['quantidade']:
                        carrinho['itens'].append(dados)
                        carrinho['total'] += produto['preco'] * dados['quantidade']
                        return jsonify(carrinho), 200
                    else:
                        return jsonify({'erro': 'Estoque insuficiente'}), 400
            return jsonify({'erro': 'Produto não encontrado'}), 404
    return jsonify({'erro': 'Carrinho não encontrado'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de produtos simulando banco de dados
• Linha 11: carrinhos = [] - Inicializa lista de carrinhos
• Linha 13: @app.route('/api/produtos', methods=['GET']) - Define rota GET para listar produtos
• Linha 14: def listar_produtos(): - Define função para listar produtos
• Linha 15: """Lista todos os produtos""" - Docstring explicando função
• Linha 16: return jsonify(produtos) - Retorna lista de produtos em JSON
• Linha 18: @app.route('/api/carrinho/<int:carrinho_id>', methods=['GET']) - Define rota GET para ver carrinho
• Linha 19: def ver_carrinho(carrinho_id): - Define função para visualizar carrinho
• Linha 20: """Visualiza carrinho de compras""" - Docstring explicando função
• Linha 21: for carrinho in carrinhos: - Percorre lista de carrinhos
• Linha 22: if carrinho['id'] == carrinho_id: - Verifica se ID do carrinho corresponde ao solicitado

17. API de Rede Social

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
usuarios = [
    {'id': 1, 'nome': 'João Silva', 'email': 'joao@email.com', 'seguidores': [2, 3]},
    {'id': 2, 'nome': 'Maria Santos', 'email': 'maria@email.com', 'seguidores': [1]},
    {'id': 3, 'nome': 'Pedro Costa', 'email': 'pedro@email.com', 'seguidores': [1]}
]

posts = [
    {'id': 1, 'autor_id': 1, 'conteudo': 'Aprendendo Flask!', 'likes': [2, 3], 'comentarios': []},
    {'id': 2, 'autor_id': 2, 'conteudo': 'Python é incrível!', 'likes': [1], 'comentarios': []}
]

@app.route('/api/usuarios/<int:usuario_id>/posts', methods=['GET'])
def listar_posts_usuario(usuario_id):
    """Lista posts de um usuário específico"""
    posts_usuario = [post for post in posts if post['autor_id'] == usuario_id]
    return jsonify(posts_usuario)

@app.route('/api/posts/<int:post_id>/like', methods=['POST'])
def curtir_post(post_id):
    """Curtir um post"""
    dados = request.get_json()
    for post in posts:
        if post['id'] == post_id:
            if dados['usuario_id'] not in post['likes']:
                post['likes'].append(dados['usuario_id'])
                return jsonify({'mensagem': 'Post curtido!', 'likes': len(post['likes'])})
            else:
                return jsonify({'erro': 'Post já foi curtido'}), 400
    return jsonify({'erro': 'Post não encontrado'}), 404

@app.route('/api/posts/<int:post_id>/comentarios', methods=['POST'])
def adicionar_comentario(post_id):
    """Adicionar comentário a um post"""
    dados = request.get_json()
    for post in posts:
        if post['id'] == post_id:
            novo_comentario = {
                'id': len(post['comentarios']) + 1,
                'autor_id': dados['autor_id'],
                'texto': dados['texto']
            }
            post['comentarios'].append(novo_comentario)
            return jsonify(novo_comentario), 201
    return jsonify({'erro': 'Post não encontrado'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de usuários simulando banco de dados
• Linha 12: posts = [] - Inicializa lista de posts
• Linha 14: @app.route('/api/usuarios/<int:usuario_id>/posts', methods=['GET']) - Define rota GET para listar posts de um usuário
• Linha 15: def listar_posts_usuario(usuario_id): - Define função para listar posts de um usuário
• Linha 16: """Lista posts de um usuário específico""" - Docstring explicando função
• Linha 17: posts_usuario = [post for post in posts if post['autor_id'] == usuario_id] - Filtra posts do usuário
• Linha 18: return jsonify(posts_usuario) - Retorna posts do usuário em JSON
• Linha 20: @app.route('/api/posts/<int:post_id>/like', methods=['POST']) - Define rota POST para curtir post
• Linha 21: def curtir_post(post_id): - Define função para curtir post
• Linha 22: """Curtir um post""" - Docstring explicando função
• Linha 23: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 24: for post in posts: - Percorre lista de posts
• Linha 25: if post['id'] == post_id: - Verifica se ID do post corresponde ao solicitado

18. API de Sistema Bancário

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
contas = [
    {'id': 1, 'numero': '12345-6', 'titular': 'João Silva', 'saldo': 1000.00},
    {'id': 2, 'numero': '67890-1', 'titular': 'Maria Santos', 'saldo': 500.00}
]

transacoes = [
    {'id': 1, 'conta_origem': 1, 'conta_destino': 2, 'valor': 100.00, 'tipo': 'transferencia', 'data': '2024-01-15'}
]

@app.route('/api/contas/<int:conta_id>/saldo', methods=['GET'])
def consultar_saldo(conta_id):
    """Consulta saldo de uma conta"""
    for conta in contas:
        if conta['id'] == conta_id:
            return jsonify({'saldo': conta['saldo']})
    return jsonify({'erro': 'Conta não encontrada'}), 404

@app.route('/api/transacoes', methods=['POST'])
def realizar_transacao():
    """Realiza uma transação bancária"""
    dados = request.get_json()
    
    # Verificar se contas existem
    conta_origem = None
    conta_destino = None
    
    for conta in contas:
        if conta['id'] == dados['conta_origem']:
            conta_origem = conta
        if conta['id'] == dados['conta_destino']:
            conta_destino = conta
    
    if not conta_origem or not conta_destino:
        return jsonify({'erro': 'Conta não encontrada'}), 404
    
    # Verificar se há saldo suficiente
    if conta_origem['saldo'] < dados['valor']:
        return jsonify({'erro': 'Saldo insuficiente'}), 400
    
    # Realizar transação
    conta_origem['saldo'] -= dados['valor']
    conta_destino['saldo'] += dados['valor']
    
    nova_transacao = {
        'id': len(transacoes) + 1,
        'conta_origem': dados['conta_origem'],
        'conta_destino': dados['conta_destino'],
        'valor': dados['valor'],
        'tipo': 'transferencia',
        'data': '2024-01-15'
    }
    transacoes.append(nova_transacao)
    
    return jsonify({'mensagem': 'Transação realizada com sucesso!', 'transacao': nova_transacao}), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de contas simulando banco de dados
• Linha 11: transacoes = [] - Inicializa lista de transações
• Linha 13: @app.route('/api/contas/<int:conta_id>/saldo', methods=['GET']) - Define rota GET para consultar saldo
• Linha 14: def consultar_saldo(conta_id): - Define função para consultar saldo
• Linha 15: """Consulta saldo de uma conta""" - Docstring explicando função
• Linha 16: for conta in contas: - Percorre lista de contas
• Linha 17: if conta['id'] == conta_id: - Verifica se ID da conta corresponde ao solicitado
• Linha 18: return jsonify({'saldo': conta['saldo']}) - Retorna saldo da conta em JSON
• Linha 20: @app.route('/api/transacoes', methods=['POST']) - Define rota POST para realizar transação
• Linha 21: def realizar_transacao(): - Define função para realizar transação
• Linha 22: """Realiza uma transação bancária""" - Docstring explicando função
• Linha 23: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 25: # Verificar se contas existem - Comentário explicativo
• Linha 26: conta_origem = None - Inicializa variável para conta origem
• Linha 27: conta_destino = None - Inicializa variável para conta destino

19. API de Hotel

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
quartos = [
    {'id': 1, 'numero': '101', 'tipo': 'Simples', 'preco': 100.00, 'disponivel': True},
    {'id': 2, 'numero': '102', 'tipo': 'Duplo', 'preco': 150.00, 'disponivel': False},
    {'id': 3, 'numero': '103', 'tipo': 'Suíte', 'preco': 250.00, 'disponivel': True}
]

reservas = [
    {'id': 1, 'hospede': 'João Silva', 'quarto_id': 2, 'checkin': '2024-01-15', 'checkout': '2024-01-20', 'total': 750.00}
]

@app.route('/api/quartos', methods=['GET'])
def listar_quartos():
    """Lista todos os quartos"""
    return jsonify(quartos)

@app.route('/api/quartos/disponiveis', methods=['GET'])
def listar_quartos_disponiveis():
    """Lista apenas quartos disponíveis"""
    quartos_disponiveis = [quarto for quarto in quartos if quarto['disponivel']]
    return jsonify(quartos_disponiveis)

@app.route('/api/reservas', methods=['POST'])
def criar_reserva():
    """Cria uma nova reserva"""
    dados = request.get_json()
    
    # Verificar se quarto existe e está disponível
    quarto = None
    for q in quartos:
        if q['id'] == dados['quarto_id']:
            quarto = q
            break
    
    if not quarto:
        return jsonify({'erro': 'Quarto não encontrado'}), 404
    
    if not quarto['disponivel']:
        return jsonify({'erro': 'Quarto não está disponível'}), 400
    
    # Calcular total da reserva
    dias = 5  # Simulado
    total = quarto['preco'] * dias
    
    nova_reserva = {
        'id': len(reservas) + 1,
        'hospede': dados['hospede'],
        'quarto_id': dados['quarto_id'],
        'checkin': dados['checkin'],
        'checkout': dados['checkout'],
        'total': total
    }
    
    reservas.append(nova_reserva)
    quarto['disponivel'] = False
    
    return jsonify(nova_reserva), 201

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de quartos simulando banco de dados
• Linha 12: reservas = [] - Inicializa lista de reservas
• Linha 14: @app.route('/api/quartos', methods=['GET']) - Define rota GET para listar quartos
• Linha 15: def listar_quartos(): - Define função para listar quartos
• Linha 16: """Lista todos os quartos""" - Docstring explicando função
• Linha 17: return jsonify(quartos) - Retorna lista de quartos em JSON
• Linha 19: @app.route('/api/quartos/disponiveis', methods=['GET']) - Define rota GET para listar quartos disponíveis
• Linha 20: def listar_quartos_disponiveis(): - Define função para listar quartos disponíveis
• Linha 21: """Lista apenas quartos disponíveis""" - Docstring explicando função
• Linha 22: quartos_disponiveis = [quarto for quarto in quartos if quarto['disponivel']] - Filtra quartos disponíveis
• Linha 23: return jsonify(quartos_disponiveis) - Retorna quartos disponíveis em JSON
• Linha 25: @app.route('/api/reservas', methods=['POST']) - Define rota POST para criar reserva
• Linha 26: def criar_reserva(): - Define função para criar reserva
• Linha 27: """Cria uma nova reserva""" - Docstring explicando função
• Linha 28: dados = request.get_json() - Obtém dados JSON enviados na requisição

20. API de Escola

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
disciplinas = [
    {'id': 1, 'nome': 'Matemática', 'professor': 'Ana Santos', 'alunos': 30},
    {'id': 2, 'nome': 'Português', 'professor': 'João Silva', 'alunos': 25},
    {'id': 3, 'nome': 'História', 'professor': 'Maria Costa', 'alunos': 28}
]

alunos = [
    {'id': 1, 'nome': 'Pedro Oliveira', 'matricula': '2024001', 'disciplinas': [1, 2]},
    {'id': 2, 'nome': 'Ana Ferreira', 'matricula': '2024002', 'disciplinas': [1, 3]}
]

@app.route('/api/disciplinas', methods=['GET'])
def listar_disciplinas():
    """Lista todas as disciplinas"""
    return jsonify(disciplinas)

@app.route('/api/alunos/<int:aluno_id>/disciplinas', methods=['GET'])
def listar_disciplinas_aluno(aluno_id):
    """Lista disciplinas de um aluno específico"""
    for aluno in alunos:
        if aluno['id'] == aluno_id:
            disciplinas_aluno = [d for d in disciplinas if d['id'] in aluno['disciplinas']]
            return jsonify(disciplinas_aluno)
    return jsonify({'erro': 'Aluno não encontrado'}), 404

@app.route('/api/disciplinas/<int:disciplina_id>/alunos', methods=['GET'])
def listar_alunos_disciplina(disciplina_id):
    """Lista alunos de uma disciplina específica"""
    for disciplina in disciplinas:
        if disciplina['id'] == disciplina_id:
            alunos_disciplina = [a for a in alunos if disciplina_id in a['disciplinas']]
            return jsonify(alunos_disciplina)
    return jsonify({'erro': 'Disciplina não encontrada'}), 404

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de disciplinas simulando banco de dados
• Linha 12: alunos = [] - Inicializa lista de alunos
• Linha 14: @app.route('/api/disciplinas', methods=['GET']) - Define rota GET para listar disciplinas
• Linha 15: def listar_disciplinas(): - Define função para listar disciplinas
• Linha 16: """Lista todas as disciplinas""" - Docstring explicando função
• Linha 17: return jsonify(disciplinas) - Retorna lista de disciplinas em JSON
• Linha 19: @app.route('/api/alunos/<int:aluno_id>/disciplinas', methods=['GET']) - Define rota GET para listar disciplinas de um aluno
• Linha 20: def listar_disciplinas_aluno(aluno_id): - Define função para listar disciplinas de um aluno
• Linha 21: """Lista disciplinas de um aluno específico""" - Docstring explicando função
• Linha 22: for aluno in alunos: - Percorre lista de alunos
• Linha 23: if aluno['id'] == aluno_id: - Verifica se ID do aluno corresponde ao solicitado
• Linha 24: disciplinas_aluno = [d for d in disciplinas if d['id'] in aluno['disciplinas']] - Filtra disciplinas do aluno
• Linha 25: return jsonify(disciplinas_aluno) - Retorna disciplinas do aluno em JSON

13.6.5 MUITO DIFÍCIL (Nível 5)

21. API de Marketplace

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
vendedores = [
    {'id': 1, 'nome': 'João Silva', 'email': 'joao@email.com', 'produtos': [1, 2]},
    {'id': 2, 'nome': 'Maria Santos', 'email': 'maria@email.com', 'produtos': [3]}
]

produtos = [
    {'id': 1, 'nome': 'Notebook', 'preco': 2500.00, 'vendedor_id': 1, 'estoque': 10},
    {'id': 2, 'nome': 'Mouse', 'preco': 50.00, 'vendedor_id': 1, 'estoque': 50},
    {'id': 3, 'nome': 'Teclado', 'preco': 120.00, 'vendedor_id': 2, 'estoque': 25}
]

compras = [
    {'id': 1, 'comprador': 'Ana Costa', 'produto_id': 1, 'vendedor_id': 1, 'valor': 2500.00, 'data': '2024-01-15'}
]

@app.route('/api/vendedores/<int:vendedor_id>/produtos', methods=['GET'])
def listar_produtos_vendedor(vendedor_id):
    """Lista produtos de um vendedor específico"""
    produtos_vendedor = [produto for produto in produtos if produto['vendedor_id'] == vendedor_id]
    return jsonify(produtos_vendedor)

@app.route('/api/produtos/<int:produto_id>/comprar', methods=['POST'])
def comprar_produto(produto_id):
    """Compra um produto de um vendedor"""
    dados = request.get_json()
    
    # Verificar se produto existe
    produto = None
    for p in produtos:
        if p['id'] == produto_id:
            produto = p
            break
    
    if not produto:
        return jsonify({'erro': 'Produto não encontrado'}), 404
    
    # Verificar se há estoque
    if produto['estoque'] <= 0:
        return jsonify({'erro': 'Produto fora de estoque'}), 400
    
    # Realizar compra
    produto['estoque'] -= 1
    
    nova_compra = {
        'id': len(compras) + 1,
        'comprador': dados['comprador'],
        'produto_id': produto_id,
        'vendedor_id': produto['vendedor_id'],
        'valor': produto['preco'],
        'data': '2024-01-15'
    }
    compras.append(nova_compra)
    
    return jsonify({'mensagem': 'Compra realizada com sucesso!', 'compra': nova_compra}), 201

@app.route('/api/vendedores/<int:vendedor_id>/vendas', methods=['GET'])
def listar_vendas_vendedor(vendedor_id):
    """Lista vendas de um vendedor específico"""
    vendas_vendedor = [compra for compra in compras if compra['vendedor_id'] == vendedor_id]
    return jsonify(vendas_vendedor)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de vendedores simulando banco de dados
• Linha 11: produtos = [] - Inicializa lista de produtos
• Linha 13: compras = [] - Inicializa lista de compras
• Linha 15: @app.route('/api/vendedores/<int:vendedor_id>/produtos', methods=['GET']) - Define rota GET para listar produtos de um vendedor
• Linha 16: def listar_produtos_vendedor(vendedor_id): - Define função para listar produtos de um vendedor
• Linha 17: """Lista produtos de um vendedor específico""" - Docstring explicando função
• Linha 18: produtos_vendedor = [produto for produto in produtos if produto['vendedor_id'] == vendedor_id] - Filtra produtos do vendedor
• Linha 19: return jsonify(produtos_vendedor) - Retorna produtos do vendedor em JSON
• Linha 21: @app.route('/api/produtos/<int:produto_id>/comprar', methods=['POST']) - Define rota POST para comprar produto
• Linha 22: def comprar_produto(produto_id): - Define função para comprar produto
• Linha 23: """Compra um produto de um vendedor""" - Docstring explicando função
• Linha 24: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 26: # Verificar se produto existe - Comentário explicativo
• Linha 27: produto = None - Inicializa variável para produto
• Linha 28: for p in produtos: - Percorre lista de produtos
• Linha 29: if p['id'] == produto_id: - Verifica se ID do produto corresponde ao solicitado
• Linha 30: produto = p - Armazena produto encontrado
• Linha 31: break - Sai do loop quando produto é encontrado

22. API de Sistema de Delivery

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
restaurantes = [
    {'id': 1, 'nome': 'Pizza Hut', 'endereco': 'Rua A, 123', 'cardapio': [1, 2]},
    {'id': 2, 'nome': 'McDonald\'s', 'endereco': 'Rua B, 456', 'cardapio': [3, 4]}
]

pratos = [
    {'id': 1, 'nome': 'Pizza Margherita', 'preco': 35.00, 'restaurante_id': 1},
    {'id': 2, 'nome': 'Pizza Portuguesa', 'preco': 40.00, 'restaurante_id': 1},
    {'id': 3, 'nome': 'Big Mac', 'preco': 25.00, 'restaurante_id': 2},
    {'id': 4, 'nome': 'McChicken', 'preco': 20.00, 'restaurante_id': 2}
]

entregadores = [
    {'id': 1, 'nome': 'João Silva', 'telefone': '11999999999', 'disponivel': True},
    {'id': 2, 'nome': 'Maria Santos', 'telefone': '11888888888', 'disponivel': False}
]

pedidos = [
    {'id': 1, 'cliente': 'Ana Costa', 'restaurante_id': 1, 'entregador_id': 1, 'endereco': 'Rua C, 789', 'total': 35.00, 'status': 'Preparando'}
]

@app.route('/api/restaurantes/<int:restaurante_id>/cardapio', methods=['GET'])
def listar_cardapio_restaurante(restaurante_id):
    """Lista cardápio de um restaurante específico"""
    cardapio_restaurante = [prato for prato in pratos if prato['restaurante_id'] == restaurante_id]
    return jsonify(cardapio_restaurante)

@app.route('/api/pedidos', methods=['POST'])
def criar_pedido():
    """Cria um novo pedido de delivery"""
    dados = request.get_json()
    
    # Verificar se restaurante existe
    restaurante = None
    for r in restaurantes:
        if r['id'] == dados['restaurante_id']:
            restaurante = r
            break
    
    if not restaurante:
        return jsonify({'erro': 'Restaurante não encontrado'}), 404
    
    # Encontrar entregador disponível
    entregador_disponivel = None
    for entregador in entregadores:
        if entregador['disponivel']:
            entregador_disponivel = entregador
            break
    
    if not entregador_disponivel:
        return jsonify({'erro': 'Nenhum entregador disponível'}), 400
    
    # Calcular tempo estimado (simulado)
    tempo_estimado = 30  # minutos
    
    novo_pedido = {
        'id': len(pedidos) + 1,
        'cliente': dados['cliente'],
        'restaurante_id': dados['restaurante_id'],
        'entregador_id': entregador_disponivel['id'],
        'endereco': dados['endereco'],
        'total': dados['total'],
        'status': 'Recebido',
        'tempo_estimado': tempo_estimado
    }
    
    pedidos.append(novo_pedido)
    entregador_disponivel['disponivel'] = False
    
    return jsonify({'mensagem': 'Pedido criado com sucesso!', 'pedido': novo_pedido}), 201

@app.route('/api/entregadores/<int:entregador_id>/pedidos', methods=['GET'])
def listar_pedidos_entregador(entregador_id):
    """Lista pedidos de um entregador específico"""
    pedidos_entregador = [pedido for pedido in pedidos if pedido['entregador_id'] == entregador_id]
    return jsonify(pedidos_entregador)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de restaurantes simulando banco de dados
• Linha 11: pratos = [] - Inicializa lista de pratos
• Linha 13: entregadores = [] - Inicializa lista de entregadores
• Linha 15: pedidos = [] - Inicializa lista de pedidos
• Linha 17: @app.route('/api/restaurantes/<int:restaurante_id>/cardapio', methods=['GET']) - Define rota GET para listar cardápio de um restaurante
• Linha 18: def listar_cardapio_restaurante(restaurante_id): - Define função para listar cardápio de um restaurante
• Linha 19: """Lista cardápio de um restaurante específico""" - Docstring explicando função
• Linha 20: cardapio_restaurante = [prato for prato in pratos if prato['restaurante_id'] == restaurante_id] - Filtra pratos do restaurante
• Linha 21: return jsonify(cardapio_restaurante) - Retorna cardápio do restaurante em JSON
• Linha 23: @app.route('/api/pedidos', methods=['POST']) - Define rota POST para criar pedido
• Linha 24: def criar_pedido(): - Define função para criar pedido
• Linha 25: """Cria um novo pedido de delivery""" - Docstring explicando função
• Linha 26: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 28: # Verificar se restaurante existe - Comentário explicativo
• Linha 29: restaurante = None - Inicializa variável para restaurante
• Linha 30: for r in restaurantes: - Percorre lista de restaurantes
• Linha 31: if r['id'] == dados['restaurante_id']: - Verifica se ID do restaurante corresponde ao solicitado
• Linha 32: restaurante = r - Armazena restaurante encontrado
• Linha 33: break - Sai do loop quando restaurante é encontrado

23. API de Streaming

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
usuarios = [
    {'id': 1, 'nome': 'João Silva', 'email': 'joao@email.com', 'assinatura': 'Premium'},
    {'id': 2, 'nome': 'Maria Santos', 'email': 'maria@email.com', 'assinatura': 'Básica'}
]

conteudo = [
    {'id': 1, 'titulo': 'Filme A', 'genero': 'Ação', 'disponivel': True, 'assinatura_necessaria': 'Premium'},
    {'id': 2, 'titulo': 'Filme B', 'genero': 'Comédia', 'disponivel': True, 'assinatura_necessaria': 'Básica'},
    {'id': 3, 'titulo': 'Série C', 'genero': 'Drama', 'disponivel': False, 'assinatura_necessaria': 'Premium'}
]

historico = [
    {'id': 1, 'usuario_id': 1, 'conteudo_id': 1, 'data': '2024-01-15', 'tempo_assistido': 120}
]

@app.route('/api/conteudo', methods=['GET'])
def listar_conteudo():
    """Lista todo o conteúdo disponível"""
    return jsonify(conteudo)

@app.route('/api/conteudo/<int:conteudo_id>/assistir', methods=['POST'])
def assistir_conteudo(conteudo_id):
    """Permite que usuário assista conteúdo"""
    dados = request.get_json()
    
    # Verificar se conteúdo existe
    conteudo_encontrado = None
    for c in conteudo:
        if c['id'] == conteudo_id:
            conteudo_encontrado = c
            break
    
    if not conteudo_encontrado:
        return jsonify({'erro': 'Conteúdo não encontrado'}), 404
    
    # Verificar se conteúdo está disponível
    if not conteudo_encontrado['disponivel']:
        return jsonify({'erro': 'Conteúdo não está disponível'}), 400
    
    # Verificar se usuário tem assinatura necessária
    usuario = None
    for u in usuarios:
        if u['id'] == dados['usuario_id']:
            usuario = u
            break
    
    if not usuario:
        return jsonify({'erro': 'Usuário não encontrado'}), 404
    
    if conteudo_encontrado['assinatura_necessaria'] == 'Premium' and usuario['assinatura'] != 'Premium':
        return jsonify({'erro': 'Assinatura Premium necessária'}), 403
    
    # Registrar no histórico
    novo_historico = {
        'id': len(historico) + 1,
        'usuario_id': dados['usuario_id'],
        'conteudo_id': conteudo_id,
        'data': '2024-01-15',
        'tempo_assistido': 0
    }
    historico.append(novo_historico)
    
    return jsonify({'mensagem': 'Conteúdo iniciado!', 'conteudo': conteudo_encontrado}), 200

@app.route('/api/usuarios/<int:usuario_id>/historico', methods=['GET'])
def listar_historico_usuario(usuario_id):
    """Lista histórico de um usuário específico"""
    historico_usuario = [h for h in historico if h['usuario_id'] == usuario_id]
    return jsonify(historico_usuario)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de usuários simulando banco de dados
• Linha 11: conteudo = [] - Inicializa lista de conteúdo
• Linha 13: historico = [] - Inicializa lista de histórico
• Linha 15: @app.route('/api/conteudo', methods=['GET']) - Define rota GET para listar conteúdo
• Linha 16: def listar_conteudo(): - Define função para listar conteúdo
• Linha 17: """Lista todo o conteúdo disponível""" - Docstring explicando função
• Linha 18: return jsonify(conteudo) - Retorna lista de conteúdo em JSON
• Linha 20: @app.route('/api/conteudo/<int:conteudo_id>/assistir', methods=['POST']) - Define rota POST para assistir conteúdo
• Linha 21: def assistir_conteudo(conteudo_id): - Define função para assistir conteúdo
• Linha 22: """Permite que usuário assista conteúdo""" - Docstring explicando função
• Linha 23: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 25: # Verificar se conteúdo existe - Comentário explicativo
• Linha 26: conteudo_encontrado = None - Inicializa variável para conteúdo encontrado
• Linha 27: for c in conteudo: - Percorre lista de conteúdo
• Linha 28: if c['id'] == conteudo_id: - Verifica se ID do conteúdo corresponde ao solicitado
• Linha 29: conteudo_encontrado = c - Armazena conteúdo encontrado
• Linha 30: break - Sai do loop quando conteúdo é encontrado

24. API de Sistema de Saúde

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
pacientes = [
    {'id': 1, 'nome': 'João Silva', 'cpf': '123.456.789-00', 'telefone': '11999999999'},
    {'id': 2, 'nome': 'Maria Santos', 'cpf': '987.654.321-00', 'telefone': '11888888888'}
]

medicos = [
    {'id': 1, 'nome': 'Dr. Ana Costa', 'especialidade': 'Cardiologia', 'crm': '12345'},
    {'id': 2, 'nome': 'Dr. Pedro Oliveira', 'especialidade': 'Pediatria', 'crm': '67890'}
]

consultas = [
    {'id': 1, 'paciente_id': 1, 'medico_id': 1, 'data': '2024-01-20', 'horario': '14:00', 'status': 'Agendada'}
]

@app.route('/api/pacientes', methods=['GET'])
def listar_pacientes():
    """Lista todos os pacientes"""
    return jsonify(pacientes)

@app.route('/api/medicos', methods=['GET'])
def listar_medicos():
    """Lista todos os médicos"""
    return jsonify(medicos)

@app.route('/api/consultas', methods=['POST'])
def agendar_consulta():
    """Agenda uma nova consulta"""
    dados = request.get_json()
    
    # Verificar se paciente existe
    paciente = None
    for p in pacientes:
        if p['id'] == dados['paciente_id']:
            paciente = p
            break
    
    if not paciente:
        return jsonify({'erro': 'Paciente não encontrado'}), 404
    
    # Verificar se médico existe
    medico = None
    for m in medicos:
        if m['id'] == dados['medico_id']:
            medico = m
            break
    
    if not medico:
        return jsonify({'erro': 'Médico não encontrado'}), 404
    
    # Criar nova consulta
    nova_consulta = {
        'id': len(consultas) + 1,
        'paciente_id': dados['paciente_id'],
        'medico_id': dados['medico_id'],
        'data': dados['data'],
        'horario': dados['horario'],
        'status': 'Agendada'
    }
    
    consultas.append(nova_consulta)
    
    return jsonify({'mensagem': 'Consulta agendada com sucesso!', 'consulta': nova_consulta}), 201

@app.route('/api/pacientes/<int:paciente_id>/consultas', methods=['GET'])
def listar_consultas_paciente(paciente_id):
    """Lista consultas de um paciente específico"""
    consultas_paciente = [c for c in consultas if c['paciente_id'] == paciente_id]
    return jsonify(consultas_paciente)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-9: Define lista de pacientes simulando banco de dados
• Linha 11: medicos = [] - Inicializa lista de médicos
• Linha 13: consultas = [] - Inicializa lista de consultas
• Linha 15: @app.route('/api/pacientes', methods=['GET']) - Define rota GET para listar pacientes
• Linha 16: def listar_pacientes(): - Define função para listar pacientes
• Linha 17: """Lista todos os pacientes""" - Docstring explicando função
• Linha 18: return jsonify(pacientes) - Retorna lista de pacientes em JSON
• Linha 20: @app.route('/api/medicos', methods=['GET']) - Define rota GET para listar médicos
• Linha 21: def listar_medicos(): - Define função para listar médicos
• Linha 22: """Lista todos os médicos""" - Docstring explicando função
• Linha 23: return jsonify(medicos) - Retorna lista de médicos em JSON
• Linha 25: @app.route('/api/consultas', methods=['POST']) - Define rota POST para agendar consulta
• Linha 26: def agendar_consulta(): - Define função para agendar consulta
• Linha 27: """Agenda uma nova consulta""" - Docstring explicando função
• Linha 28: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 30: # Verificar se paciente existe - Comentário explicativo
• Linha 31: paciente = None - Inicializa variável para paciente
• Linha 32: for p in pacientes: - Percorre lista de pacientes
• Linha 33: if p['id'] == dados['paciente_id']: - Verifica se ID do paciente corresponde ao solicitado
• Linha 34: paciente = p - Armazena paciente encontrado
• Linha 35: break - Sai do loop quando paciente é encontrado

25. API de Sistema de Transporte

from flask import Flask, jsonify, request

app = Flask(__name__)

# Banco de dados em memória (simulado)
rotas = [
    {'id': 1, 'origem': 'São Paulo', 'destino': 'Rio de Janeiro', 'distancia': 430, 'tempo_estimado': '5h30min'},
    {'id': 2, 'origem': 'São Paulo', 'destino': 'Brasília', 'distancia': 1060, 'tempo_estimado': '12h00min'},
    {'id': 3, 'origem': 'Rio de Janeiro', 'destino': 'Brasília', 'distancia': 1140, 'tempo_estimado': '13h30min'}
]

passageiros = [
    {'id': 1, 'nome': 'João Silva', 'cpf': '123.456.789-00', 'telefone': '11999999999'},
    {'id': 2, 'nome': 'Maria Santos', 'cpf': '987.654.321-00', 'telefone': '11888888888'}
]

viagens = [
    {'id': 1, 'rota_id': 1, 'passageiro_id': 1, 'data': '2024-01-20', 'horario': '08:00', 'status': 'Confirmada'}
]

@app.route('/api/rotas', methods=['GET'])
def listar_rotas():
    """Lista todas as rotas disponíveis"""
    return jsonify(rotas)

@app.route('/api/viagens', methods=['POST'])
def reservar_viagem():
    """Reserva uma nova viagem"""
    dados = request.get_json()
    
    # Verificar se rota existe
    rota = None
    for r in rotas:
        if r['id'] == dados['rota_id']:
            rota = r
            break
    
    if not rota:
        return jsonify({'erro': 'Rota não encontrada'}), 404
    
    # Verificar se passageiro existe
    passageiro = None
    for p in passageiros:
        if p['id'] == dados['passageiro_id']:
            passageiro = p
            break
    
    if not passageiro:
        return jsonify({'erro': 'Passageiro não encontrado'}), 404
    
    # Criar nova viagem
    nova_viagem = {
        'id': len(viagens) + 1,
        'rota_id': dados['rota_id'],
        'passageiro_id': dados['passageiro_id'],
        'data': dados['data'],
        'horario': dados['horario'],
        'status': 'Confirmada'
    }
    
    viagens.append(nova_viagem)
    
    return jsonify({'mensagem': 'Viagem reservada com sucesso!', 'viagem': nova_viagem}), 201

@app.route('/api/passageiros/<int:passageiro_id>/viagens', methods=['GET'])
def listar_viagens_passageiro(passageiro_id):
    """Lista viagens de um passageiro específico"""
    viagens_passageiro = [v for v in viagens if v['passageiro_id'] == passageiro_id]
    return jsonify(viagens_passageiro)

if __name__ == '__main__':
    app.run(debug=True)

Explicação linha por linha:

• Linha 1: from flask import Flask, jsonify, request - Importa Flask, jsonify e request
• Linha 3: app = Flask(__name__) - Cria instância da aplicação Flask
• Linha 5: # Banco de dados em memória (simulado) - Comentário explicativo
• Linhas 6-10: Define lista de rotas simulando banco de dados
• Linha 12: passageiros = [] - Inicializa lista de passageiros
• Linha 14: viagens = [] - Inicializa lista de viagens
• Linha 16: @app.route('/api/rotas', methods=['GET']) - Define rota GET para listar rotas
• Linha 17: def listar_rotas(): - Define função para listar rotas
• Linha 18: """Lista todas as rotas disponíveis""" - Docstring explicando função
• Linha 19: return jsonify(rotas) - Retorna lista de rotas em JSON
• Linha 21: @app.route('/api/viagens', methods=['POST']) - Define rota POST para reservar viagem
• Linha 22: def reservar_viagem(): - Define função para reservar viagem
• Linha 23: """Reserva uma nova viagem""" - Docstring explicando função
• Linha 24: dados = request.get_json() - Obtém dados JSON enviados na requisição
• Linha 26: # Verificar se rota existe - Comentário explicativo
• Linha 27: rota = None - Inicializa variável para rota
• Linha 28: for r in rotas: - Percorre lista de rotas
• Linha 29: if r['id'] == dados['rota_id']: - Verifica se ID da rota corresponde ao solicitado
• Linha 30: rota = r - Armazena rota encontrada
• Linha 31: break - Sai do loop quando rota é encontrada

13.7 Próximos Passos: Continue Aprendendo!

Parabéns! Você agora domina a criação de APIs REST com Flask! 🎉

13.7.1 O que você aprendeu:

• ✅ Introdução ao Flask: Como funciona o framework web
• ✅ Primeiro servidor: Criando “Hello World” web
• ✅ Rotas e decoradores: Como criar endpoints com @app.route()
• ✅ Retornando JSON: Como usar jsonify() para APIs
• ✅ Métodos HTTP: GET, POST, PUT, DELETE em prática
• ✅ API completa: Sistema de lista de tarefas com CRUD
• ✅ Testando APIs: Como usar curl e navegador
• ✅ Boas práticas: Status codes e tratamento de erros

13.7.2 Desafios para Continuar:

1. Conecte com banco de dados: Use SQLite ou PostgreSQL
2. Adicione autenticação: Implemente login e JWT tokens
3. Crie documentação: Use Swagger/OpenAPI
4. Deploy na nuvem: Publique sua API no Heroku ou AWS

13.7.3 Próximo Capítulo:

No Capítulo 14, vamos aprender sobre Web Scraping com BeautifulSoup! Você vai descobrir como:

• Extrair dados de páginas web
• Usar BeautifulSoup para parsing HTML
• Combinar requests + BeautifulSoup
• Criar sistemas de coleta de dados
• Implementar scraping ético e responsável

🎯 batel.tech: Quer praticar mais? Acesse batel.tech e encontre projetos práticos para aplicar seus conhecimentos de criação de APIs! Lá você pode colaborar com outros desenvolvedores e construir sistemas web incríveis!

---

13.8 Referências Bibliográficas

• Flask Documentation: Official Flask Documentation
• REST API Design: REST API Best Practices
• HTTP Methods: MDN Web Docs
• JSON API: JSON API Specification
• Flask Tutorial: Flask Mega-Tutorial

---

Capítulo 13 concluído! 🎉 Agora você está pronto para criar suas próprias APIs e sistemas web. No próximo capítulo, vamos aprender a extrair dados da web!