¿Cuál es el Pokémon más pesado? Análisis con Python y PokeAPI

¿Alguna vez te has preguntado cuál es el Pokémon más pesado, cuál pesa menos o cuál es el Pokémon más pequeño? En este proyecto vamos a responder algunas de estas preguntas utilizando Python, Jupyter Notebook, Pandas y PokeAPI.

La idea es utilizar los datos disponibles en una API para realizar un pequeño análisis de datos y posteriormente convertir algunos de los resultados en contenido para YouTube Shorts.

¿Qué es PokeAPI?

PokeAPI es una API pública que proporciona información sobre Pokémon. Podemos consultar datos como:

• Nombre del Pokémon
• ID de la Pokédex
• Peso
• Altura
• Tipos
• Habilidades
• Estadísticas
• Imágenes
• Movimientos
• Experiencia base

Para este análisis utilizamos el endpoint de Pokémon de PokeAPI.

¿Cuántos Pokémon podemos consultar?

Primero podemos consultar cuántos registros están disponibles actualmente en la API.

import requests

url = "https://pokeapi.co/api/v2/pokemon/?limit=1"

response = requests.get(url)
data = response.json()

total_pokemon = data["count"]

print("Total de Pokémon:", total_pokemon)

En nuestro análisis obtuvimos 1,351 registros.

Posteriormente obtenemos la lista completa:

url = f"https://pokeapi.co/api/v2/pokemon/?limit={total_pokemon}"

response = requests.get(url)
data = response.json()

print("Registros obtenidos:", len(data["results"]))

Es importante entender que esta consulta nos proporciona principalmente el nombre y la URL de cada Pokémon. Para obtener información como el peso y la altura necesitamos consultar los detalles de cada Pokémon.

Obtener el peso y la altura

Creamos una lista para almacenar los datos que vamos obteniendo:

pokemon_data = []

for pokemon in data["results"]:

    detalle = requests.get(pokemon["url"]).json()

    pokemon_data.append({
        "id": detalle["id"],
        "nombre": detalle["name"].capitalize(),
        "peso_kg": detalle["weight"] / 10,
        "altura_m": detalle["height"] / 10
    })

Después convertimos la información en un DataFrame de Pandas:

import pandas as pd

df_pokemon = pd.DataFrame(pokemon_data)

Ahora tenemos una tabla que podemos utilizar para realizar diferentes consultas y análisis.

¿Cuál es el Pokémon menos pesado?

Podemos ordenar los Pokémon de menor a mayor peso:

df_pokemon.sort_values("peso_kg").head(10)

Durante nuestro análisis encontramos varios Pokémon con pesos muy bajos. Para este ejercicio seleccionamos a:

0.1 kg equivalen a 100 gramos.

Para obtener automáticamente el registro con menor peso podemos utilizar:

pokemon_menos_pesado = df_pokemon.loc[
    df_pokemon["peso_kg"].idxmin()
]

print(pokemon_menos_pesado)

¿Cuál es el Pokémon más pesado?

Ahora hacemos exactamente lo contrario y ordenamos los datos de mayor a menor peso:

df_pokemon.sort_values(
    "peso_kg",
    ascending=False
).head(10)

El resultado que seleccionamos y validamos fue:

Eso equivale aproximadamente a una tonelada.

Para obtener el registro automáticamente:

pokemon_mas_pesado = df_pokemon.loc[
    df_pokemon["peso_kg"].idxmax()
]

print(pokemon_mas_pesado)

¿Cuál es el Pokémon más alto?

La misma técnica puede utilizarse para encontrar el Pokémon con mayor altura:

pokemon_mas_alto = df_pokemon.loc[
    df_pokemon["altura_m"].idxmax()
]

print("Nombre:", pokemon_mas_alto["nombre"])
print("Altura:", pokemon_mas_alto["altura_m"], "m")
print("Peso:", pokemon_mas_alto["peso_kg"], "kg")

También podemos revisar los primeros resultados para validar los datos:

df_pokemon.sort_values(
    "altura_m",
    ascending=False
).head(10)

En este proyecto decidimos validar manualmente los resultados antes de utilizarlos en el contenido final, especialmente porque PokeAPI incluye diferentes formas de algunos Pokémon.

¿Cuál es el Pokémon más pequeño?

Para encontrar el Pokémon con menor altura utilizamos:

pokemon_mas_pequeno = df_pokemon.loc[
    df_pokemon["altura_m"].idxmin()
]

print(pokemon_mas_pequeno)

En nuestro análisis seleccionamos:

Esto significa que su altura registrada es de aproximadamente 20 centímetros.

Mostrar la imagen del Pokémon con Python

PokeAPI también proporciona imágenes que podemos utilizar desde Python. Por ejemplo, podemos consultar la imagen oficial de Sinistea:

from IPython.display import Image, display
import requests

pokemon_id = 854

url = f"https://pokeapi.co/api/v2/pokemon/{pokemon_id}"

pokemon = requests.get(url).json()

imagen_url = pokemon[
    "sprites"
]["other"]["official-artwork"]["front_default"]

display(
    Image(
        url=imagen_url,
        width=400
    )
)

Esto permite combinar programación, consumo de APIs y visualización de datos directamente dentro de Jupyter Notebook.

Validación de los datos

Una parte importante de este proyecto fue no confiar ciegamente en el primer resultado obtenido. Primero utilizamos Python para encontrar los valores máximos y mínimos y después revisamos los resultados.

Esto es especialmente útil cuando trabajamos con APIs que incluyen formas especiales o variantes de Pokémon. Un análisis de datos no consiste únicamente en encontrar el valor máximo o mínimo: también es importante revisar si el resultado tiene sentido.

De un análisis de datos a un YouTube Short

Una de las razones por las que realizamos este proyecto fue convertir los resultados en preguntas para un Short.

También podemos crear preguntas como:

• ¿Cuál es el Pokémon más ligero?
• ¿Cuál es el Pokémon más pesado?
• ¿Cuál es el Pokémon más alto?
• ¿Cuál es el Pokémon más pequeño?
• ¿Cuál tiene mayor ataque?
• ¿Cuál tiene mayor defensa?
• ¿Cuál tiene mayor velocidad?

¿Qué podemos hacer después?

Este proyecto puede crecer mucho más. Podemos utilizar las estadísticas de los Pokémon para crear nuevos análisis y preguntas.

Por ejemplo, podemos analizar ataque, defensa, velocidad, HP, tipos, habilidades y otras características disponibles en PokeAPI.

De esta manera podemos seguir un flujo completo:

API → Python → Pandas → Análisis de datos → Visualización → YouTube Shorts

Conclusión

Este proyecto demuestra que una API pública puede convertirse en una fuente de datos para practicar programación y Data Science.

Con Python podemos consultar cientos de registros, transformarlos en un DataFrame y responder preguntas utilizando operaciones sencillas como idxmin(), idxmax() y sort_values().

Además, el resultado del análisis puede utilizarse para crear contenido educativo y entretenido sobre Pokémon.

Fuente de datos: documentación oficial de PokeAPI.

Este contenido utiliza datos públicos de PokeAPI con fines educativos y de entretenimiento. Pokémon y sus elementos relacionados son marcas de sus respectivos propietarios.