Formateo avanzado: f-strings y método format()
Introducción
El formateo de cadenas es una operación fundamental en programación que permite crear textos dinámicos combinando variables y valores con texto fijo. Python ofrece métodos avanzados de formateo que permiten representar datos de manera clara, precisa y personalizada. Los f-strings (cadenas literales formateadas) y el método format() son herramientas potentes que facilitan esta tarea con una sintaxis elegante y flexible. En este artículo, exploraremos estas técnicas de formateo avanzado que te permitirán manipular textos con mayor precisión y menos código.
F-strings: formateo de cadenas literal
Los f-strings, introducidos en Python 3.6, representan la forma más moderna y recomendada de formatear cadenas en Python. Son concisos, legibles y eficientes.
Sintaxis básica
Para crear un f-string, solo necesitas añadir el prefijo f o F antes de la cadena y utilizar llaves {} para incluir expresiones.
nombre = "Ana"
edad = 28
print(f"Hola, me llamo {nombre} y tengo {edad} años.")
# Salida: Hola, me llamo Ana y tengo 28 años.
Expresiones en f-strings
Las llaves pueden contener cualquier expresión Python válida:
# Operaciones aritméticas
precio = 19.95
cantidad = 3
print(f"Total: {precio * cantidad} €")
# Salida: Total: 59.85 €
# Llamadas a métodos
mensaje = "python"
print(f"Mensaje: {mensaje.upper()}")
# Salida: Mensaje: PYTHON
# Operaciones con diccionarios
persona = {"nombre": "Carlos", "profesion": "programador"}
print(f"{persona['nombre']} es {persona['profesion']}")
# Salida: Carlos es programador
Formato de números
Los f-strings permiten controlar la presentación de números con gran precisión:
# Número de decimales (precisión)
pi = 3.14159
print(f"Pi redondeado a 2 decimales: {pi:.2f}")
# Salida: Pi redondeado a 2 decimales: 3.14
# Ancho y relleno
for i in range(1, 11):
print(f"{i:3} {i*i:4} {i*i*i:5}")
# Salida (alineación por columnas):
# 1 1 1
# 2 4 8
# 3 9 27
# ...
# Formato de porcentajes
probabilidad = 0.75
print(f"Probabilidad de éxito: {probabilidad:.1%}")
# Salida: Probabilidad de éxito: 75.0%
# Números con separador de miles
grande = 1234567
print(f"Número grande: {grande:,}")
# Salida: Número grande: 1,234,567
Alineación y relleno
Los f-strings ofrecen opciones para alinear texto:
# Alineación a la derecha con ancho de 10
print(f"{'Derecha':>10}")
# Salida: " Derecha"
# Alineación a la izquierda con ancho de 10
print(f"{'Izquierda':<10}")
# Salida: "Izquierda "
# Centrado con ancho de 20
print(f"{'Centrado':^20}")
# Salida: " Centrado "
# Relleno con caracteres personalizados
print(f"{'Título':*^20}")
# Salida: "*******Título*******"
F-strings y depuración
A partir de Python 3.8, los f-strings permiten una sintaxis de depuración muy útil:
x = 10
y = 20
print(f"{x=}, {y=}, {x+y=}")
# Salida: x=10, y=20, x+y=30
El método format()
Aunque los f-strings son la opción preferida actualmente, el método format() sigue siendo ampliamente utilizado y ofrece algunas funcionalidades adicionales.
Sintaxis básica
nombre = "Pedro"
edad = 35
print("Hola, me llamo {} y tengo {} años.".format(nombre, edad))
# Salida: Hola, me llamo Pedro y tengo 35 años.
Posicionamiento de argumentos
Con format() podemos especificar el orden de los argumentos:
# Por posición
print("{0} y {1}".format("día", "noche"))
# Salida: día y noche
# Reutilizando posiciones
print("{0}, {1}, {0}".format("a", "b"))
# Salida: a, b, a
# Por nombre
print("{nombre} tiene {edad} años".format(nombre="Laura", edad=29))
# Salida: Laura tiene 29 años
# Combinando técnicas
print("{0} tiene {edad} años".format("Miguel", edad=42))
# Salida: Miguel tiene 42 años
Acceso a atributos y elementos
El método format() permite acceder a atributos de objetos y elementos de colecciones:
# Elementos de listas
coordenadas = [4, 5]
print("X: {0[0]}, Y: {0[1]}".format(coordenadas))
# Salida: X: 4, Y: 5
# Elementos de diccionarios
persona = {"nombre": "Sara", "edad": 26}
print("{0[nombre]} tiene {0[edad]} años".format(persona))
# Salida: Sara tiene 26 años
# Atributos de objetos
class Punto:
def __init__(self, x, y):
self.x = x
self.y = y
p = Punto(10, 20)
print("Punto en ({0.x}, {0.y})".format(p))
# Salida: Punto en (10, 20)
Opciones de formato similares a f-strings
El método format() comparte muchas opciones de formato con los f-strings:
# Precisión decimal
pi = 3.14159
print("Pi: {:.3f}".format(pi))
# Salida: Pi: 3.142
# Ancho y alineación
for i in range(1, 4):
print("{:2d} {:3d} {:4d}".format(i, i*i, i*i*i))
# Salida:
# 1 1 1
# 2 4 8
# 3 9 27
# Relleno personalizado
print("{:*^20}".format("TÍTULO"))
# Salida: *******TÍTULO*******
# Notación científica
print("{:e}".format(1000000.0))
# Salida: 1.000000e+06
¿Cuándo usar cada método?
- F-strings: Son la opción recomendada para la mayoría de los casos por su concisión, legibilidad y rendimiento.
- format(): Útil cuando necesitas plantillas de texto reutilizables o cuando el formateo debe determinarse dinámicamente.
# Plantilla reutilizable con format()
plantilla = "Hola {}, bienvenido a {}!"
print(plantilla.format("Juan", "Python"))
print(plantilla.format("María", "Madrid"))
# Formateo dinámico
claves = ["nombre", "profesion"]
valores = ["Ana", "desarrolladora"]
plantilla = "La {0[0]} de la persona es {0[1]}"
print(plantilla.format(dict(zip(claves, valores))))
# Salida: La nombre de la persona es Ana
Resumen
El formateo avanzado de cadenas con f-strings y el método format() nos permite crear textos dinámicos con gran precisión y flexibilidad. Los f-strings destacan por su sintaxis concisa y directa, mientras que format() ofrece mayor flexibilidad para plantillas reutilizables. Estas herramientas son esenciales para generar salidas legibles y profesionales en nuestros programas Python, permitiéndonos presentar información de manera clara y personalizada. En el siguiente artículo, exploraremos cómo trabajar con archivos, una habilidad fundamental para manejar datos persistentes en nuestras aplicaciones.