Interpolación de cadenas en Python: Guía para principiantes

Supón que quieres imprimir el nombre y la profesión de una persona. Podrías escribir un programa sencillo como el siguiente

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

Ese enfoque carece de concisión y legibilidad. Afortunadamente, la interpolación de cadenas ofrece una solución mejor. Permite insertar variables, expresiones o salidas de funciones directamente en una cadena, dinamizando la manipulación de cadenas y eliminando la necesidad de concatenación manual.

Utilizando un enfoque de interpolación de cadenas, podríamos reescribir el código como sigue.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

La versión con interpolación de cadenas permite incrustar expresiones directamente dentro de la cadena, sin necesidad de utilizar concatenaciones engorrosas. Como puedes ver, es un enfoque mucho más limpio.

Interpolación básica de cadenas en Python

En Python existen varias técnicas de interpolación de cadenas. El método más recomendado son los literales de cadena formateados, también conocidos como cadenas f, que están disponibles desde Python 3.6.

Otro método, comúnmente visto en código anterior a Python 3.6, es el método .format(). Aunque este método es más verboso que el de las cadenas f, a veces tiene ventajas (más detalles a continuación).

Por último, puedes encontrarte con %-formateo de estilo en código heredado.

Utilizar cadenas f (Python 3.6+)

cadenas-f (literales de cadena formateados) son una forma potente y concisa de formatear cadenas en Python. Se introdujeron en Python 3.6 y proporcionan una forma legible y eficaz de insertar variables, expresiones y llamadas a funciones directamente en cadenas.

Un ejemplo sencillo de la sintaxis básica de una cadena f es el siguiente.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)

   My name is Mark.

En este código, a la variable output_string se le asigna una cadena f. El prefijo f antes de las comillas de apertura indica que la cadena admite expresiones incrustadas. Se evalúa la variable name y su valor se inserta en la cadena, dando como resultado la salida : "My name is Mark."

En las cadenas f no sólo se pueden insertar valores variables, sino también cálculos o expresiones. Considera este ejemplo.

import math


a = 3.0
b = 4.0


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.

La expresión math.sqrt(a ** 2 + b ** 2) se evalúa directamente dentro de la cadena, eliminando la necesidad de calcular el valor por separado antes de insertarlo en la cadena.

Utilizando el método .format()

Al igual que las cadenas f, el método.format() permite insertar variables y expresiones en una cadena. La sintaxis básica del método .format() es la siguiente.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)

   My name is Mark.

Las llaves {} sirven como marcador de posición, indicando que el valor de una variable se insertará en la cadena en esa posición. El valor específico de la variable insertada en el marcador de posición viene determinado por el argumento proporcionado al método .format().

Argumentos posicionales

¿Qué ocurre si necesitas varios marcadores de posición para varias variables? Considera el siguiente código.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

En este ejemplo, se necesitan dos variables, name y age. En consecuencia, la cadena incluye dos marcadores de posición, y las variables se insertan en el mismo orden en que aparecen en el método .format(). Estos argumentos se conocen como argumentos *posicionales* de porque su ubicación en la cadena viene determinada por su posición en la lista de argumentos del método.

Marcadores de posición indexados y con nombre

Como variación de la idea del marcador de posición, considera este ejemplo.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

Aquí hemos reutilizado dos veces el valor de la variable age. Incluir la misma variable varias veces de esta forma es engorroso y resta legibilidad. ¿Hay alguna forma de reutilizar una variable en cadena formateada con el método .format() sin repetirla? Sí, existe, utilizando los llamados *marcadores de posición indexados*.

name = 'Mark'
age = 7


# Use indexed placeholders
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

En este ejemplo, hemos definido explícitamente el orden de las variables dentro de las llaves, siguiendo la indexación basada en cero de Python. Además, reutilizamos la variable del índice 1 en lugar de repetirla.

Como alternativa a la indexación posicional, también puedes utilizar argumentos con nombre, en los que a cada argumento se le da un nombre.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))

   My name is Mark and I am 7 years old.

El argumento nombrado se evalúa dentro de las llaves que especifican su nombre. Como resultado, el marcador de posición {name} se sustituye por el valor "Mark", y el marcador de posición {age} se sustituye por 30.

Utilizar el operador %

El último método de interpolación de cadenas es el operador%. Funciona de forma similar al comando printf() en C. Su uso está obsoleto y totalmente desaconsejado en favor de las cadenas f o del método.format(). Se menciona aquí porque puedes encontrarlo en bases de código heredadas.

El formato básico del operador % es: "format string" % values. La cadena de formato contiene marcadores de posición, como %s para cadenas, que se sustituyen por valores. Por ejemplo, el siguiente ejemplo imprime "Hola, Mark".

'Hello %s' % 'Mark'

   'Hello Mark'

En la tabla siguiente se muestran otros especificadores de formato habituales.

El operador % tiene muchas limitaciones. Por un lado, es menos legible que las cadenas f. Considera el siguiente código.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

¿Está claro este código a simple vista? Probablemente no. Hay mucho análisis visual de ida y vuelta entre el marcador de posición y las variables que rellenan los espacios en blanco. Es fácil confundirse (o marearse) con tanta exploración de un lado a otro.

Ahora, considera un código equivalente utilizando cadenas f.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

No es necesario escanear ni utilizar oscuras cadenas de formato. El código es limpio, fácil de entender y fácil de escribir. Puedes aprender otros consejos para escribir código claro y optimizado conel curso de habilidades de Programación en Python de DataCamp. 

Técnicas avanzadas de interpolación de cadenas en Python

Ahora que hemos entendido lo básico de la interpolación de cadenas en Python, veamos algunos usos más avanzados. 

Interpolación de cadenas multilínea en Python

Las cadenas f también pueden utilizarse para contenido multilínea utilizando el significante f con comillas triples (simples o dobles). El texto puede escribirse en varias líneas, y aparecerá en la salida exactamente como se formateó.

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

 También se pueden crear cadenas multilínea utilizando el método .format().

name = 'Mark'
profession = 'Astronaut'
age = 7


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Casos prácticos de interpolación de cadenas multilínea

¿Por qué querrías utilizar la interpolación de cadenas multilínea? La interpolación de cadenas multilínea tiene muchos usos. Aquí tienes algunos casos de uso:

• Generar correos electrónicos o mensajes multilínea
• Registro y depuración
• Generar consultas SQL dinámicamente

Generar correos electrónicos o mensajes multilínea

Supón que envías una carta formulario a muchos invitados a una conferencia tecnológica.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event Team

Con las cadenas f, crear una carta formulario es sencillo y eficaz. Para cambiar el nombre, el evento o la fecha, basta con cambiarlos en las variables y la cadena cambiará automáticamente.

Registro y depuración

Las cadenas multilínea son útiles para imprimir mensajes de error en los registros.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.

Este método mantiene estructurados los mensajes de registro y facilita la depuración con registros formateados correctamente.

Generar consultas SQL dinámicamente

Las consultas SQL pueden construirse dinámicamente utilizando cadenas multilínea.

table = 'users'
column = 'email'
value = 'alice@example.com'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)

   SELECT *

   FROM users

   WHERE email = 'alice@example.com';

Este método hace que las consultas SQL sean legibles y mantiene la sangría. Además, elimina la necesidad de utilizar + para la concatenación de cadenas.

Otros casos de uso son:

• Redactar contratos con formato
• Crear Markdown o $\LaTeX$ documentos
• Plantillas HTML/XML multilínea
• Generar respuestas API o texto tipo JSON

Ventajas de la interpolación de cadenas multilínea

Como vemos, la interpolación de cadenas multilínea tiene varias ventajas.

• La interpolación de cadenas conserva el formato sin necesidad del carácter de escape \n.
• La interpolación de cadenas mejora la legibilidad en comparación con el formato de una sola línea. 
• La interpolación de cadenas reduce el desorden al trabajar con texto estructurado (por ejemplo, registros, consultas, informes). 
• La interpolación de cadenas permite la generación dinámica de texto sin romper la sangría. 

Formatear números y valores especiales

Para controlar el número de decimales mostrados mediante una cadena f, utiliza la sintaxis: f'{value:.nf}', donde value es el número en coma flotante, n es el número de decimales, y f (el que va después de .) significa formato de coma flotante.

Para ilustrarlo, el siguiente código da como resultado $\pi$ con diferentes decimales.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

El formateo con el método .format() es similar.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

Puedes utilizar una cadena f para formatear porcentajes utilizando la sintaxis :.nf combinada con %, donde n es el número de decimales.

score = 0.875
print(f"Success rate: {score:.2%}")

   Success rate: 87.50%

Puedes utilizar una cadena f para dar formato a la moneda utilizando :, para los separadores de miles y .nf para controlar los decimales. También puedes incluir un símbolo de moneda como $, € o £ directamente en la cadena.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

Utilizar cadenas f con diccionarios y listas

Para utilizar cadenas f con un diccionario en Python, accede a los valores del diccionario dentro de las llaves utilizando la notación de corchetes (dict['clave']) o descomprimiendo el diccionario con **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")

   My name is Alice, I am 30 years old, and I live in New York.

En lugar de acceder manualmente a cada clave, puedes descomprimir el diccionario en una cadena f como se indica a continuación.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))

   My name is Alice and I am 7 years old.

Para evitar un error por falta de claves, utiliza get() para el acceso al diccionario.

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") 

   ---------------------------------------------------------------------------




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Error: key 'city' is missing

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'

print(f"City: {person.get('city', 'Not specified')}")

   City: Not specified

Ventajas e inconvenientes de los métodos de interpolación de cadenas

Como hemos visto, tanto las cadenas f como el método .format() son métodos útiles para la interpolación de cadenas. Veamos una comparación de los pros y los contras de cada método.

¿Cuándo debes utilizar .format() sobre cadenas f?

Errores comunes y buenas prácticas

A continuación, encontrarás algunos métodos de resolución de problemas y los mejores consejos para utilizar la interpolación de cadenas de Python. 

Evitar errores de sintaxis con llaves

Se pueden cometer muchos errores sintácticos al utilizar la interpolación de cadenas con llaves.

• Asegúrate de que cada { tiene un } coincidente

print('Hello, my name is {name!'}

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('

Afortunadamente, el error es sencillo, y la solución es fácil.

• Utiliza {{ y }} para mostrar {} literales

¿Qué ocurre si quieres imprimir llaves dentro de una cadena interpolada? Todo lo que esté entre llaves se evaluará (o intentará evaluarse).

print(f'Set notation: {a, b, c}')

   ---------------------------------------------------------------------------

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not defined

Python interpreta a, b, c dentro de las llaves como una tupla, intentando encontrar un valor asociado a a. Como no existe tal variable, se produce un KeyError. La solución es utilizar dobles llaves {{}}.

print("Set notation: {{a, b, c}}")

   Notación de conjunto: {{a, b, c}}

Comparación de rendimiento: cadenas f frente a .format()

Comparemos el rendimiento de las cadenas f y .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Measure f-string performance
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Measure .format() performance
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

Como puedes ver, desde el punto de vista de la eficacia, hay que preferir las cadenas f a .format().

Buenas prácticas para una interpolación de cadenas limpia y legible

Para asegurarte de que el formato de tus cadenas es claro, eficiente y fácil de mantener, sigue estas buenas prácticas cuando utilices cadenas interpoladas.

• Prefiere cadenas f para facilitar la lectura (Python 3.6+)

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


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Utiliza marcadores de posición con nombre para mayor claridad

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Mantén legibles las cadenas multilínea.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  

• Utiliza cadenas f en el registro para mejorar la depuración

Python 3.8 y posteriores admiten = para depurar en cadenas f.

value = 42


# Output: value = 42
print(f"{value = }") 

   value = 42

Conclusión

La interpolación de cadenas es una potente función de Python que hace que el formato de las cadenas sea más limpio, legible y eficaz. Entre los métodos disponibles, las cadenas f son el enfoque más moderno y recomendado, ya que ofrecen mejor rendimiento, claridad y flexibilidad que métodos más antiguos como .format() y el formato % .

Siguiendo las mejores prácticas, como utilizar marcadores de posición con nombre, controlar la precisión decimal, alinear el texto para que sea legible y gestionar con elegancia las claves de diccionario que faltan, puedes escribir en Python un formato de cadena limpio, profesional y fácil de mantener. 

Tanto si estás generando informes formateados, mensajes multilínea o salidas de datos estructurados, las cadenas f proporcionan una forma sencilla pero potente de integrar variables y expresiones a la perfección. Adoptar cadenas f no sólo mejorará la calidad de tu código, sino que también aumentará su eficacia. 

Para más información sobre la interpolación de cadenas en Python, consulta los recursos de DataCamp:

• Formato de cadena f en Python tutorial
• Python Añadir cadena: 6 Técnicas esenciales de concatenación
• Programación en Python vía de habilidad
• Fundamentos de Python pista de habilidades
• Introducción a la Ciencia de Datos en Python curso