[Copia y Pega y Funciona] ¡Crea una App de CLI del Tiempo con Python y una API! Guía Paso a Paso para Principiantes

"He empezado a programar, pero no sé qué crear..." "Estoy estudiando, pero siento que voy a rendirme porque no consigo construir nada que funcione de verdad..."

Hace solo unos meses, yo tenía exactamente las mismas preocupaciones. Empecé a estudiar por mi cuenta sin ningún conocimiento de programación, con la ayuda de la IA, y ahora soy capaz de gestionar mis propias páginas web. Por mi experiencia, lo más importante en las primeras etapas del aprendizaje es "la vivencia de construir algo con tus propias manos y verlo funcionar".

En este artículo, explicaré con más detalle que en ningún otro sitio cómo crear una sencilla aplicación de línea de comandos (CLI) con Python que te da el pronóstico del tiempo, para que incluso los principiantes en programación puedan sentir la alegría de "¡Funciona! ¡Es divertido!".

Así es como se ve el resultado final. ¿Qué pasa cuando escribes un comando en la terminal (la pantalla negra)...?

$ python weather.py Tokio

[ El tiempo en Tokio (JP) ]
Tiempo: cielo despejado ☀️
Temperatura: 28.5℃ (Sensación térmica: 29.1℃)
Humedad: 65%
Velocidad del viento: 3.1 m/s

¡No es nada difícil! Con solo copiar y pegar, podrás tenerlo funcionando en tu ordenador al instante. Compartiré sinceramente los puntos en los que yo mismo me atasqué, así que puedes seguirme con total confianza.

PASO 1: ¡Prepárate para la aventura! - Consigue una clave de API del tiempo

Primero, está la cuestión de dónde obtener la información meteorológica. Los pronósticos del tiempo que vemos en la tele o en el móvil se basan en datos observados por organismos especializados, como las agencias meteorológicas, ¿verdad?

En esta ocasión, usaremos un servicio llamado OpenWeatherMap. Utilizando el mecanismo que ofrece este servicio, llamado API, podremos obtener datos meteorológicos de todo el mundo libremente en nuestros programas.

No hace falta que te compliques pensando "¿Qué es una API?". Por ahora, imagínala como una especie de "contraseña (clave) para obtener datos del tiempo desde un programa". A continuación, te explico los pasos para conseguir esta clave (clave de API).

Accede a la página de la API de OpenWeatherMap y haz clic en el botón "Subscribe" de "Current Weather Data".
Pulsa el botón "Get API key" del plan gratuito y crea una cuenta (tendrás que configurar tu correo electrónico, contraseña, etc.).
Una vez completado el registro, en la pestaña "API keys" de tu panel de control, se habrá emitido tu clave de API personal. Esta cadena de unos 32 caracteres alfanuméricos es la "contraseña" de la que te hablaba.

【¡Súper importante!】 ¡Nunca le des tu clave de API a nadie ni la publiques en redes sociales o en GitHub!
Esta clave es exclusivamente para tu uso. Si cayera en manos de alguien con malas intenciones, podría realizar una gran cantidad de peticiones no autorizadas y podrías acabar recibiendo una factura. Trátala con el mismo cuidado que la llave de tu casa.

PASO 2: ¡Reúne las herramientas necesarias! - La librería `requests`

Una vez que tienes la clave de la API, el siguiente paso es preparar las herramientas para poder usarla desde Python. Esa herramienta es una librería llamada `requests`.

Una librería es como una "caja de herramientas" que ya viene con un montón de funciones útiles. Con `requests`, puedes acceder a sitios web y APIs con solo unas pocas líneas de código.

Abre la terminal de tu ordenador (Símbolo del sistema o PowerShell en Windows, Terminal en Mac) y ejecuta el siguiente comando.

pip install requests

Si aparece un mensaje como `Successfully installed...`, ¡lo has conseguido! Ya está todo listo para comunicarnos con la API del tiempo.

PASO 3: ¡Probemos algo sencillo para empezar!

Llegó el momento de programar. Para empezar, vamos a escribir un código muy, muy sencillo para obtener el tiempo de una ciudad concreta (en este caso, Tokio). Crea un archivo llamado `weather.py` en tu editor de código y pega el siguiente código.

import requests
import json

# Reemplaza esto con tu clave de API obtenida en el PASO 1
API_KEY = "Pega_tu_clave_de_API_aquí"
CITY_NAME = "Tokyo"

# Construir la URL de la solicitud a la API
api_url = f"https://api.openweathermap.org/data/2.5/weather?q={CITY_NAME}&appid={API_KEY}&units=metric&lang=es"

try:
    # Enviar la solicitud a la API
    response = requests.get(api_url)
    response.raise_for_status() # Lanzar una excepción si hay un error

    # Convertir el resultado de formato JSON a un diccionario de Python
    data = response.json()

    # Mostrar los datos de forma legible
    print(json.dumps(data, indent=2, ensure_ascii=False))

except requests.exceptions.RequestException as e:
    print(f"Ocurrió un error de comunicación: {e}")
except Exception as e:
    print(f"Ocurrió un error inesperado: {e}")

Después de pegar el código, no olvides reemplazar la parte de `API_KEY = "Pega_tu_clave_de_API_aquí"` con tu propia clave de API que obtuviste antes.

Una vez reemplazada, ejecuta este archivo desde la terminal.

$ python weather.py

¿Qué tal ha ido? Si te aparece un montón de texto (datos) como el de abajo, ¡es que lo has logrado!

{
  "coord": {
    "lon": 139.6917,
    "lat": 35.6895
  },
  "weather": [
    {
      "id": 800,
      "main": "Clear",
      "description": "cielo despejado",
      "icon": "01d"
    }
  ],
  "base": "stations",
  "main": {
    "temp": 28.5,
    "feels_like": 29.1,
    "temp_min": 27.21,
    "temp_max": 29.58,
    "pressure": 1012,
    "humidity": 65
  },
  "visibility": 10000,
  "wind": {
    "speed": 3.09,
    "deg": 190
  },
  // ...y mucho más
}

Esto que ves es el estado bruto de los "datos del tiempo actual de Tokio" que nos ha enviado OpenWeatherMap. El siguiente paso consiste en extraer solo la información que necesitamos de este formato de datos llamado JSON.

【Explicación de un punto problemático】Cómo leer datos JSON
JSON se compone de una combinación de `{}` (llaves) y `[]` (corchetes).

`{}`: Representa un diccionario (objeto). Es un conjunto de pares "clave" y "valor". Por ejemplo, `"temp": 28.5` significa que "la clave 'temp' tiene el valor 28.5".
`[]`: Representa una lista (array). Contiene varios datos en orden.

En Python, los `{}` de JSON se pueden tratar como "diccionarios" y los `[]` como "listas", lo que los hace muy compatibles. Por ejemplo, si quieres obtener la temperatura (`temp`), solo tienes que acceder a `temp`, que está dentro del bloque más grande `main`. Por lo tanto, se escribe `data['main']['temp']`. ¡Fácil, ¿verdad?!

PASO 4: ¡Mejoremos la aplicación de verdad!

Ahora empieza lo bueno. En lugar de tener que cambiar el código cada vez, vamos a evolucionarlo para que tenga la forma de una aplicación CLI en condiciones, permitiendo que el usuario introduzca el nombre de una ciudad y mostrando solo la información necesaria de forma clara.

Para esta ocasión, y para crear una aplicación CLI más seria, usaremos la librería estándar de Python `argparse`. Con ella, podrás pasar información al ejecutar el programa, como por ejemplo `python weather.py Madrid`.

Sustituye por completo el contenido de `weather.py` por el siguiente. La forma de gestionar la clave de la API también la hemos cambiado por una más segura.

import requests
import argparse
import os

def get_weather_emoji(weather_main):
    """Devuelve un emoji a partir del nombre del tiempo en inglés"""
    if weather_main == "Clear":
        return "☀️"
    elif weather_main == "Clouds":
        return "☁️"
    elif weather_main == "Rain":
        return "🌧️"
    elif weather_main == "Drizzle":
        return "🌦️"
    elif weather_main == "Thunderstorm":
        return "⛈️"
    elif weather_main == "Snow":
        return "❄️"
    else:
        return "🌫️" # Niebla, Humo, Bruma, Polvo, Niebla densa, Arena, Ceniza, Chubasco, Tornado

def format_weather_data(data):
    """Formatea la respuesta de la API y la devuelve como una cadena de texto"""
    try:
        city_name = data["name"]
        country = data["sys"]["country"]
        weather_description = data["weather"][0]["description"]
        weather_main = data["weather"][0]["main"]
        emoji = get_weather_emoji(weather_main)
        temp = data["main"]["temp"]
        feels_like = data["main"]["feels_like"]
        humidity = data["main"]["humidity"]
        wind_speed = data["wind"]["speed"]

        # Construir la cadena de salida para que sea fácil de leer
        output = f"[ El tiempo en {city_name} ({country}) ]\n"
        output += f"Tiempo: {weather_description} {emoji}\n"
        output += f"Temperatura: {temp}°C (Sensación térmica: {feels_like}°C)\n"
        output += f"Humedad: {humidity}%\n"
        output += f"Velocidad del viento: {wind_speed} m/s"
        
        return output
    except KeyError:
        return "Error al analizar los datos del tiempo. El formato de la respuesta podría ser inválido."

def main():
    # 1. Obtener la clave de la API desde una variable de entorno
    #    para gestionar la clave de forma más segura
    api_key = os.getenv("OPENWEATHERMAP_API_KEY")
    if not api_key:
        print("Error: La variable de entorno 'OPENWEATHERMAP_API_KEY' no está configurada.")
        print("Por favor, configura la clave de la API y vuelve a intentarlo.")
        return # Salir del programa

    # 2. Configurar los argumentos de la línea de comandos
    parser = argparse.ArgumentParser(description="Muestra la información del tiempo actual para una ciudad especificada.")
    parser.add_argument("city", help="El nombre de la ciudad para obtener la información del tiempo (ej: Madrid)")
    parser.add_argument("-u", "--units", choices=["metric", "imperial"], default="metric", 
                        help="Especifica la unidad de temperatura ('metric' para Celsius, 'imperial' para Fahrenheit)")
    
    args = parser.parse_args()
    
    # 3. Enviar la solicitud a la API
    base_url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": args.city,
        "appid": api_key,
        "units": args.units,
        "lang": "es"
    }

    try:
        response = requests.get(base_url, params=params)
        # Lanzar una excepción para los códigos de error 4xx y 5xx
        response.raise_for_status()

        weather_data = response.json()
        
        # 4. Mostrar los resultados
        formatted_output = format_weather_data(weather_data)
        print(formatted_output)

    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 401:
            print("Error: Clave de API inválida. Por favor, comprueba que la clave de API sea correcta.")
        elif e.response.status_code == 404:
            print(f"Error: Ciudad '{args.city}' no encontrada. Por favor, comprueba el nombre de la ciudad.")
        else:
            print(f"Ocurrió un error HTTP: {e}")
    except requests.exceptions.RequestException as e:
        print(f"Ocurrió un error de comunicación: {e}")
    except Exception as e:
        print(f"Ocurrió un error inesperado: {e}")


if __name__ == "__main__":
    main()

【Importante】Cómo configurar de forma segura una clave de API (Variables de entorno)

Ya te comenté que es peligroso escribir la clave de la API directamente en el código. Por eso, vamos a usar un mecanismo llamado "variables de entorno", que también se utiliza en entornos profesionales. Es una forma de que tu propio ordenador memorice la clave de la API.

Para Mac / Linux:

export OPENWEATHERMAP_API_KEY="tu_clave_de_API"

Para Windows (Símbolo del sistema):

set OPENWEATHERMAP_API_KEY="tu_clave_de_API"

Para Windows (PowerShell):

$Env:OPENWEATHERMAP_API_KEY="tu_clave_de_API"

Ejecuta el comando anterior en tu terminal (la configuración se restablecerá cuando cierres la terminal). Con esto, el código `os.getenv("OPENWEATHERMAP_API_KEY")` podrá leer la clave que has configurado en tu PC.

Cuando estés listo, ¡ejecútalo!

$ python weather.py Madrid

¿Se ha mostrado correctamente el tiempo de Madrid?

Ahora, probemos a mostrar el tiempo de Ciudad de México en grados Fahrenheit.

$ python weather.py "Ciudad de Mexico" -u imperial

No olvides rodear el nombre de la ciudad con `"` (comillas dobles) si contiene espacios. Si la temperatura se muestra en grados Fahrenheit (°F), ¡lo has conseguido!

Prueba a introducir a propósito un nombre de ciudad incorrecto o a configurar mal la clave de la API para comprobar que los mensajes de error se muestran correctamente. Esto es lo que se llama un "manejo de errores robusto".

Conclusión: Más allá del "¡Funciona!"

¡Buen trabajo! Ya has completado tu propia y original aplicación CLI de pronóstico del tiempo. Más allá de simplemente copiar y pegar código, deberías haber aprendido lo siguiente:

Cómo obtener datos externos usando una API (`requests`)
Cómo manejar el formato de datos JSON
Cómo gestionar de forma segura las claves de API (variables de entorno)
Cómo crear argumentos para una aplicación CLI seria (`argparse`)
Cómo crear un programa amigable que no se detiene ante errores (`try-except`)
Cómo organizar el código mediante funciones

En el aprendizaje de la programación, lo más importante es acumular estas "pequeñas victorias". Tomando como base la aplicación que has creado hoy, anímate a modificarla con tus propias ideas: "¿Y si ahora muestro varias ciudades a la vez?", "¿Y si añado el pronóstico por horas?", "¿Y si envío los resultados a Telegram?", etc.

¡Usa la "alegría de crear cosas que funcionan" como combustible y sigue aventurándote en el mundo de la programación!

Hacia el siguiente paso

Todo el que programa en Python se encuentra tarde o temprano con los "errores de indentación". No dejes de leer nuestro artículo que explica a fondo por qué ocurren y cómo solucionarlos.

Causas y soluciones para IndentationError