Home / Lenguajes / Rich en Python: terminales con color, tablas y barras de progreso
Rich en Python: terminales con color, tablas y barras de progreso

Rich en Python: terminales con color, tablas y barras de progreso

20 November 2026 · 20 min de lectura ··

Por qué merece la pena cuidar la salida de tus scripts

Casi todos empezamos a programar en Python con print(). Funciona, es inmediato y no exige configuración. El problema aparece cuando el script crece: un listado de cien líneas sin estructura, un diccionario anidado que se desborda en una sola línea ilegible, un proceso largo que parece colgado porque no muestra nada durante minutos. La terminal es la interfaz de muchas herramientas internas, y una interfaz pobre te hace perder tiempo cada vez que depuras o ejecutas algo.

Rich es una biblioteca que resuelve justamente esto. Con muy poco código te permite imprimir texto con color y estilo, dibujar tablas con bordes, agrupar información en paneles, mostrar jerarquías como árboles, resaltar sintaxis, renderizar Markdown y, sobre todo, mostrar barras de progreso y spinners que informan al usuario de lo que está pasando. Además mejora los mensajes de error y los logs, dos cosas que cualquier desarrollador consulta a diario.

En este tutorial vamos a recorrer Rich con un enfoque práctico y distinto al de un juego: construiremos poco a poco una pequeña utilidad de línea de comandos que revisa el estado de varios servicios ficticios de una empresa, y por el camino veremos cada pieza importante de la biblioteca. Si prefieres ver Rich aplicado a un proyecto completo y lúdico, ya publicamos cómo construir un clon de Wordle con Python y Rich en terminal, que se centra en el tablero y el color de las letras. Aquí iremos más hacia herramientas de trabajo: informes, logs, procesos largos y depuración.

Al terminar sabrás instalar Rich, imprimir con markup, usar Console, crear tablas, paneles, columnas y árboles, mostrar progreso de una o varias tareas, integrar logs con el módulo estándar logging, mejorar los tracebacks y evitar los errores más habituales cuando la salida no va a una terminal interactiva.

Preparar el entorno e instalar Rich

La versión estable actual de Rich es la 15.0.0, publicada en abril de 2026, y la rama estable de Python es la 3.14. Rich es una dependencia de Python puro y funciona en Linux, macOS y Windows, incluida la terminal moderna de Windows. Aun así, te recomiendo trabajar siempre dentro de un entorno virtual para no ensuciar la instalación global del sistema. Si todavía no dominas ese flujo, repasa cómo instalar paquetes Python con pip y entornos virtuales.

Crea una carpeta para el ejercicio, activa un entorno y instala la biblioteca:

mkdir panel-servicios
cd panel-servicios
python3 -m venv .venv
source .venv/bin/activate
pip install rich

En Windows, la activación se hace con .venv\Scripts\activate. Para comprobar la versión instalada puedes pedírsela a pip:

pip show rich

La salida incluirá el nombre, la versión y la licencia. Rich trae además una demostración integrada que sirve para comprobar de un vistazo qué soporta tu terminal: colores, estilos, tablas, Markdown, emojis y más.

python -m rich

Si ves los colores y los recuadros bien dibujados, tu terminal está lista. Si algo sale con caracteres extraños, probablemente se trate de la fuente o de la codificación; lo trataremos en la sección de problemas habituales.

Primeros pasos con print y el markup de Rich

La forma más rápida de empezar es sustituir la función print por la que ofrece Rich. Se puede importar con otro nombre para no pisar la original:

from rich import print as rprint

estado = {
    "servicio": "facturacion",
    "activo": True,
    "puertos": [8080, 8443],
    "ultima_revision": None,
}

rprint(estado)
rprint("Revisando servicios...")

Sin configurar nada, Rich colorea los valores según su tipo: los números de un color, las cadenas de otro, los booleanos y None con tonos propios. Además, las estructuras anidadas se imprimen de forma legible y respetan el ancho de la terminal, rompiendo líneas cuando hace falta en lugar de dejar una cadena kilométrica.

Si quieres reemplazar print en todo el archivo, hay una alternativa más agresiva: from rich import print sin alias. Funciona igual, pero conviene reservarla para scripts pequeños, porque cambia el comportamiento de una función que el resto del equipo da por conocida.

El lenguaje de marcas entre corchetes

Rich incorpora un markup inspirado en BBCode. Se escribe con etiquetas entre corchetes y se cierra con una barra. Por ejemplo, [bold red] activa negrita y rojo, y [/bold red] lo desactiva. Una etiqueta de cierre vacía, [/], cierra la última abierta.

from rich import print as rprint

rprint("[bold green]OK[/bold green] base de datos accesible")
rprint("[yellow]AVISO[/yellow] la caché responde lento: [italic]420 ms[/italic]")
rprint("[bold white on red] ERROR [/bold white on red] cola de mensajes caída")
rprint("[underline cyan]Resumen:[/] 2 correctos, 1 con avisos, 1 con errores")

La sintaxis white on red indica color de texto sobre color de fondo. Puedes usar nombres de color estándar, números del 0 al 255 de la paleta ampliada, códigos hexadecimales como #ff8800 o expresiones rgb(255,136,0). Rich adapta el color a lo que soporte la terminal: si solo admite 16 colores, aproxima el resto.

Un detalle que conviene conocer: el markup se interpreta siempre, así que si imprimes texto que contiene corchetes, como una lista escrita a mano o una ruta con índices, Rich puede intentar leer una etiqueta donde no la hay. Para evitarlo, usa rich.markup.escape o desactiva el markup en esa llamada, como veremos con Console.

También hay emojis mediante códigos entre dos puntos, por ejemplo :rocket: o :warning:. Son cómodos para dar énfasis, aunque en informes serios conviene usarlos con moderación y comprobar que la terminal destino los dibuja correctamente.

La clase Console: el centro de todo

rprint es práctico, pero la API principal de Rich gira alrededor de rich.console.Console. Un objeto Console representa la terminal de salida y decide cómo se renderiza cada cosa: ancho disponible, soporte de color, si la salida es interactiva, si debe guardarse en un archivo, etc.

from rich.console import Console

consola = Console()

consola.print("Inicio del chequeo", style="bold blue")
consola.print("Servicio [cyan]auth[/cyan] disponible")
consola.rule("[bold]Resultados[/bold]")
consola.print_json('{"servicio": "auth", "latencia_ms": 38}')
consola.out("Texto sin interpretar markup [no-etiqueta]")

Cada método tiene su utilidad. print acepta cualquier objeto renderizable y parámetros de estilo, alineación y resaltado. rule dibuja una línea horizontal con un título opcional, perfecta para separar secciones de un informe. print_json formatea y colorea una cadena JSON, algo muy útil cuando depuras respuestas de una API. out escribe de forma más directa, sin interpretar markup, lo que lo hace adecuado para texto que no controlas.

Una práctica sensata es crear una única instancia de Console en un módulo y reutilizarla en toda la aplicación. Así todos los mensajes comparten configuración y, si más adelante quieres redirigir la salida, lo cambias en un solo sitio.

Resaltado automático y opciones útiles

Por defecto, Console.print resalta números, URLs, rutas, cadenas entre comillas y otros patrones frecuentes. Puedes desactivarlo con highlight=False en una llamada concreta o al construir la consola. De forma parecida, markup=False evita que se interpreten los corchetes. Estas dos opciones son la forma limpia de imprimir datos externos sin sorpresas:

from rich.console import Console

consola = Console()
entrada_usuario = "[rojo] intento de inyeccion de [etiquetas]"

consola.print(entrada_usuario, markup=False, highlight=False)

Otras opciones del constructor que usarás a menudo son width para fijar el ancho, stderr=True para escribir en la salida de errores, record=True para poder exportar lo impreso y force_terminal o no_color para controlar el comportamiento en entornos no interactivos.

Registrar mensajes con console.log

Además de print, existe console.log, que antepone la hora y el archivo y línea desde donde se llamó. Es un pequeño sistema de trazas sin configurar nada.

from rich.console import Console

consola = Console()


def combinar_configuracion(base, extra):
    resultado = dict(base)
    resultado.update(extra)
    consola.log("Configuración combinada", resultado, log_locals=True)
    return resultado


combinar_configuracion({"reintentos": 3, "modo": "seguro"}, {"reintentos": 5})

El parámetro log_locals=True añade una tabla con las variables locales de la función en ese momento. Para depurar es oro: en lugar de llenar el código de print(variable), obtienes una instantánea ordenada del contexto completo de la función. Eso sí, no lo dejes activado en producción si tus variables pueden contener secretos como tokens o contraseñas, porque acabarían impresas en claro.

Inspeccionar objetos con inspect

Cuando trabajas con una biblioteca que no conoces, la función help() integrada de Python produce un texto largo y poco amigable. Rich ofrece inspect, que genera un informe compacto y coloreado de cualquier objeto.

from rich import inspect

servicios = ["auth", "pagos", "correo"]
inspect(servicios, methods=True)

Con methods=True lista también los métodos disponibles con su firma y la primera línea de su documentación. Si lo usas sin ese parámetro, verás solo los atributos y una descripción breve. Con all=True incluye además los atributos privados y especiales, útil cuando estás explorando a fondo una clase ajena. Es una herramienta excelente para sesiones interactivas: abres el intérprete, importas un objeto y lo inspeccionas en segundos, sin saltar a la documentación web.

Tablas para presentar datos

Las tablas son probablemente la característica de Rich que más se usa en herramientas reales. La clase Table permite definir columnas, añadir filas y ajustar estilo y alineación.

from rich.console import Console
from rich.table import Table

consola = Console()

tabla = Table(title="Estado de servicios", caption="Revisión automática")
tabla.add_column("Servicio", style="cyan", no_wrap=True)
tabla.add_column("Latencia (ms)", justify="right")
tabla.add_column("Estado", justify="center")

tabla.add_row("auth", "38", "[green]OK[/green]")
tabla.add_row("pagos", "412", "[yellow]LENTO[/yellow]")
tabla.add_row("correo", "-", "[bold red]CAÍDO[/bold red]")

consola.print(tabla)

Fíjate en que las celdas aceptan markup, de modo que puedes colorear el estado según su valor. La tabla se adapta al ancho de la terminal: si no cabe, Rich recorta o envuelve el contenido según la configuración de cada columna. Con no_wrap=True evitas que una columna se parta en varias líneas, y con overflow eliges cómo cortar el texto sobrante.

Personalizar el aspecto

El constructor de Table admite muchos parámetros. Los más útiles son show_lines para dibujar una línea entre filas, row_styles para alternar colores y facilitar la lectura, box para cambiar el tipo de borde y show_header o show_footer para controlar encabezados y pies.

from rich import box
from rich.console import Console
from rich.table import Table

consola = Console()

tabla = Table(
    title="Tareas pendientes",
    box=box.ROUNDED,
    row_styles=["", "dim"],
    header_style="bold magenta",
)
tabla.add_column("Id", justify="right")
tabla.add_column("Tarea")
tabla.add_column("Responsable")

tabla.add_row("1", "Rotar certificados", "Marta")
tabla.add_row("2", "Actualizar dependencias", "Luis")
tabla.add_row("3", "Revisar alertas nocturnas", "Ana")

consola.print(tabla)

Los estilos alternos con row_styles hacen que tablas largas sean mucho más fáciles de seguir con la vista. Y si la información procede de una lista de diccionarios, basta un bucle para generar las columnas desde las claves y las filas desde los valores. Una buena práctica es convertir siempre los valores a cadena antes de pasarlos a add_row, porque la tabla espera texto o elementos renderizables, no números sueltos.

Paneles, columnas y composición de elementos

Un Panel encierra cualquier contenido dentro de un recuadro con título opcional. Sirve para destacar mensajes, agrupar información o crear tarjetas.

from rich.console import Console
from rich.panel import Panel

consola = Console()

consola.print(
    Panel(
        "El servicio de pagos supera el umbral de latencia desde hace 10 minutos.",
        title="[bold yellow]Alerta[/bold yellow]",
        subtitle="turno de noche",
        border_style="yellow",
        padding=(1, 2),
    )
)

El valor padding=(1, 2) define un margen interior vertical y horizontal. Si no quieres que el panel ocupe todo el ancho, usa expand=False y se ajustará al contenido.

Cuando tienes varios elementos pequeños, la clase Columns los distribuye en una cuadrícula que se adapta al ancho disponible. Combinada con paneles, permite construir pequeños paneles de control:

from rich.columns import Columns
from rich.console import Console
from rich.panel import Panel

consola = Console()

servicios = {
    "auth": "activo",
    "pagos": "lento",
    "correo": "caído",
    "búsqueda": "activo",
    "informes": "activo",
}

tarjetas = [
    Panel(f"[b]{nombre}[/b]\n{estado}", expand=True)
    for nombre, estado in servicios.items()
]

consola.print(Columns(tarjetas, equal=True, expand=True))

Con equal=True todas las tarjetas tienen el mismo ancho, y con expand=True se reparten el espacio de la fila. Si redimensionas la terminal y vuelves a ejecutar el script, las tarjetas se reorganizan en más o menos columnas.

Para composiciones más complejas existen Layout, que divide la pantalla en regiones, Group, que agrupa varios renderizables como uno solo, y Align y Padding, que controlan la posición y el espacio. Todo lo que Rich sabe imprimir puede anidarse dentro de otro elemento, por eso una tabla puede vivir dentro de un panel y un panel dentro de una columna.

Árboles para mostrar jerarquías

Cuando la información es jerárquica, un árbol comunica mucho mejor que una lista plana. Rich ofrece Tree, y cada nodo se añade con add, que devuelve el nuevo nodo para poder seguir anidando.

from rich.console import Console
from rich.tree import Tree

consola = Console()

arbol = Tree("[bold]Infraestructura[/bold]")

produccion = arbol.add("[green]produccion[/green]")
produccion.add("api-gateway")
base = produccion.add("bases de datos")
base.add("principal")
base.add("réplica de lectura")

pruebas = arbol.add("[yellow]pruebas[/yellow]")
pruebas.add("api-gateway")
pruebas.add("[dim]base de datos (apagada)[/dim]")

consola.print(arbol)

Los árboles son ideales para representar estructuras de carpetas, dependencias, organigramas o el resultado de un análisis estático. Puedes personalizar el estilo de las guías con el parámetro guide_style y colapsar ramas con expanded=False en add.

Hay una variante que a muchos desarrolladores les resulta cómoda: construir el árbol de forma recursiva a partir de un directorio real con pathlib. Una función de pocas líneas que recorra Path.iterdir() y vaya llamando a add para cada archivo o carpeta produce un tree coloreado, sin depender de herramientas externas.

Barras de progreso y estados para procesos largos

Un script que tarda y no dice nada genera desconfianza, así que conviene mostrar barras de progreso siempre que el proceso dure. Rich cubre este caso con tres niveles de complejidad creciente.

Envolver un iterable con track

El caso más simple consiste en envolver el bucle con track. Rich calcula el porcentaje, la velocidad y el tiempo restante:

import time

from rich.progress import track

archivos = [f"informe_{n}.csv" for n in range(40)]

for archivo in track(archivos, description="Procesando archivos..."):
    time.sleep(0.05)

Si el iterable no tiene longitud conocida, pasa total= para que la barra sepa cuál es el objetivo. Para un generador sin final claro, Rich muestra una barra indeterminada.

Spinners con console.status

A veces no hay un total medible, solo una espera. Para eso sirve console.status, que muestra un spinner animado mientras se ejecuta un bloque y permite actualizar el mensaje:

import time

from rich.console import Console

consola = Console()

with consola.status("[bold green]Conectando con el clúster...") as estado:
    time.sleep(1.5)
    consola.log("Conexión establecida")
    estado.update("[bold green]Descargando configuración...")
    time.sleep(1.5)
    consola.log("Configuración descargada")

Los mensajes de consola.log aparecen por encima del spinner sin romperlo, de modo que puedes registrar hitos mientras el indicador sigue girando.

Varias tareas a la vez con Progress

Para flujos con varias etapas o varios trabajos en paralelo, la clase Progress usada como gestor de contexto es la herramienta adecuada. Se añaden tareas con add_task y se avanzan con advance o update:

import time

from rich.progress import (
    BarColumn,
    Progress,
    TaskProgressColumn,
    TextColumn,
    TimeRemainingColumn,
)

with Progress(
    TextColumn("[bold blue]{task.description}"),
    BarColumn(),
    TaskProgressColumn(),
    TimeRemainingColumn(),
) as progreso:
    copia = progreso.add_task("Copia de seguridad", total=100)
    indices = progreso.add_task("Reconstruir índices", total=60)
    envio = progreso.add_task("Enviar informe", total=30)

    while not progreso.finished:
        progreso.advance(copia, 2)
        progreso.advance(indices, 1.5)
        progreso.advance(envio, 0.8)
        time.sleep(0.05)

Aquí hemos personalizado las columnas que se muestran. Por defecto, Progress incluye descripción, barra, porcentaje y tiempo restante, pero puedes componer tu propia combinación con columnas para velocidad de transferencia, tamaño descargado, tiempo transcurrido o un spinner. La propiedad finished es cierta cuando todas las tareas alcanzaron su total.

Una recomendación práctica: si dentro de una barra de progreso necesitas imprimir mensajes, hazlo con progreso.console.print o con el Console que compartes con Progress. Imprimir con el print normal mientras hay una barra activa estropea la visualización, porque las dos salidas compiten por la misma línea.

Logs bonitos con RichHandler

Si tu aplicación ya usa el módulo estándar logging, no tienes que reescribirla. Rich proporciona RichHandler, un manejador que formatea los registros con color, hora, nivel y ubicación del código.

import logging

from rich.logging import RichHandler

logging.basicConfig(
    level=logging.INFO,
    format="%(message)s",
    datefmt="[%X]",
    handlers=[RichHandler(rich_tracebacks=True, markup=True)],
)

registro = logging.getLogger("panel")

registro.info("Arranque del panel de servicios")
registro.warning("La caché tarda más de lo esperado")

try:
    1 / 0
except ZeroDivisionError:
    registro.exception("Fallo al calcular la disponibilidad")

Con rich_tracebacks=True, las excepciones registradas con exception se muestran con el formato mejorado de Rich, incluyendo fragmentos del código fuente. Con markup=True, los mensajes aceptan etiquetas de estilo, aunque conviene activarlo solo si controlas el texto. Como el formato ya incluye la hora y el nivel de forma visual, se suele dejar format="%(message)s" para no duplicar información.

Un aviso importante: RichHandler está pensado para la lectura humana en una terminal. Si tus logs van a un archivo, a un agregador o a un sistema de monitorización, conserva un formato estructurado y sin códigos de color. Lo habitual es configurar dos manejadores: uno de Rich para el desarrollo local y otro plano o en JSON para producción.

Tracebacks legibles para depurar

Los errores de Python imprimen una traza funcional pero austera. Rich puede sustituirla globalmente con una sola instrucción:

from rich.traceback import install

install(show_locals=True)


def dividir(a, b):
    return a / b


dividir(10, 0)

Tras llamar a install, cualquier excepción no capturada se muestra con resaltado de sintaxis, fragmentos de código alrededor de la línea fallida y, con show_locals=True, el valor de las variables locales de cada marco. Eso ahorra muchos ciclos de añadir impresiones temporales. Igual que con log_locals, ten presente que mostrar variables puede exponer datos sensibles, así que limita esta opción al desarrollo.

Para capturar una excepción concreta sin que el programa termine, puedes usar consola.print_exception(show_locals=True) dentro de un bloque except. Aprovecha esto en tareas por lotes donde un fallo en un elemento no debe detener el resto, pero quieres un informe claro de lo ocurrido.

Markdown y código con resaltado de sintaxis

Rich también renderiza Markdown y fragmentos de código con coloreado, lo cual es útil si tu herramienta muestra ayuda, notas de versión o respuestas largas dentro de la terminal.

from rich.console import Console
from rich.markdown import Markdown
from rich.syntax import Syntax

consola = Console()

texto = """
# Guía rápida

Para revisar un servicio:

- Ejecuta el comando de chequeo
- Consulta el informe generado
"""
consola.print(Markdown(texto))

codigo = '''
def saludar(nombre):
    return f"Hola, {nombre}"
'''
consola.print(Syntax(codigo, "python", theme="monokai", line_numbers=True))

Syntax admite decenas de lenguajes y temas, y puede numerar las líneas o resaltar un rango concreto. Si estás documentando tu propio código para otros, recuerda que un buen resaltado no sustituye a explicaciones claras; para eso conviene cuidar también comentarios y docstrings bien usados en Python, que son lo que Rich mostrará cuando inspecciones objetos.

Juntar todo: un pequeño informe de servicios

Veamos cómo encajan las piezas en un script completo. Simula la comprobación de varios servicios con una barra de progreso, construye una tabla con los resultados y cierra con un panel resumen. Guarda esto como panel.py:

import random
import time

from rich import box
from rich.console import Console
from rich.panel import Panel
from rich.progress import track
from rich.table import Table

consola = Console()

SERVICIOS = ["auth", "pagos", "correo", "búsqueda", "informes", "notificaciones"]


def comprobar(nombre):
    time.sleep(0.2)
    latencia = random.randint(20, 600)
    if random.random() < 0.15:
        return nombre, None
    return nombre, latencia


def clasificar(latencia):
    if latencia is None:
        return "[bold red]CAÍDO[/bold red]"
    if latencia > 400:
        return "[yellow]LENTO[/yellow]"
    return "[green]OK[/green]"


def main():
    consola.rule("[bold]Chequeo de servicios[/bold]")
    resultados = [comprobar(s) for s in track(SERVICIOS, description="Comprobando...")]

    tabla = Table(box=box.SIMPLE_HEAVY, header_style="bold cyan")
    tabla.add_column("Servicio")
    tabla.add_column("Latencia", justify="right")
    tabla.add_column("Estado", justify="center")

    caidos = 0
    for nombre, latencia in resultados:
        texto_latencia = "-" if latencia is None else f"{latencia} ms"
        if latencia is None:
            caidos += 1
        tabla.add_row(nombre, texto_latencia, clasificar(latencia))

    consola.print(tabla)

    color = "red" if caidos else "green"
    consola.print(
        Panel(
            f"Servicios revisados: {len(resultados)}\nServicios caídos: {caidos}",
            title="Resumen",
            border_style=color,
            expand=False,
        )
    )


if __name__ == "__main__":
    main()

Ejecútalo con python panel.py. Verás la barra avanzar, y después una tabla con colores por estado y un panel cuyo borde cambia a rojo si hay servicios caídos. Es una estructura que se repite en muchas herramientas: recoger datos, presentar el detalle y resumir. Separar la lógica de comprobación de la presentación, como hacemos aquí, te permite cambiar el aspecto sin tocar el resto.

Rendimiento y cuándo no usar Rich

Rich no es gratuito en términos de coste. Renderizar tablas con miles de filas o refrescar una barra a una frecuencia altísima consume CPU. Algunas pautas razonables:

  • No imprimas decenas de miles de líneas con Console.print dentro de un bucle caliente; acumula y muestra un resumen, o limita la frecuencia de actualización.
  • Usa Progress con la velocidad de refresco por defecto. Subirla rara vez mejora la experiencia y sí aumenta el consumo.
  • Evita colorear cada palabra de un texto enorme con markup; el análisis de etiquetas tiene su coste.
  • Para procesos que escriben a máxima velocidad en un archivo, un simple write es mucho más rápido que cualquier renderizado enriquecido.

Tampoco es la herramienta para todo. Si necesitas una interfaz interactiva completa, con teclado, ventanas y eventos, Rich solo se ocupa de la salida, y para eso existen bibliotecas construidas sobre él orientadas a aplicaciones de terminal. Y si tu script se ejecuta sobre todo en sistemas de integración continua, valora si el color aporta algo o si solo llena los logs de secuencias de control.

Problemas habituales y cómo resolverlos

Si los colores no aparecen cuando redirijo la salida, es el comportamiento correcto: Rich detecta que la salida no es una terminal y desactiva estilos y animaciones. Si de verdad quieres color en un archivo o en un sistema que lo interpreta, crea la consola con force_terminal=True. Por el contrario, si quieres texto limpio siempre, usa no_color=True o respeta la variable de entorno estándar NO_COLOR, que Rich reconoce.

Otro error clásico es que las etiquetas entre corchetes desaparecen del texto que imprimes. Ocurre cuando el contenido incluye algo parecido a una etiqueta de estilo. La solución consiste en escapar los datos con rich.markup.escape antes de insertarlos en una cadena con markup, o imprimir con markup=False.

Si la barra de progreso se queda mal dibujada al mezclar impresiones, es casi seguro que estás usando print normal mientras hay un Progress activo. Dirige todos los mensajes a través de la misma consola que usa la barra.

En Windows antiguo o en terminales con codificación limitada, los caracteres de dibujo de bordes pueden salir como signos de interrogación. Prueba a cambiar la fuente de la terminal, a usar un terminal moderno o a elegir un estilo de borde ASCII con box=box.ASCII.

Cuando una tabla se desborda en pantallas estrechas, no fuerces un ancho fijo grande. Marca como no_wrap solo las columnas importantes y deja que las descriptivas envuelvan su texto. Y si el ancho detectado es incorrecto dentro de un contenedor o un CI, puedes fijarlo con Console(width=100) o con la variable de entorno COLUMNS.

Por último, si Rich parece no hacer nada, comprueba que estás importando desde rich y no desde un archivo local de tu proyecto llamado rich.py, que taparía la biblioteca instalada. Es un fallo sorprendentemente frecuente cuando se prueban ejemplos en la misma carpeta.

Buenas prácticas para usar Rich en proyectos reales

Después de los ejemplos, conviene fijar unas cuantas reglas que mantienen el código ordenado y la salida predecible.

La primera es centralizar la consola en un módulo y reutilizarla. Un archivo ui.py con consola = Console() y unas pocas funciones auxiliares, como exito, aviso y error, evita estilos repartidos y contradictorios por toda la aplicación. Si después decides cambiar el color de los errores, lo haces en un único punto.

La segunda es separar los datos de su presentación. Las funciones que calculan o recuperan información deben devolver estructuras normales de Python, y solo la capa final las convierte en tablas o paneles. Así puedes probar la lógica sin depender de la terminal y reutilizarla si mañana quieres emitir JSON o generar una página web en lugar de texto coloreado.

La tercera es ofrecer una salida alternativa para automatización. Una herramienta de línea de comandos bien diseñada acepta un parámetro que desactiva la decoración y produce texto plano o JSON, porque otros programas la van a consumir. Con Console(record=True) incluso puedes capturar lo impreso y exportarlo con export_text, export_html o export_svg, útil para generar informes o capturas de documentación.

La cuarta es cuidar la accesibilidad. No uses solo el color para transmitir significado: acompaña el rojo y el verde con palabras como OK o ERROR, como hicimos en los ejemplos, para que la información siga siendo comprensible para personas con daltonismo o en terminales monocromáticas.

La quinta es fijar la dependencia en tu archivo de requisitos con un rango compatible. Rich sigue versionado de forma semántica en lo esencial, aunque entre versiones mayores puede haber cambios menores en parámetros poco usados. Si publicas una herramienta, declara un límite inferior y revisa las notas de versión antes de subir de versión mayor. En la serie 15 conviene usar siempre los nombres actuales documentados y no los alias antiguos que pudieras encontrar en tutoriales de hace años.

Y la sexta es probar. Rich permite crear una Console que escribe en un StringIO con file= y un ancho fijo, de forma que puedes comparar la salida con la esperada en una prueba automática. Combina eso con no_color=True para que las comparaciones sean estables y no dependan de secuencias de escape.

Conclusiones

Rich convierte la terminal en un medio de comunicación mucho más expresivo sin obligarte a aprender un framework completo. Con Console y el markup consigues texto con estilo; con Table, Panel, Columns y Tree organizas información compleja; con track, status y Progress mantienes informado al usuario durante procesos largos; y con RichHandler y los tracebacks mejorados haces la depuración bastante más llevadera.

Para sacarle partido, empieza por lo pequeño: sustituye un print por rprint, añade una tabla a tu próximo informe y envuelve un bucle lento con track. Después da el salto a una consola compartida, logs integrados y una salida alternativa para automatización. Con Rich 15 y Python 3.14 tienes una base estable y moderna, y con un par de tardes de práctica tus herramientas de línea de comandos dejarán de parecer scripts improvisados para parecer productos cuidados.