Cómo alinear la salida al imprimir en Python

Introducción

Al escribir programas en Python, presentar la salida de manera limpia y organizada es esencial tanto para la legibilidad del código como para la experiencia del usuario. Ya sea que estés creando informes, mostrando datos tabulares o simplemente imprimiendo información en la consola, la alineación adecuada del texto hace que tu salida sea más profesional y fácil de leer.

En este laboratorio (lab), aprenderás diversas técnicas para alinear y dar formato a la salida de texto en Python. Explorarás diferentes métodos de alineación, practicarás técnicas de formato y crearás presentaciones tabulares bien estructuradas que se pueden aplicar en aplicaciones del mundo real.

Alineación básica de cadenas en Python

En este primer paso, aprenderás sobre los conceptos fundamentales de la alineación de texto en Python e implementarás técnicas básicas de alineación.

¿Qué es la alineación de texto?

La alineación de texto se refiere a cómo se posiciona el texto dentro de un espacio dado. Python proporciona varios métodos para controlar la posición del texto al imprimir en la consola. Los tres tipos principales de alineación son:

Alineación a la izquierda: El texto comienza desde el borde izquierdo del espacio asignado.
Alineación a la derecha: El texto termina en el borde derecho del espacio asignado.
Alineación al centro: El texto se centra dentro del espacio asignado.

Tu primer programa de alineación

Vamos a crear un sencillo script de Python para demostrar las técnicas básicas de alineación.

Abre el WebIDE en tu entorno LabEx.
Crea un nuevo archivo llamado basic_alignment.py en el directorio /home/labex/project haciendo clic en el icono "Nuevo archivo" en el WebIDE.
Agrega el siguiente código al archivo:

## basic_alignment.py
print("Basic String Alignment Examples")
print("-" * 30)

## Left alignment example
print("Left alignment:")
print("Python".ljust(20) + "|")
print("Programming".ljust(20) + "|")
print("Alignment".ljust(20) + "|")
print()

## Right alignment example
print("Right alignment:")
print("Python".rjust(20) + "|")
print("Programming".rjust(20) + "|")
print("Alignment".rjust(20) + "|")
print()

## Center alignment example
print("Center alignment:")
print("Python".center(20) + "|")
print("Programming".center(20) + "|")
print("Alignment".center(20) + "|")

Guarda el archivo presionando Ctrl+S o seleccionando "Archivo" > "Guardar" desde el menú.
Abre una terminal en el WebIDE (si no está ya abierta) haciendo clic en el menú "Terminal" y seleccionando "Nueva terminal".
Ejecuta el script utilizando el intérprete de Python:

cd ~/project
python3 basic_alignment.py

Deberías ver la siguiente salida:

Basic String Alignment Examples
------------------------------
Left alignment:
Python              |
Programming         |
Alignment           |

Right alignment:
              Python|
         Programming|
           Alignment|

Center alignment:
       Python       |
     Programming    |
      Alignment     |

Entendiendo el código

El script que acabas de crear demuestra tres métodos básicos de alineación de cadenas en Python:

ljust(width): Justifica la cadena a la izquierda dentro de un campo del ancho especificado.
rjust(width): Justifica la cadena a la derecha dentro de un campo del ancho especificado.
center(width): Centra la cadena dentro de un campo del ancho especificado.

En cada ejemplo, agregamos una barra vertical (|) al final de cada línea para mostrar claramente el límite del espacio asignado. Observa cómo el texto se alinea de manera diferente en cada caso mientras se mantiene el mismo ancho total de 20 caracteres.

Alineación de cadenas con diferentes caracteres

Los métodos de justificación de cadenas también pueden tomar un segundo parámetro para especificar el carácter de relleno que se utilizará para el relleno. Vamos a modificar nuestro script para ver esto en acción.

Crea un nuevo archivo llamado alignment_with_chars.py en el directorio /home/labex/project.
Agrega el siguiente código al archivo:

## alignment_with_chars.py
print("String Alignment With Custom Characters")
print("-" * 40)

## Using different padding characters
print("Left alignment with dots:")
print("Python".ljust(20, '.') + "|")
print("Programming".ljust(20, '.') + "|")
print()

print("Right alignment with asterisks:")
print("Python".rjust(20, '*') + "|")
print("Programming".rjust(20, '*') + "|")
print()

print("Center alignment with hyphens:")
print("Python".center(20, '-') + "|")
print("Programming".center(20, '-') + "|")

Guarda el archivo y ejecútalo:

python3 ~/project/alignment_with_chars.py

Deberías ver una salida como esta:

String Alignment With Custom Characters
----------------------------------------
Left alignment with dots:
Python..............|
Programming.........|

Right alignment with asterisks:
**************Python|
*********Programming|

Center alignment with hyphens:
-------Python------|
----Programming----|

Estos ejemplos demuestran cómo puedes personalizar la apariencia de tu texto alineado utilizando diferentes caracteres de relleno.

Métodos Avanzados de Formato para Alineación

En el paso anterior, aprendiste sobre la alineación básica de cadenas usando los métodos ljust(), rjust() y center(). Ahora, exploremos métodos de formato más potentes y flexibles disponibles en Python.

Métodos de Formato de Cadenas en Python

Python ofrece varias maneras de formatear cadenas:

Formato de estilo antiguo (usando el operador %)
El método str.format()
Cadenas f (literales de cadena formateadas, disponibles en Python 3.6+)

Cada método proporciona maneras de alinear texto y formatear varios tipos de datos. Exploremos cada uno de ellos.

1. Formato de Estilo Antiguo (% Operador)

Este es el método más antiguo de formateo de cadenas en Python, similar a la función printf() de C.

Crea un nuevo archivo llamado old_style_formatting.py en el directorio /home/labex/project:

## old_style_formatting.py
print("Formato de Cadenas de Estilo Antiguo")
print("-" * 30)

## Alineación a la izquierda con formato %
print("Alineación a la izquierda:")
print("%-15s | %-10s" % ("Python", "Lenguaje"))
print("%-15s | %-10s" % ("JavaScript", "Web"))
print()

## Alineación a la derecha con formato %
print("Alineación a la derecha:")
print("%15s | %10s" % ("Python", "Lenguaje"))
print("%15s | %10s" % ("JavaScript", "Web"))
print()

## Formato de números
precio = 125.5
tasa_impuesto = 0.21
print("Precio: $%8.2f" % precio)
print("Tasa de impuesto: %6.1f%%" % (tasa_impuesto * 100))
print("Importe de impuesto: $%6.2f" % (precio * tasa_impuesto))
print("Total: $%8.2f" % (precio * (1 + tasa_impuesto)))

Guarda el archivo y ejecútalo:

python3 ~/project/old_style_formatting.py

Deberías ver una salida similar a esta:

Formato de Cadenas de Estilo Antiguo
------------------------------
Alineación a la izquierda:
Python          | Lenguaje
JavaScript      | Web

Alineación a la derecha:
         Python |  Lenguaje
     JavaScript |       Web

Formato de números:
Precio: $   125.50
Tasa de impuesto:   21.0%
Importe de impuesto: $ 26.36
Total: $   151.86

2. El Método str.format()

El método str.format() proporciona una forma más versátil de formatear cadenas y fue introducido para abordar algunas limitaciones del operador %.

Crea un nuevo archivo llamado format_method.py en el directorio /home/labex/project:

## format_method.py
print("Formato de Cadenas con str.format()")
print("-" * 35)

## Alineación básica con format
print("Alineación básica:")
print("{:<15} | {:<10}".format("Python", "Lenguaje"))
print("{:>15} | {:>10}".format("Python", "Lenguaje"))
print("{:^15} | {:^10}".format("Python", "Lenguaje"))
print()

## Alineación con carácter de relleno personalizado
print("Carácter de relleno personalizado:")
print("{:*<15} | {:.>10}".format("Python", "Lenguaje"))
print("{:#^15} | {:=^10}".format("Python", "Lenguaje"))
print()

## Alineación con nombres de campo
print("Usando nombres de campo:")
print("{nombre:<15} | {tipo:<10}".format(nombre="JavaScript", tipo="Web"))
print("{nombre:>15} | {tipo:>10}".format(nombre="Python", tipo="Lenguaje"))
print()

## Formato de números
precio = 125.5
tasa_impuesto = 0.21
print("Formato de números:")
print("Precio: ${:8.2f}".format(precio))
print("Tasa de impuesto: {:6.1f}%".format(tasa_impuesto * 100))
print("Importe de impuesto: ${:6.2f}".format(precio * tasa_impuesto))
print("Total: ${:8.2f}".format(precio * (1 + tasa_impuesto)))

Guarda el archivo y ejecútalo:

python3 ~/project/format_method.py

Deberías ver una salida similar a esta:

Formato de Cadenas con str.format()
-----------------------------------
Alineación básica:
Python          | Lenguaje
         Python |   Lenguaje
    Python      |  Lenguaje

Carácter de relleno personalizado:
Python********* | Lenguaje...
#####Python##### | ==Lenguaje==

Usando nombres de campo:
JavaScript      | Web
         Python |  Lenguaje

Formato de números:
Precio: $  125.50
Tasa de impuesto:   21.0%
Importe de impuesto: $ 26.36
Total: $  151.86

3. Cadenas f (Python 3.6+)

Las cadenas f proporcionan una forma concisa y conveniente de incrustar expresiones dentro de literales de cadena. Se prefijan con la letra 'f' y usan llaves {} para incluir expresiones.

Crea un nuevo archivo llamado f_strings.py en el directorio /home/labex/project:

## f_strings.py
print("Formato de Cadenas con Cadenas f")
print("-" * 35)

lenguaje = "Python"
categoria = "Lenguaje"
version = 3.10
año = 2022

## Alineación básica con cadenas f
print("Alineación básica:")
print(f"{lenguaje:<15} | {categoria:<10}")
print(f"{lenguaje:>15} | {categoria:>10}")
print(f"{lenguaje:^15} | {categoria:^10}")
print()

## Especificación de ancho dinámico
ancho1 = 15
ancho2 = 10
print("Ancho dinámico:")
print(f"{lenguaje:<{ancho1}} | {categoria:<{ancho2}}")
print(f"{lenguaje:>{ancho1}} | {categoria:>{ancho2}}")
print()

## Expresiones dentro de cadenas f
print("Expresiones en cadenas f:")
print(f"{lenguaje + ' ' + str(version):<15} | {año - 1991:>10} años")
print()

## Formato de números
precio = 125.5
tasa_impuesto = 0.21
print("Formato de números:")
print(f"Precio: ${precio:8.2f}")
print(f"Tasa de impuesto: {tasa_impuesto * 100:6.1f}%")
print(f"Importe de impuesto: ${precio * tasa_impuesto:6.2f}")
print(f"Total: ${precio * (1 + tasa_impuesto):8.2f}")

Guarda el archivo y ejecútalo:

python3 ~/project/f_strings.py

Deberías ver una salida similar a esta:

Formato de Cadenas con Cadenas f
-----------------------------------
Alineación básica:
Python          | Lenguaje
         Python |  Lenguaje
    Python      | Lenguaje

Ancho dinámico:
Python          | Lenguaje
         Python |  Lenguaje

Expresiones en cadenas f:
Python 3.1      |         31 años

Formato de números:
Precio: $  125.50
Tasa de impuesto:   21.0%
Importe de impuesto: $ 26.36
Total: $  151.86

Comparación de Métodos de Formato

Cada método de formateo tiene sus ventajas. Aquí te decimos cuándo usar cada uno:

Operador %: Útil en código heredado o cuando es necesaria la compatibilidad con versiones anteriores de Python.
Método str.format(): Más potente que el formato %, especialmente para requisitos de formato complejos.
Cadenas f: La opción más concisa y legible, recomendada para todo nuevo código Python (Python 3.6+).

La tendencia moderna en Python es usar cadenas f siempre que sea posible debido a sus beneficios de legibilidad y rendimiento.

Creación de Tablas Formateadas con Python

Ahora que has aprendido diferentes técnicas de alineación, apliquemos estas para crear tablas bien formateadas. Las tablas son una forma común de mostrar datos estructurados en un formato legible, y una alineación adecuada es crucial para presentar la información tabular de manera efectiva.

Tabla Simple con Columnas de Ancho Fijo

Empecemos creando una tabla simple con columnas de ancho fijo.

Crea un nuevo archivo llamado simple_table.py en el directorio /home/labex/project:

## simple_table.py
print("Tabla Simple de Ancho Fijo")
print("-" * 50)

## Define algunos datos
encabezado = ["Nombre", "Edad", "Ciudad", "Profesión"]
datos = [
    ["John Smith", 34, "Nueva York", "Médico"],
    ["Sarah Johnson", 28, "San Francisco", "Ingeniera"],
    ["Michael Brown", 42, "Chicago", "Maestro"],
    ["Emily Davis", 31, "Boston", "Científica"]
]

## Imprime el encabezado
print(f"{encabezado[0]:<20} {encabezado[1]:<8} {encabezado[2]:<15} {encabezado[3]:<15}")
print("-" * 60)

## Imprime las filas
for fila in datos:
    print(f"{fila[0]:<20} {fila[1]:<8} {fila[2]:<15} {fila[3]:<15}")

Guarda el archivo y ejecútalo:

python3 ~/project/simple_table.py

Deberías ver una tabla formateada como esta:

Tabla Simple de Ancho Fijo
--------------------------------------------------
Nombre                 Edad      Ciudad            Profesión
------------------------------------------------------------
John Smith           34       Nueva York        Médico
Sarah Johnson        28       San Francisco   Ingeniera
Michael Brown        42       Chicago         Maestro
Emily Davis          31       Boston          Científica

Tabla Dinámica con Múltiples Tipos de Alineación

Diferentes tipos de datos a menudo se ven mejor con diferentes estilos de alineación. Por ejemplo, el texto suele alinearse a la izquierda, mientras que los números se alinean a la derecha. Creemos una tabla más sofisticada con alineación mixta.

Crea un nuevo archivo llamado dynamic_table.py en el directorio /home/labex/project:

## dynamic_table.py
print("Tabla Dinámica con Alineación Mixta")
print("-" * 50)

## Define algunos datos
encabezado = ["Producto", "Precio", "Cantidad", "Total"]
productos = [
    ["Portátil", 1299.99, 3, 3899.97],
    ["Ratón", 24.50, 10, 245.00],
    ["Monitor", 349.95, 2, 699.90],
    ["Teclado", 49.99, 5, 249.95],
    ["Auriculares", 89.95, 4, 359.80]
]

## Calcula los anchos de columna basados en el contenido
anchos_columnas = [
    max(len(str(encabezado[0])), max(len(str(fila[0])) for fila in productos)) + 2,
    max(len(str(encabezado[1])), max(len(f"${fila[1]:.2f}") for fila in productos)) + 2,
    max(len(str(encabezado[2])), max(len(str(fila[2])) for fila in productos)) + 2,
    max(len(str(encabezado[3])), max(len(f"${fila[3]:.2f}") for fila in productos)) + 2
]

## Imprime el encabezado
print(f"{encabezado[0]:<{anchos_columnas[0]}}"
      f"{encabezado[1]:>{anchos_columnas[1]}}"
      f"{encabezado[2]:>{anchos_columnas[2]}}"
      f"{encabezado[3]:>{anchos_columnas[3]}}")
print("-" * sum(anchos_columnas))

## Imprime las filas con la alineación apropiada
for producto in productos:
    print(f"{producto[0]:<{anchos_columnas[0]}}",
          f"${producto[1]:.2f}".rjust(anchos_columnas[1]),
          f"{producto[2]}".rjust(anchos_columnas[2]),
          f"${producto[3]:.2f}".rjust(anchos_columnas[3]))

## Imprime el resumen
cantidad_total = sum(producto[2] for producto in productos)
coste_total = sum(producto[3] for producto in productos)
print("-" * sum(anchos_columnas))
print(f"{'TOTAL':<{anchos_columnas[0]}}",
      f"".rjust(anchos_columnas[1]),
      f"{cantidad_total}".rjust(anchos_columnas[2]),
      f"${coste_total:.2f}".rjust(anchos_columnas[3]))

... (resto del código traducido)

Resumen

En este laboratorio, has aprendido diversas técnicas para alinear y formatear la salida de texto en Python:

Métodos básicos de alineación de cadenas: ljust(), rjust() y center()
Diferentes enfoques de formato de cadenas: operador %, str.format() y f-strings
Cómo crear tablas bien estructuradas con columnas de ancho fijo
Cómo aplicar diferentes estilos de alineación según los tipos de datos
Cómo crear aplicaciones del mundo real, como informes financieros, con un formato adecuado

Estas habilidades de alineación de texto son esenciales para crear una salida legible y profesional en muchas aplicaciones, desde simples utilidades de línea de comandos hasta complejos sistemas de procesamiento de datos. Al dominar la alineación de texto en Python, puedes mejorar significativamente la experiencia del usuario y la legibilidad de tus programas.

A medida que continúes tu viaje en Python, recuerda que una salida limpia y bien formateada a menudo es tan importante como la lógica computacional de tus programas. Las técnicas aprendidas en este laboratorio te ayudarán a presentar tus datos de una manera que sea tanto funcional como visualmente atractiva.