Python f-Strings

Los f-strings (literales de string formateados) se introdujeron en Python 3.6 y son ahora la forma recomendada de insertar valores dentro de strings. Son más rápidos que el formateo con % y str.format(), y mucho más legibles porque el nombre de la variable aparece directamente dentro del string en el lugar donde se mostrará.

Este capítulo cubre:

• Sintaxis básica de los f-strings y cómo insertar variables
• Evaluación de expresiones, llamadas a métodos y llamadas a funciones en línea
• Especificadores de formato: alineación, ancho, precisión y bases numéricas
• Formato de fechas y uso de los especificadores de signo y relleno con ceros
• El especificador de depuración = (Python 3.8+)
• f-strings multilínea y plantillas reutilizables en funciones
• Errores comunes y cómo evitarlos

Capítulos relacionados: Format Strings · Python String Formatting · Python Strings · Python Dates · Python Regex

Sintaxis básica

Un f-string es cualquier literal de string que comienza con la letra f (o F) inmediatamente antes de la comilla de apertura. Cualquier expresión Python que coloques dentro de las llaves {} se evalúa en tiempo de ejecución, su valor se convierte a string y se inserta en el resultado.

name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")

My name is Alice and I am 30 years old.

El prefijo f funciona con comillas simples, comillas dobles y comillas triples:

language = "Python"
print(f'I love {language}!')          # single quotes
print(f"""I love {language}!""")      # triple quotes

I love Python!
I love Python!

Inserción de expresiones

El marcador de posición {} acepta cualquier expresión Python válida, no solo nombres de variables. Puedes realizar aritmética, comparaciones, llamar a métodos, llamar a funciones y acceder a claves de diccionario.

Aritmética y comparaciones

x = 10
y = 3
print(f"{x} divided by {y} is {x / y:.2f}")
print(f"The square of {x} is {x ** 2}")
print(f"Is {x} greater than {y}? {x > y}")

10 divided by 3 is 3.33
The square of 10 is 100
Is 10 greater than 3? True

Llamadas a métodos

name = "alice smith"
print(f"Hello, {name.title()}!")
print(f"Uppercase: {name.upper()}")

Hello, Alice Smith!
Uppercase: ALICE SMITH

Llamadas a funciones y funciones integradas

items = ["apples", "bananas", "cherries"]
print(f"You have {len(items)} items in the list.")

You have 3 items in the list.

Acceso a diccionarios

Usa comillas simples dentro de las llaves para acceder a claves de diccionario (el string externo usa comillas dobles, por lo que no hay conflicto):

person = {"name": "Bob", "age": 25}
print(f"Name: {person['name']}, Age: {person['age']}")

Name: Bob, Age: 25

Expresiones condicionales

score = 72
print(f"Score: {score} => {'Pass' if score >= 60 else 'Fail'}")

Score: 72 => Pass

Especificadores de formato

Después de la expresión, agrega dos puntos : seguidos de un especificador de formato para controlar cómo se muestra el valor. La sintaxis completa del mini-lenguaje es:

{expression:[fill][align][sign][width][grouping][.precision][type]}

No es necesario usar todas las partes: combina solo las que necesites.

Alineación y ancho

Usa < (izquierda), > (derecha) o ^ (centro) con un número para establecer el ancho del campo:

name = "Alice"
print(f"|{name:<10}|")   # left-align in a field of width 10
print(f"|{name:>10}|")   # right-align
print(f"|{name:^10}|")   # center

|Alice     |
|     Alice|
|  Alice   |

Especifica un carácter de relleno antes del símbolo de alineación para rellenar con algo distinto de espacios:

print(f"|{'hello':*^15}|")  # fill with * and center

|*****hello*****|

Precisión decimal

pi = 3.14159265
print(f"Pi is approximately {pi:.2f}")   # 2 decimal places
print(f"Pi is approximately {pi:.4f}")   # 4 decimal places

Pi is approximately 3.14
Pi is approximately 3.1416

Formato de números

price = 1234567.89
print(f"{price:,.2f}")   # comma as thousands separator
print(f"{price:e}")      # scientific notation

1,234,567.89
1.234568e+06

Muestra un valor como porcentaje directamente: Python multiplica por 100 automáticamente:

ratio = 0.853
print(f"{ratio:.1%}")

85.3%

Especificador de signo

Usa + para mostrar siempre el signo, o un espacio para reservar un espacio para los números positivos (de modo que las columnas se alineen con los negativos):

x = 42
y = -7
print(f"{x:+d}")    # +42
print(f"{y:+d}")    # -7
print(f"{x: d}")    # space before positive
print(f"{y: d}")    # -7

+42
-7
 42
-7

Relleno con ceros

Rellena un entero hasta un ancho fijo con ceros a la izquierda usando 0 antes del número de ancho:

print(f"{42:010d}")   # zero-pad to 10 digits

0000000042

Combina signo y relleno con ceros: el signo ocupa la primera posición:

x = 42
print(f"{x:+010d}")   # +000000042

+000000042

Bases enteras

x = 255
print(f"{x:d}")    # decimal   -> 255
print(f"{x:x}")    # hex lower -> ff
print(f"{x:X}")    # hex upper -> FF
print(f"{x:o}")    # octal     -> 377
print(f"{x:b}")    # binary    -> 11111111

255
ff
FF
377
11111111

Formato de fechas

Cuando colocas un objeto datetime o date dentro de un f-string, puedes seguir los dos puntos con códigos de formato strftime para controlar la salida directamente, sin necesidad de llamar a .strftime():

from datetime import date
today = date(2024, 6, 19)
print(f"Today is {today:%B %d, %Y}")
print(f"ISO format: {today:%Y-%m-%d}")

Today is June 19, 2024
ISO format: 2024-06-19

Consulta el capítulo Python Dates para ver la lista completa de códigos de formato strftime.

El especificador de depuración = (Python 3.8+)

Agregar = después del nombre de la expresión imprime tanto el texto de la expresión como su valor. Esto evita tener que escribir el nombre de la variable dos veces y es muy útil para depurar rápidamente:

val = 42
result = val * 2
print(f"{val=}, {result=}")

val=42, result=84

Los valores de tipo string reciben el tratamiento de repr() para que puedas ver las comillas:

name = "Alice"
print(f"{name=}")

name='Alice'

Puedes combinar = con un especificador de formato; pon el especificador después de =:

pi = 3.14159265
print(f"{pi=:.3f}")

pi=3.142

f-Strings multilínea

Para textos más largos puedes extender un f-string en varias líneas. Dos enfoques funcionan bien.

Concatenación implícita de strings (no se necesita barra invertida dentro de los paréntesis):

name = "Alice"
age = 30
city = "London"
profile = (
    f"Name : {name}\n"
    f"Age  : {age}\n"
    f"City : {city}"
)
print(profile)

Name : Alice
Age  : 30
City : London

f-string con comillas triples — los saltos de línea son literales, por lo que no se necesita \n:

name = "Alice"
age = 30
report = f"""
Name : {name}
Age  : {age}
""".strip()
print(report)

Name : Alice
Age  : 30

Plantillas reutilizables

Los f-strings se evalúan de inmediato, por lo que no puedes almacenarlos como una variable de plantilla y rellenarlos más adelante. Usa una función en su lugar:

def greet(name, role):
    return f"Hello, {name}! Your role is {role}."

print(greet("Alice", "admin"))
print(greet("Bob", "editor"))

Hello, Alice! Your role is admin.
Hello, Bob! Your role is editor.

Si realmente necesitas una plantilla diferida, usa str.format() — consulta Format Strings.

Llaves literales en la salida

Para incluir un carácter { o } literal en la salida, duplícalo:

value = 42
print(f"The answer is {{value}} = {value}")

The answer is {value} = 42

Errores comunes

Barras invertidas dentro de la expresión (Python < 3.12)

Antes de Python 3.12, no se permiten barras invertidas dentro de la expresión {} de un f-string. La solución es calcular el valor en una variable previamente:

items = ["a", "b", "c"]

# This raises SyntaxError on Python < 3.12:
# print(f"{'\n'.join(items)}")

# Workaround — pre-compute:
joined = "\n".join(items)
print(f"Items:\n{joined}")

Items:
a
b
c

Python 3.12 eliminó esta restricción, por lo que las barras invertidas ahora son válidas dentro de las expresiones de f-string.

Usar el mismo tipo de comilla dentro de la expresión

Si el f-string externo usa comillas dobles, usa comillas simples para las claves de diccionario dentro de {}. Si necesitas el mismo tipo de comilla, cambia las comillas externas o usa una variable:

person = {"name": "Bob"}

# Works — single quotes inside double-quoted f-string
print(f"Name: {person['name']}")

# Also works — pre-assign the key
key = "name"
print(f"Name: {person[key]}")

Name: Bob
Name: Bob

Los f-strings no son perezosos

Un f-string evalúa cada expresión en el momento en que se ejecuta la línea. Si asignas un f-string a una variable, captura los valores actuales: cambiar las variables después no tiene ningún efecto sobre el string ya evaluado:

x = 5
msg = f"x is {x}"
x = 99
print(msg)   # still shows 5, not 99

x is 5

Usa una función (como se mostró antes) cuando necesites una plantilla que se evalúe más tarde.

Referencia rápida

Práctica