⚙️ Introducción a la Línea de Comandos de Python

La línea de comandos de Python es una de las herramientas más poderosas para cualquier programador.
Permite ejecutar instrucciones directamente en el intérprete, probar código al instante, depurar errores y automatizar tareas sin necesidad de abrir un editor.
Comprender su funcionamiento te hará más eficiente, dominarás mejor el lenguaje y podrás trabajar igual de bien en Windows, Linux o macOS.

💻 Terminal y entorno de ejecución

Python puede ejecutarse desde cualquier terminal o consola del sistema.
A continuación, veremos cómo hacerlo en cada sistema operativo.

Una vez abierta la consola, puedes verificar que Python está instalado escribiendo:

python --version

o en algunos sistemas:

python3 --version

La salida debería mostrar algo como:

Python 3.12.1

Si ves ese mensaje, ¡todo está listo para comenzar! 🎉
En caso contrario, asegúrate de haber instalado Python correctamente y de que esté añadido a la variable PATH.

🐍 Iniciar el intérprete interactivo de Python

El intérprete interactivo o modo REPL (Read–Eval–Print–Loop) permite ejecutar comandos Python uno por uno, viendo los resultados al instante.

Para iniciarlo, escribe en tu terminal:

python

O bien:

python3

Verás algo similar a esto:

Python 3.12.1 (main, Jan  1 2025)
[GCC 13.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

El prompt >>> indica que el intérprete está listo para recibir instrucciones.

Por ejemplo, puedes escribir:

print("Hola desde Python CLI!")

Y obtendrás:

Hola desde Python CLI!

Para salir del intérprete, usa exit() o presiona Ctrl + D (en Linux/macOS) o Ctrl + Z + Enter (en Windows).

🎮 Modo interactivo de Python (REPL)

El REPL (Read–Eval–Print–Loop) es el corazón del entorno interactivo.
Cada comando que escribes es:

1. Leído (Read)
2. Evaluado (Eval)
3. Mostrado (Print)
4. Y vuelve al inicio del bucle (Loop)

Este flujo permite probar fragmentos de código, explorar funciones o comprobar errores de forma inmediata, sin crear archivos .py.

🧠 Qué es el REPL

El REPL te ofrece una experiencia de experimentación instantánea: escribes una instrucción y obtienes una respuesta al momento.
Por ejemplo:

>>> 2 + 3
5
>>> nombre = "Javier"
>>> print(f"Hola, {nombre}!")
Hola, Javier!

Cada expresión se evalúa inmediatamente, lo que convierte al REPL en una herramienta excelente para aprender, probar ideas o depurar errores.

⌨️ Comandos útiles dentro del REPL

Por ejemplo:

>>> 10 * 3
30
>>> _ + 5
35

El guion bajo _ guarda el último resultado, una función muy útil cuando haces cálculos rápidos.

💡 Ejemplos prácticos interactivos

El modo interactivo te permite ejecutar pequeñas pruebas en tiempo real. Algunos ejemplos:

>>> mensaje = "Python es genial"
>>> len(mensaje)
17

>>> mensaje.upper()
'PYTHON ES GENIAL'

>>> for i in range(3):
...     print("Hola desde el REPL")
...
Hola desde el REPL
Hola desde el REPL
Hola desde el REPL

Como ves, puedes escribir bucles, funciones y estructuras completas directamente desde la consola.

🚪 Salir del modo interactivo

• exit() o quit()
• Ctrl + D (Linux/macOS)
• Ctrl + Z y luego Enter (Windows)

Consejo profesional 💡: si trabajas mucho con el REPL, usa herramientas mejoradas como bpython o IPython, que ofrecen autocompletado y resaltado de sintaxis.

⬆️ Volver al índice

📂 Ejecutar archivos .py desde la terminal

Además del REPL, la forma habitual de usar Python es ejecutar archivos .py desde la terminal.
Esto te permite empaquetar lógica, pasar argumentos, leer datos y automatizar tareas.

🚀 Ejecutar un script básico

Supón un archivo hola.py con este contenido:

# hola.py
print("Hola desde un script de Python")

Ejecuta el archivo desde tu terminal:

python hola.py
# o según tu sistema
python3 hola.py

Salida:

Hola desde un script de Python

Ejecutar un módulo como script

También puedes ejecutar un módulo (paquete o librería) con la opción -m:

python -m http.server 8080        # Inicia un servidor HTTP simple
python -m venv .venv              # Crea un entorno virtual
python -m pip install requests    # pip como módulo

Otras opciones útiles del intérprete

Shebang (Linux/macOS) y permisos

#!/usr/bin/env python3
print("Script ejecutable")

chmod +x mi_script.py
./mi_script.py

En Windows, normalmente llamarás al intérprete: python mi_script.py.

⚙️ Pasar argumentos desde la línea de comandos

Los programas reales necesitan parámetros (rutas, flags, valores).
Python ofrece dos vías comunes: leer sys.argv directamente o usar el módulo argparse.

Opción 1 — sys.argv (rápido y simple)

# cli_basico.py
import sys

# sys.argv es una lista: [script, arg1, arg2, ...]
if len(sys.argv) < 2:
    print("Uso: python cli_basico.py <nombre>")
    sys.exit(1)

nombre = sys.argv[1]
print(f"Hola, {nombre}!")

python cli_basico.py Javier
# Hola, Javier!

Opción 2 — argparse (profesional y robusto)

# cli_argparse.py
import argparse

parser = argparse.ArgumentParser(
    prog="saludador",
    description="Ejemplo de CLI con argparse."
)
parser.add_argument("nombre", help="Nombre de la persona")
parser.add_argument("-t", "--titulo", default="", help="Título opcional (Sr., Sra., Ing., etc.)")
parser.add_argument("-n", "--repeticiones", type=int, default=1, help="Veces a saludar")
parser.add_argument("-q", "--quiet", action="store_true", help="Silenciar salida")

args = parser.parse_args()

if not args.quiet:
    saludo = f"Hola, {args.titulo + ' ' if args.titulo else ''}{args.nombre}!"
    for _ in range(args.repeticiones):
        print(saludo)

python cli_argparse.py Ana -t Ing. -n 2
# Hola, Ing. Ana!
# Hola, Ing. Ana!

python cli_argparse.py Ana --quiet
# (sin salida)

🧾 Lectura y salida estándar (stdin/stdout/stderr)

La línea de comandos brilla cuando encadenas programas con pipes o redirecciones.
Python se integra perfecto leyendo de stdin y escribiendo a stdout / stderr.

Leer de stdin

# mayus.py
import sys

for linea in sys.stdin:
    sys.stdout.write(linea.upper())

# Usando pipe:
echo "hola mundo" | python mayus.py
# HOLA MUNDO

# Redirigiendo desde archivo:
python mayus.py < entrada.txt > salida.txt

Escribir a stderr para errores

# errores.py
import sys

print("Salida normal", file=sys.stdout)
print("Mensaje de error", file=sys.stderr)

python errores.py 1> out.log 2> err.log
# out.log: Salida normal
# err.log: Mensaje de error

Capturar input() vs stdin

Leer CSV desde stdin (ejemplo real)

# suma_csv.py
import sys, csv

lector = csv.reader(sys.stdin)
total = 0.0
for fila in lector:
    try:
        total += float(fila[-1])  # Suma la última columna
    except (ValueError, IndexError):
        pass  # Ignora líneas no válidas
print(f"TOTAL: {total:.2f}")

cat ventas.csv | python suma_csv.py
# TOTAL: 12345.67

Redirección, pipes y modo sin buffer

# Redirigir stdout a archivo
python script.py > salida.txt

# Redirigir errores (stderr)
python script.py 2> errores.txt

# Encadenar programas con pipes
python genera.py | python procesa.py | python resume.py

# Forzar salida inmediata (logging/progreso)
python -u largo.py

Patrón profesional: separar lógica de I/O

Escribir código testeable implica separar la lógica de negocio de la E/S:

# cli_patron.py
import sys

def transformar(linea: str) -> str:
    return linea.strip().title()

def main(stdin, stdout):
    for linea in stdin:
        stdout.write(transformar(linea) + "\n")

if __name__ == "__main__":
    main(sys.stdin, sys.stdout)

Así podrás probar transformar() con tests sin tocar la terminal.

Checklist rápido (CLI robusta)

• Usa -m para ejecutar módulos estándar y tus paquetes.
• Para CLIs serias, prefiere argparse (o frameworks como Typer/Click).
• Divide lógica de negocio y capa de I/O (fácil de testear).
• Usa stdin/stdout/stderr para integrarte con pipes.
• Activa -u si necesitas flush inmediato en pipelines.

⬆️ Volver al índice

🧩 Explorando bpython

bpython es una alternativa avanzada al intérprete interactivo estándar de Python.
Su propósito es ofrecer una experiencia más fluida, visual y productiva en la terminal, combinando autocompletado, resaltado de sintaxis y una interfaz moderna sin salir de la consola.

Ideal para quienes quieren aprender, prototipar o depurar sin abrir un IDE pesado, bpython convierte el REPL tradicional en una herramienta mucho más cómoda y eficiente.

📘 ¿Qué es bpython?

bpython es un intérprete interactivo mejorado para Python, desarrollado por Bob Farrell y la comunidad open source.
A diferencia del REPL estándar, incluye:

• 🎨 Resaltado de sintaxis con colores en tiempo real.
• ⚡ Autocompletado dinámico de variables, métodos y módulos.
• 🔁 Historial interactivo con edición en línea.
• 📄 Vista previa de docstrings (muestra ayuda sin salir del entorno).
• 💾 Grabación y “replay” de sesiones.
• 🔍 Inspección rápida de objetos.

En resumen, bpython convierte la consola en una mini IDE interactiva.

⚙️ Instalación y configuración

La instalación de bpython es muy sencilla usando pip:

pip install bpython

O si usas un entorno virtual:

python -m venv .venv
source .venv/bin/activate  # Linux / macOS
.venv\Scripts\activate     # Windows
pip install bpython

Para iniciarlo, simplemente escribe en la terminal:

bpython

Verás algo así:

bpython version 0.24 on top of Python 3.12
>>> 

¡Y ya estás dentro!
Puedes comenzar a escribir código Python como en el REPL normal, pero con colores, sugerencias y atajos inteligentes.

💡 Funcionalidades destacadas

1️⃣ Autocompletado inteligente

A medida que escribes, bpython te sugiere variables, funciones o métodos disponibles.

>>> texto = "Hola mundo"
>>> texto.
# (aparece lista: capitalize(), upper(), replace(), etc.)

El autocompletado se basa en introspección, así que muestra solo los métodos aplicables al tipo de objeto.

2️⃣ Resaltado de sintaxis en tiempo real

Cada línea de código se colorea automáticamente, facilitando la lectura del código incluso en sesiones largas.

>>> for i in range(3):
...     print(f"Número {i}")

Esto hace que los errores de indentación y paréntesis sean mucho más fáciles de detectar visualmente.

3️⃣ Docstrings y ayuda instantánea

Si escribes el nombre de una función y presionas ?, bpython mostrará su documentación al instante:

>>> print?
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Perfecto para explorar nuevas funciones o módulos sin necesidad de salir del entorno.

4️⃣ Historial y edición de código

Con las flechas ↑ y ↓ puedes navegar por tu historial de comandos anteriores y editarlos en vivo.
Además, si presionas Ctrl + R, puedes buscar entre comandos previos por palabra clave (similar a Bash).

Y si cometes un error en una línea multilínea, puedes editar todo el bloque fácilmente antes de volver a ejecutarlo.

5️⃣ Guardar y reproducir sesiones

¿Quieres guardar tus pruebas?
Presiona Ctrl + D para salir y el sistema te preguntará si deseas guardar la sesión.

Do you want to save this session? (y/N)

También puedes cargarla más tarde:

bpython --load session.json

Ideal para continuar donde lo dejaste o para documentar ejemplos para clases o proyectos.

6️⃣ Integración con el portapapeles

Puedes copiar bloques de código completos presionando F10, y bpython los guardará directamente en el portapapeles o archivo.

Copied 8 lines to clipboard

Esto es muy útil cuando quieres llevar una prueba rápida al editor o al blog sin volver a escribirla.

⚖️ Comparativa con REPL e IPython

En pocas palabras:

• 🧠 REPL estándar → perfecto para principiantes.
• ⚡ bpython → para quienes buscan rapidez y feedback visual.
• 🔬 IPython → ideal para análisis de datos y entornos Jupyter.

🧰 Comandos rápidos de bpython

🎯 Ejemplo integrador con bpython

Veamos un flujo completo dentro de bpython:

>>> import math
>>> math.
# (autocompletado sugiere: acos, asin, atan, ceil, cos, ...)
>>> math.sqrt(25)
5.0
>>> print?
# muestra la documentación de print()
>>> def cuadrado(x): return x**2
>>> list(map(cuadrado, range(5)))
[0, 1, 4, 9, 16]

Con bpython, todo este proceso resulta inmediato y mucho más cómodo gracias al autocompletado y la vista de ayuda contextual.

⬆️ Volver al índice

🚀 Mejora de flujo de trabajo con la CLI

Optimizar tu flujo en la terminal te ahorra tiempo real. A continuación verás alias/funciones, cómo aprovechar el historial y un set de comandos shell clave para el día a día en Python.

🔖 Alias y atajos útiles

Define alias en tu ~/.bashrc o ~/.zshrc para reducir tecleo y errores. Ejemplos:

# Atajos de Python
alias py="python3"
alias pi="python3 -m pip"
alias pym="python3 -m"

# Entornos virtuales
alias venv="python3 -m venv .venv"
alias va="source .venv/bin/activate"      # Linux/macOS
alias vw=".venv\\Scripts\\activate"       # Windows (PowerShell: .venv\\Scripts\\Activate.ps1)

# Utilidades
alias rmpyc="find . -name '*.pyc' -delete -o -name '__pycache__' -exec rm -r {} +"
alias flake="python3 -m flake8 ."

Tras editarlos: source ~/.bashrc (o source ~/.zshrc) para aplicarlos.

📜 Historial y repetición de comandos

En PowerShell, usa Get-History y Invoke-History (ihy) para funciones equivalentes.

🧰 Comandos shell frecuentes en desarrollo

🪲 Depuración desde la terminal

La depuración en terminal es directa y extremadamente útil en scripts y servidores. El depurador estándar es pdb, aunque puedes usar variantes como ipdb (IPython) según tu stack.

🔍 Uso básico del depurador pdb

Inserta un breakpoint en tu código:

# calcula.py
def dividir(a, b):
    return a / b

def main():
    x, y = 10, 0
    import pdb; pdb.set_trace()  # Punto de ruptura
    print("Resultado:", dividir(x, y))

if __name__ == "__main__":
    main()

Ejecuta el script y entra al depurador donde pusiste set_trace().

También puedes lanzar el depurador sobre un script sin modificarlo:

python -m pdb calcula.py

🎯 Breakpoints y navegación

Crea y gestiona puntos de ruptura sin tocar el código fuente:

python -m pdb app.py
# Dentro de pdb:
(bdb) b 42          # breakpoint en línea 42
(bdb) b app.py:60   # breakpoint en archivo:línea
(bdb) cl 42         # clear breakpoint 42
(bdb) disable 1     # desactivar breakpoint #1
(bdb) enable 1      # reactivar

Consejo: usa tbreak para puntos de ruptura que se eliminan tras dispararse una vez (ideal para pasar inicializaciones largas).

🧠 Depuración con bpython

bpython no es un depurador, pero ayuda a inspeccionar interactivamente: copia fragmentos fallidos, pégalos, invoca funciones con diferentes datos y observa el comportamiento con autocompletado y docstrings visibles.

$ bpython
>>> from calcula import dividir
>>> dividir(10, 0)
# ZeroDivisionError → ahora prueba casos, inspecciona tipos y docstrings

Para depuración paso a paso, usa pdb o su variante ipdb si prefieres la experiencia IPython.

💼 Consejos de productividad

Un buen flujo CLI incluye entornos aislados, instalación controlada de dependencias y mejoras de calidad de vida en la consola.

🧱 Uso de entornos virtuales en la terminal

Aísla dependencias por proyecto con venv. Evitarás choques de versiones y mantendrás reproducibilidad.

# Crear y activar
python -m venv .venv
# Linux/macOS
source .venv/bin/activate
# Windows (CMD)
.venv\\Scripts\\activate.bat
# Windows (PowerShell)
.venv\\Scripts\\Activate.ps1

# Desactivar
deactivate

Guarda tus dependencias en requirements.txt:

pip freeze > requirements.txt
pip install -r requirements.txt

📦 Instalación de paquetes con pip

Pro tip: usa python -m pip para asegurarte de que usas el pip del intérprete activo.

✨ Autocompletado, historial y mejoras visuales

Mejora tu experiencia con herramientas de línea de comandos:

• readline (Linux/macOS): edición estilo Emacs, historial persistente.
• rlwrap (cuando no tienes readline nativo).
• fzf: buscador difuso para directorios/archivos/historial.
• starship: prompt moderno con info de venv y Git.
• direnv: activa/desactiva venv automáticamente al entrar/salir de un proyecto.

# Ejemplo: prompt muestra venv + rama Git
# Instala y configura starship (ver docs del proyecto)
eval "$(starship init bash)"

🧾 Checklist rápido (productividad)

• Alias para python, pip y venv (ahorras tecleo y errores).
• Usa Ctrl + R para buscar comandos anteriores al instante.
• Aísla dependencias con venv y versiona requirements.txt.
• Depura con pdb; para inspecciones rápidas, apóyate en bpython.
• Mejora el prompt (starship), usa fzf y activa entornos con direnv.

⬆️ Volver al índice

🎓 Resumen Final de la Lección

En esta lección has aprendido a trabajar con Python directamente desde la línea de comandos,
una habilidad esencial para cualquier desarrollador profesional.
Desde el REPL clásico hasta bpython, pasando por argparse,
stdin/stdout y la depuración con pdb,
ahora dominas el ciclo completo del desarrollo y la prueba en consola.

🧠 Conceptos clave aprendidos

• Qué es la línea de comandos y cómo usar el intérprete de Python (REPL).
• Ejecución de scripts con python archivo.py y módulos con -m.
• Lectura y escritura desde stdin y stdout.
• Uso de sys.argv y argparse para recibir argumentos CLI.
• Funcionamiento del entorno interactivo bpython.
• Uso del depurador pdb directamente desde la terminal.
• Buenas prácticas con venv, pip, alias y productividad.

Con esto tienes las bases para desarrollar, depurar y automatizar tareas desde la terminal
sin depender de IDEs pesados. 💪

📋 Tablas de referencia rápida

🧾 Comandos esenciales de Python CLI

🧩 Atajos del REPL estándar

💡 Atajos rápidos de bpython

🪲 Comandos esenciales de pdb

🧱 Comandos de entorno virtual y pip

🧩 Prácticas guiadas — Terminal y bpython

🔹 Ejercicio 1 — Probando el intérprete interactivo

Abre tu terminal y escribe:

python

Luego prueba:

>>> nombre = input("¿Cómo te llamas? ")
>>> print(f"Hola, {nombre}!")
>>> 5 * 10
50
>>> _ + 20
70

💬 Comenta con tus alumnos cómo el símbolo _ guarda el último resultado.

🔹 Ejercicio 2 — Ejecutar scripts desde CLI

Crea un archivo saludo.py:

# saludo.py
import sys

if len(sys.argv) < 2:
    print("Uso: python saludo.py <nombre>")
    sys.exit(1)

nombre = sys.argv[1]
print(f"👋 Hola, {nombre}! Bienvenido a Python CLI.")

Ejecuta:

python saludo.py Javier

Resultado:

👋 Hola, Javier! Bienvenido a Python CLI.

🔹 Ejercicio 3 — Explorando con bpython

Instala y abre bpython:

pip install bpython
bpython

Dentro de bpython ejecuta:

>>> import math
>>> math.
# Usa TAB para autocompletar
>>> math.sqrt(16)
4.0
>>> def doble(x): return x*2
>>> list(map(doble, [1,2,3,4]))
[2, 4, 6, 8]

Prueba los atajos: F2 para ver ayuda, Ctrl+L para limpiar pantalla y F10 para copiar el código al portapapeles.

🔹 Ejercicio 4 — Depuración rápida con pdb

Crea un archivo bug.py:

def sumar(a, b):
    return a + b

def main():
    x, y = 5, "10"   # error: sumar int + str
    import pdb; pdb.set_trace()
    print(sumar(x, y))

if __name__ == "__main__":
    main()

Ejecuta:

python bug.py

En la consola:

(Pdb) p x
5
(Pdb) p y
'10'
(Pdb) c
# Error → TypeError: unsupported operand type(s)

Discute cómo pdb ayuda a inspeccionar variables antes del fallo.

🔹 Ejercicio 5 — Automatización con pipes

Crea un archivo mayus.py:

import sys
for linea in sys.stdin:
    print(linea.upper(), end="")

Prueba:

echo "python es divertido" | python mayus.py

Salida:

PYTHON ES DIVERTIDO

💡 Este ejemplo enseña la diferencia entre programas interactivos y aquellos que procesan stdin.

🏁 Conclusión

Con esta lección dominas el flujo completo de trabajo en la línea de comandos de Python.
Desde el uso del REPL, bpython y pdb hasta el manejo de argumentos y pipes,
tienes ahora la base práctica para trabajar de forma profesional, ágil y eficiente.

El dominio de la consola no solo te ahorrará tiempo: te convertirá en un programador más versátil,
capaz de automatizar, probar y desplegar proyectos en cualquier entorno.

💬 Reto final

Combina todo lo aprendido creando una pequeña herramienta:

# contador.py
"""
Script CLI que cuenta líneas, palabras y caracteres
de un archivo o texto recibido por stdin.
"""

import sys

def contar(texto):
    lineas = texto.count("\n") + 1
    palabras = len(texto.split())
    chars = len(texto)
    return lineas, palabras, chars

def main():
    data = sys.stdin.read()
    l, p, c = contar(data)
    print(f"Líneas: {l}, Palabras: {p}, Caracteres: {c}")

if __name__ == "__main__":
    main()

Prueba:

cat leccion.txt | python contador.py

Resultado:

Líneas: 42, Palabras: 278, Caracteres: 1963

¡Y listo! Has construido una herramienta CLI completa, procesando datos desde stdin y devolviendo resultados por stdout — como los profesionales. 🚀

🐍 ¡Enhorabuena! Has completado la lección “Línea de Comandos de Python”.

⬆️ Volver al índice