🔥 Como Criar uma API de Pokémon com Python (e uma interface para batalhar!)
- #Python
🍽️ Parte 1 – O que é uma API? (o garçom, a mesa e a cozinha)
Vamos começar pensando no seguinte cenário: você está num restaurante. você senta na mesa (isso é o front‑end, a parte visível, onde você interage). Na cozinha (o back‑end), os chefs preparam os pratos é onde a lógica acontece, os dados são processados, as regras são aplicadas. E por fim quem leva seu pedido até a cozinha e traz o prato pronto? O garçom. essa é a API.
- Mesa (front‑end): o app/site/interface que o usuário usa;
- Garçom (API): leva a requisição (seu pedido) e traz a resposta (o prato/dados);
- Cozinha (back‑end): faz o trabalho pesado: consulta, valida, transforma e devolve;
Mas por que usar? Porque a API organiza e padroniza como sistemas conversam. Hoje vamos criar uma API de Pokémon; amanhã, um app mobile, um painel web, um bot do discord… Todos podem consumir os mesmos dados pela API. simples, limpo e escalável.
🐉 Parte 2 – Criando a API de Pokémon com Python
A seguir vamos ver como criar essa API Pokemon do zero , utilziando apenas a linguagem python e algumas bibliotecas, e ao final ainda vamos escrevr um código que nos retornará uma interface visual e um bônus ao final desse artigo!
Vamos começar instalando as dependências:
pip install fastapi uvicorn
Agora vamos ver como criar nossa API, primeiro, definimos um “banco de dados” básico em forma de dicionário Python, onde cada chave é o nome de um Pokémon e o valor traz seus detalhes (tipo, poderes e fraqueza).
Em seguida, configuramos duas rotas:
- /: rota inicial, que mostra uma mensagem de boas-vindas e orienta como usar a API.
- /pokemon/{nome}: rota dinâmica, que recebe o nome de um Pokémon e devolve suas informações. Se o nome não existir, retorna uma mensagem de erro.
Na prática, ao rodar esse código, você terá uma API que responde em JSON com informações sobre Pokémon, podendo ser acessada pelo navegador ou por qualquer sistema que consuma dados.
import streamlit as st
import requests
st.set_page_config(page_title="API de Pokémon", page_icon="🐉", layout="centered")
st.title("🐉 API de Pokémon")
st.write("Digite o nome de um Pokémon e veja tipo, poderes e fraqueza.")
nome = st.text_input("Qual Pokémon? (ex: pikachu, charmander, bulbasaur, squirtle)")
if st.button("Buscar"):
if nome:
resp = requests.get(f"http://127.0.0.1:8000/pokemon/{nome}")
if resp.status_code == 200:
dados = resp.json()
if "erro" in dados:
st.error(dados["erro"])
else:
d = dados["detalhes"]
st.success(f"Encontrado: {dados['nome']}")
st.subheader("⚡ Tipo"); st.write(d["tipo"])
st.subheader("💪 Poderes"); st.write(d["poderes"])
st.subheader("🛑 Fraqueza"); st.write(d["fraqueza"])
else:
st.error("Erro ao conectar com a API.")
else:
st.warning("Digite um nome primeiro.")
uvicorn main:app --reload
Para rodar nossa API usamos o seguinte comando, digitado em nosso terminal do VS Code ou sua IDE de escolha, conforme código acima:
- http://127.0.0.1:8000/
- http://127.0.0.1:8000/pokemon/pikachu
🎨 Parte 3 – Interface visual (Streamlit) para consultar a API
Agora vamos criar a parte visual da nosssa aplicação que se conectará a nossa API, para isso vamos usar a biblioteca Streamlit. Em resumo, esse código transforma a API que antes só era acessada pelo navegador em uma página interativa, onde qualquer pessoa pode brincar de buscar Pokémons sem precisar conhecer nada de programação.
- Primeiro, configuramos uma página web com título, ícone e layout centralizado.
- Depois, colocamos um campo de entrada de texto, onde o usuário digita o nome do Pokémon.
- Quando o botão “Buscar” é clicado, o app faz uma requisição HTTP para a API que criamos no FastAPI.
- Se o Pokémon existir, a interface mostra o tipo, os poderes e a fraqueza dele. Caso contrário, aparece uma mensagem de erro.
Vamos começar instalando a biblioteca em nosso sistema:
pip install streamlit requests
Em seguida vamos codar conforme explicado anteriromente:
import streamlit as st
import requests
st.set_page_config(page_title="API de Pokémon", page_icon="🐉", layout="centered")
st.title("🐉 API de Pokémon")
st.write("Digite o nome de um Pokémon e veja tipo, poderes e fraqueza.")
nome = st.text_input("Qual Pokémon? (ex: pikachu, charmander, bulbasaur, squirtle)")
if st.button("Buscar"):
if nome:
resp = requests.get(f"http://127.0.0.1:8000/pokemon/{nome}")
if resp.status_code == 200:
dados = resp.json()
if "erro" in dados:
st.error(dados["erro"])
else:
d = dados["detalhes"]
st.success(f"Encontrado: {dados['nome']}")
st.subheader("⚡ Tipo"); st.write(d["tipo"])
st.subheader("💪 Poderes"); st.write(d["poderes"])
st.subheader("🛑 Fraqueza"); st.write(d["fraqueza"])
else:
st.error("Erro ao conectar com a API.")
else:
st.warning("Digite um nome primeiro.")
E para rodar nosso aplicativo, vamos uar o seguinte código abaixo, digitado novamente em nosso terminal de nossa IDE de escolha:
streamlit run app.py
🕹️ BÔNUS – Transformando em game: tipo X tipo (quem ganha de quem)
Agora que vimos como é simples criar uma API Python e criar uma interface visual simples e rápida, vamos deixar nosso proejto um pouco mais complexo, porpem bem mais divertido. Vamos criar uma lógica de batalha por tipo. a ideia é simples:
- água ganha de fogo
- fogo ganha de planta
- planta ganha de água
- elétrico ganha de água
- empates quando os tipos são iguais
- quando não houver regra direta, dizemos que é indefinido (você pode expandir depois)
1) adicionar endpoint de batalha na API (main.py)
adicione abaixo do dicionário pokemons:
# regras simples de vantagem (você pode expandir depois)
vantagens = {
"agua": ["fogo"],
"fogo": ["planta"],
"planta": ["agua", "terra"], # exemplo de expansão
"eletrico": ["agua"]
}
def resultado_batalha(tipo1: str, tipo2: str) -> str:
if tipo1 == tipo2:
return "empate"
if tipo2 in vantagens.get(tipo1, []):
return "p1"
if tipo1 in vantagens.get(tipo2, []):
return "p2"
return "indefinido"
Agora vamos criar um outro e endpoint, e vamos chama-lo de /batalha:
from fastapi import Query
@app.get("/batalha")
def batalha(p1: str = Query(..., description="nome do primeiro pokémon"),
p2: str = Query(..., description="nome do segundo pokémon")):
a = pokemons.get(p1.lower())
b = pokemons.get(p2.lower())
if not a or not b:
return {"erro": "Pokémon inválido. Use nomes existentes."}
t1, t2 = a["tipo"], b["tipo"]
res = resultado_batalha(t1, t2)
if res == "empate":
vencedor = "empate"
mensagem = f"{p1} ({t1}) e {p2} ({t2}) empataram!"
elif res == "p1":
vencedor = p1.lower()
mensagem = f"{p1} ({t1}) venceu {p2} ({t2})!"
elif res == "p2":
vencedor = p2.lower()
mensagem = f"{p2} ({t2}) venceu {p1} ({t1})!"
else:
vencedor = "indefinido"
mensagem = f"Sem regra direta entre {t1} e {t2}. Defina mais vantagens!"
return {
"p1": {"nome": p1.lower(), "tipo": t1},
"p2": {"nome": p2.lower(), "tipo": t2},
"resultado": vencedor,
"mensagem": mensagem
}
- Podemos testar no navegador usando os endpoints abaixo, ou se quisermos deixra mais divertido. Vamso criar uma interface web!
- http://127.0.0.1:8000/batalha?p1=pikachu&p2=squirtle
- http://127.0.0.1:8000/batalha?p1=charmander&p2=bulbasaur
2) adicionar “Modo Batalha” na interface (app.py)
Abaixo do bloco de busca, vamos adicionar o bloco de código abaixo:
st.divider()
st.header("🎮 Modo Batalha (tipo vs tipo)")
col1, col2 = st.columns(2)
with col1:
p1 = st.text_input("Jogador 1 - Pokémon", placeholder="pikachu")
with col2:
p2 = st.text_input("Jogador 2 - Pokémon", placeholder="squirtle")
if st.button("Lutar!"):
if p1 and p2:
url = f"http://127.0.0.1:8000/batalha?p1={p1}&p2={p2}"
r = requests.get(url)
if r.status_code == 200:
d = r.json()
if "erro" in d:
st.error(d["erro"])
else:
st.write(f"**{d['mensagem']}**")
st.caption(f"Tipos: {d['p1']['nome']}={d['p1']['tipo']} | {d['p2']['nome']}={d['p2']['tipo']}")
else:
st.error("Erro ao conectar com a API.")
else:
st.warning("Preencha os dois Pokémons.")
Pronto! cada jogador digita um pokémon, clica em Lutar! e a regra de tipos decide o vencedor. Depois, é só ir expandindo o dicionário de vantagens (e o catálogo de pokémons) para deixar o game mais completo. Ai o céu é o limite, voce pode adicionar mais pokenons, tipos, e até memso imagens para deixar o game mais divertido e iterativo. Busquei fazer de uma forma bem simples, para que fosse fácil de entender, não colocandomuita complexidade ao mini projeto.
Dica: Para rodar os App.py e Main.py você precisará roda-lo em dois terminais, todando primeiramente sua API, para depois abir o seu app.py, para gerar a parte viaul do seu aplicativo no Visual Studio Code (VSCode).
Dica: Se desejar para sua aplicação digite Ctrl + c em seu terminal.
🏁 Conclusão
Nesse artigo vimos e entendemos o que é uma API com a analogia do restaurante (mesa = front, garçom = API, cozinha = back) entendendo qual o papel da API em nossas aplicações e mostrando como é simples e rápido criar uma API. E entendendo esse conceito, construimos juntos:
- Uma API de Pokémon com FastAPI;
- Criamos uma interface com Streamlit pra consultar a API;
- Adicionamos um modo batalha com regras simples de tipo vs tipo, abrindo caminho pra virar um mini‑game completo.
No fim das contas, programar ficou muito mais acessível, com as ferramentas que temos hoje (FastAPI, Streamlit, etc.), a gente não precisa reinventar a roda, dá pra combinar peças prontas e criar coisas incríveis de forma bem rápida e acessível a todos. Nosso projeto começou bem simpls e foi ganhando complexidade, ee se desejar voce pode adicionar mais features, deixando ele mais completo, adidionando imagens aos pokemons, tipo e pokemons, o importante é se divertir no processo aprendendo junto d euma forma lúdica, visual e palpével.
Se curtiu esse conteúdo ou te ajudou de alguma forma dá um up vote que vai me ajudar bastante!
⭐ Dá uma passada no meu GitHub: github.com/Carlos-CGS
🤝 Conecta comigo no LinkedIn para mais conteúdos como esse: linkedin.com/in/carlos-cgs/
bora construir juntos — uma linha de código por vez. 🚀
