sys y argparse — Información de runtime y parseo de argumentos

Este artículo recorre el módulo sys, que te da acceso al runtime de Python, y el módulo argparse, que estructura los argumentos de línea de comandos. Cubrirás los fundamentos de sys.path / sys.argv / sys.exit y luego pasarás a definir argumentos con conversión de tipo, valores predeterminados y opciones usando ArgumentParser de argparse.

El módulo sys — Leer el runtime de Python

El módulo sys es una biblioteca estándar que te da acceso a información sobre el propio proceso de Python en ejecución. Qué se puede importar (sys.path), qué se pasó desde la línea de comandos (sys.argv), la versión y la plataforma de Python (sys.version / sys.platform) y cómo terminar el proceso (sys.exit) — información y funciones sobre Python mismo viven todas aquí.

`sys.path` es la lista de carpetas que import recorre buscando módulos, escaneadas en orden desde arriba. Con for p in sys.path: puedes imprimir cada carpeta registrada una línea a la vez. En el runtime de Pyodide verás rutas como /lib/python312.zip / /lib/python3.12 / /lib/python3.12/lib-dynload / /lib/python3.12/site-packages, mientras que una instalación normal de Python lista la carpeta de la biblioteca estándar y site-packages (donde van las bibliotecas instaladas con pip).

Saca la plataforma y el contenido del path de búsqueda de módulos del módulo sys y muéstralos. El módulo sys te da acceso a información sobre el proceso de Python en ejecución.

① Importa el módulo sys

② Usa sys.platform para imprimir el runtime con la forma Plataforma: ◯◯

③ Recorre sys.path con for e imprime cada entrada en su propia línea (reemplaza las cadenas vacías '' por una etiqueta más clara)

(Si tu código se ejecuta correctamente, aparecerá la explicación.)

sys.platform es un atributo que devuelve el identificador del SO como cadena. En el runtime Pyodide del navegador muestra emscripten (en una máquina real verás darwin (Mac) / win32 (Windows) / linux). Se usa cuando necesitas ramificar según el sistema operativo.

import sys

print("Plataforma:", sys.platform)
# Mac:     Plataforma: darwin
# Windows: Plataforma: win32
# Linux:   Plataforma: linux
# Navegador: Plataforma: emscripten

sys.argv y argparse — Manejar argumentos de línea de comandos

En una instalación de Python real, cuando ejecutas un comando como python script.py user_name 42, los tokens aterrizan en sys.argv como una lista de cadenas. sys.argv[0] es el nombre del script y sys.argv[1:] contiene los argumentos que pasaste. El módulo argparse es una biblioteca estándar que lee sys.argv y lo convierte en un objeto al que accedes por atributo, permitiéndote declarar conversión de tipo, valores predeterminados y restricciones de opciones de forma limpia.

# script.py (pensado para ejecutarse en una instalación de Python real)
import sys

print(sys.argv)
# Ejemplo: ejecutar python script.py user_name 42 produce
# ['script.py', 'user_name', '42']

# Los argumentos reales empiezan en [1:]
args = sys.argv[1:]
print(args)         # ['user_name', '42']

sys.argv está esencialmente vacío en el navegador

El runtime del navegador que usa esta serie no tiene línea de comandos en absoluto, así que sys.argv solo contiene un valor fijo como ['<exec>']. Comprueba el comportamiento en máquina real en el bloque code de arriba; en la práctica sustituirás pasando una lista directamente en lugar de sys.argv.

En cuanto empiezas a desarmar `sys.argv` a mano, te topas inmediatamente con requisitos como convertir cadenas a números, soportar flags opcionales o imprimir un mensaje de uso con --help. Python incluye argparse como biblioteca estándar para encargarse de todo eso por ti, y el flujo básico son tres pasos — crear un ArgumentParser, registrar los argumentos que quieres recibir con add_argument y luego convertirlos en valores con parse_args.

# Estilo Python en máquina real
import argparse

parser = argparse.ArgumentParser(description="CLI de búsqueda de productos")
parser.add_argument("--keyword", required=True)         # se pasa como --keyword Apple
parser.add_argument("--limit", type=int, default=10)    # convertido automáticamente a int

args = parser.parse_args()                              # lee sys.argv[1:]
print(args.keyword, args.limit)

En el navegador, usa la forma parse_args(list)

Como el runtime del navegador no tiene sys.argv, llamar a parse_args() sin argumentos lanza un error. Usa la misma forma de pasar lista que usarías en pruebas — parse_args(["--keyword", "Apple", "--limit", "5"]). En una máquina real, omitir esa lista usa automáticamente sys.argv[1:].

Construye el parser de argumentos para una CLI de búsqueda de productos con argparse. Crea un parser que acepte dos opciones, --keyword y --limit, y luego parsea una lista de argumentos simulada.

En una instalación de Python real, llamar a parse_args() sin argumentos lee sys.argv automáticamente, pero como este ejercicio corre en el navegador, le pasarás manualmente una lista a parse_args() en lugar de sys.argv.

① Importa argparse y crea un parser

② Registra los dos argumentos --keyword y --limit

③ Parsea la lista ["--keyword", "Apple", "--limit", "5"] (como el navegador no tiene sys.argv real, pasa la lista directamente)

④ Saca keyword y limit del resultado parseado e imprímelos en una sola línea, separados por un espacio

argparse en profundidad — Conversión de tipo, predeterminados, opciones

add_argument tiene varias opciones que controlan cómo se comporta un argumento. Cuatro de ellas cubren casi todos los casos prácticos de CLI.

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("--keyword", required=True)
parser.add_argument("--limit", type=int, default=10)
parser.add_argument("--order", choices=["asc", "desc"], default="asc")

args = parser.parse_args(["--keyword", "Apple", "--limit", "5", "--order", "desc"])
print(args.keyword, args.limit, args.order)
# -> Apple 5 desc

Combinar type y default

Cuando especificas ambos type=int, default=10, el argumento toma 10 (int) cuando se omite, y el valor pasado se convierte a int cuando se proporciona. Los valores predeterminados no pasan por la conversión de tipo, así que escribe el predeterminado ya en el tipo objetivo. Escribir default="10" pondría la cadena "10" solo cuando el argumento se omite — un bug sutil.

Define los argumentos para una CLI de búsqueda de inventario, completa con conversión de tipo, valores predeterminados y opciones. Confirma que omitir --limit cae al valor predeterminado.

En una máquina real, parse_args() sin argumentos lee sys.argv automáticamente, pero como estás corriendo en el navegador, pasarás directamente una lista de argumentos simulada.

① Importa argparse y crea un parser

② Registra estos tres argumentos

- --keyword: obligatorio

- --limit: tipo entero, predeterminado a 10

- --order: o asc o desc, predeterminado a asc

③ Parsea una lista equivalente a --keyword Banana --order desc (omitiendo --limit)

④ Imprime los tres valores, keyword, limit y order, en una sola línea separados por espacios

sys.exit — Devolver un código de salida

sys.exit(code) es una función que toma un número y termina el proceso. Por convención, 0 significa éxito y cualquier valor distinto de cero (normalmente 1) significa fallo, y los sistemas CI y los scripts de shell ramifican según este valor para decidir qué hacer a continuación. Internamente, lanza una excepción SystemExit. Puedes capturarla con try / except, pero normalmente la dejas propagarse para que el proceso salga.

import sys

price = -100

if price < 0:
    print("Error: el precio es negativo")
    sys.exit(1)         # nada después de este punto se ejecuta

print("Continuando...")  # solo se ejecuta cuando price >= 0

Escribe una validación de inventario con sys.exit. Cuando llega un conteo de stock negativo, el programa debe fallar y el código posterior no debe ejecutarse.

① Importa sys

② Establece el conteo de stock a -3 (para simular un valor malo)

③ Si el stock es negativo, imprime Error: stock es negativo y luego termina el proceso con código de salida 1

④ Fuera del if, imprime el stock con la forma Stock OK: ◯◯ (esto no debería ejecutarse cuando el stock es negativo)