f-strings en Python — La guía completa con todos los trucos

Si llevas un tiempo programando Python, las f-strings ya son parte de tu día a día. Pero la mayoría usa solo el 10% de lo que pueden hacer.

Esta entrada es la guía definitiva: desde lo básico hasta los trucos que casi nadie conoce — incluido el operador = para debug que cambia tu vida cuando lo descubres.

Qué son las f-strings (vs format vs %)

Las f-strings (formatted string literals, Python 3.6+) son la forma moderna de meter variables dentro de strings. Las identificas por la f antes de las comillas:

nombre = "Oscar"
edad = 35

# f-string (moderno, recomendado)
print(f"Hola {nombre}, tienes {edad} años")

# .format() (antiguo, todavía válido)
print("Hola {}, tienes {} años".format(nombre, edad))

# % (muy antiguo, evita en código nuevo)
print("Hola %s, tienes %d años" % (nombre, edad))

Las tres dan el mismo resultado: Hola Oscar, tienes 35 años. Pero las f-strings son más cortas, más legibles, más rápidas en runtime y más fáciles de mantener. No hay razón para usar las otras en código nuevo.

Sintaxis básica

Cualquier expresión Python entre llaves {} se evalúa:

nombre = "Ana"
print(f"Hola {nombre}")              # Hola Ana
print(f"Hola {nombre.upper()}")       # Hola ANA

a, b = 5, 3
print(f"{a} + {b} = {a + b}")         # 5 + 3 = 8

precio = 99.95
print(f"Precio con IVA: {precio * 1.21}")  # Precio con IVA: 120.94...

No solo variables — cualquier expresión: llamadas a funciones, operaciones, accesos a diccionarios, list comprehensions… lo que quieras.

Formato de números

Aquí empieza la magia. Después de la variable, un : abre opciones de formato.

Decimales

pi = 3.14159265

f"{pi:.2f}"        # "3.14" (2 decimales)
f"{pi:.4f}"        # "3.1416" (4 decimales)
f"{pi:.0f}"        # "3" (sin decimales)
f"{pi:e}"          # "3.141593e+00" (notación científica)

Separador de miles

poblacion = 1234567

f"{poblacion:,}"   # "1,234,567" (separador inglés)
f"{poblacion:_}"   # "1_234_567" (separador con guiones bajos, útil en logs)

Porcentajes

ratio = 0.857

f"{ratio:.1%}"     # "85.7%" (multiplica × 100 y añade %)
f"{ratio:.2%}"     # "85.70%"

Combinar

precio = 1234567.89

f"{precio:,.2f} €"   # "1,234,567.89 €"

Alineación y padding

Útil para tablas en consola o logs:

nombre = "Ana"

f"{nombre:<10}"    # "Ana       " (alineado izq, ancho 10)
f"{nombre:>10}"    # "       Ana" (alineado dcha)
f"{nombre:^10}"    # "   Ana    " (centrado)

# Con caracter de relleno
f"{nombre:*^10}"   # "***Ana****"
f"{42:0>5}"        # "00042" (relleno con ceros)
f"{42:05}"         # "00042" (forma corta para zero-padding numérico)

Caso real: tabla con números bien alineados:

productos = [("Manzanas", 1.50), ("Pera Conferencia", 2.30), ("Plátano", 1.95)]

for nombre, precio in productos:
    print(f"{nombre:<20} {precio:>6.2f} €")

# Resultado:
# Manzanas               1.50 €
# Pera Conferencia       2.30 €
# Plátano                1.95 €

Fechas y horas

Las f-strings respetan los formatos de strftime:

from datetime import datetime

ahora = datetime.now()

f"{ahora:%Y-%m-%d}"           # "2026-05-03"
f"{ahora:%d/%m/%Y}"           # "03/05/2026"
f"{ahora:%H:%M:%S}"           # "14:35:42"
f"{ahora:%A, %d de %B}"       # "Sunday, 03 of May" (en inglés por defecto)

Para nombres de mes en español, configura locale antes:

import locale
from datetime import datetime

locale.setlocale(locale.LC_TIME, "es_ES.UTF-8")  # En Mac/Linux
ahora = datetime.now()
print(f"{ahora:%A, %d de %B de %Y}")
# domingo, 03 de mayo de 2026

El truco = para debug (Python 3.8+)

Esto es lo que casi nadie conoce y te cambia la vida.

nombre = "Ana"
edad = 28

# Antes (verboso)
print(f"nombre: {nombre}, edad: {edad}")

# Ahora (con el = mágico)
print(f"{nombre=}, {edad=}")
# nombre='Ana', edad=28

El = después del nombre imprime la expresión Y su valor. Útil cuando estás debuggeando y no quieres tirar print de cada variable a mano.

Funciona con expresiones también:

a, b = 5, 3

print(f"{a + b=}")           # a + b=8
print(f"{[x*2 for x in range(3)]=}")  # [x*2 for x in range(3)]=[0, 2, 4]

Combinable con formato:

pi = 3.14159
print(f"{pi=:.2f}")          # pi=3.14

💡 Pro tip: cuando se te quede un script sin funcionar, mete print(f"{variable=}") en los puntos clave. Es el debugger del pobre — pero rapidísimo.

Anidamiento y expresiones complejas

Sí, puedes meter expresiones bastante locas, pero mejor no abuses. La legibilidad importa.

items = [{"nombre": "Manzana", "precio": 1.5}, {"nombre": "Pera", "precio": 2.3}]

# Aceptable
total = sum(item["precio"] for item in items)
print(f"Total: {total:.2f} €")

# Funciona pero ya es feo
print(f"Total: {sum(item['precio'] for item in items):.2f} €")

La regla: si la expresión tiene más de 2 operaciones, sácala fuera. Las f-strings son para presentar, no para calcular.

Llaves literales

Si necesitas un { o } literal en una f-string, dóblalas:

print(f"Esto es un {{diccionario}} con {len([1,2,3])} elementos")
# Esto es un {diccionario} con 3 elementos

Multilínea

Para strings largos, paréntesis o triple comilla:

nombre = "Ana"
edad = 28
ciudad = "Madrid"

mensaje = (
    f"Nombre: {nombre}\n"
    f"Edad:   {edad}\n"
    f"Ciudad: {ciudad}"
)

# O triple comilla
mensaje = f"""
Hola {nombre},
Tienes {edad} años y vives en {ciudad}.
"""

Casos donde aún quieres format()

Casi nunca, pero hay 2 escenarios:

1. Plantillas reutilizables

Si quieres definir una plantilla y rellenarla más tarde:

plantilla = "Hola {nombre}, tu pedido {pedido} está listo"

# Más tarde, con datos:
mensaje = plantilla.format(nombre="Ana", pedido="#1234")

Una f-string se evalúa al momento de declararse. No puedes “guardarla y rellenarla después” — si lo necesitas, usa format().

2. Strings que vienen de fuera (configuración, BBDD)

Por seguridad, si un string viene de un usuario o de un fichero de config, nunca lo evalúes como f-string (sería eval y es peligroso). Usa format() o str.replace().

Errores comunes

Mezclar comillas

# Mal — error de sintaxis
texto = f"Hola {data["nombre"]}"

# Bien — usa comillas distintas
texto = f"Hola {data['nombre']}"

# O con escape (Python 3.12+ ya lo permite con mismas comillas)

Olvidar la f

nombre = "Ana"
print("Hola {nombre}")          # Imprime literalmente: Hola {nombre}
print(f"Hola {nombre}")         # Imprime: Hola Ana

= con espacios

a = 5
print(f"{a =}")        # a =5  (con espacio antes del igual)
print(f"{a= }")        # a= 5  (con espacio después)
print(f"{a = }")       # a = 5 (con ambos)
print(f"{a=}")         # a=5   (sin espacios)

Útil para legibilidad: f"{variable = :.2f}" queda más limpio que pegado.

Resumen: la chuleta

# Variables
f"{nombre}"

# Decimales
f"{pi:.2f}"            # 3.14

# Miles
f"{n:,}"               # 1,234,567

# Porcentaje
f"{ratio:.1%}"         # 85.7%

# Padding
f"{texto:<10}"         # izquierda
f"{texto:>10}"         # derecha
f"{texto:^10}"         # centrado
f"{n:05}"              # zero-padding numérico

# Fechas
f"{fecha:%Y-%m-%d}"

# Debug (Python 3.8+)
f"{variable=}"
f"{variable=:.2f}"

Conclusión

Las f-strings son una de las features más útiles de Python moderno. Una vez que dominas el : con sus opciones, escribes código mucho más limpio. Y el = para debug solo lo descubres cuando ya programas Python a diario — pero cambia el juego.

Si quieres aprender Python desde la base hasta cosas como esta sin tener que ir saltando entre tutoriales sueltos, en El Pythonista tienes el curso completo en español.

Un abrazo,
Oscar