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)Con la tecnología de

   My name is Mark, I am 7 years old and my profession is Astronaut.Con la tecnología de

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)Con la tecnología de

   My name is Mark, I am 7 years old and my profession is Astronaut.Con la tecnología de

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)Con la tecnología de

   My name is Mark.Con la tecnología de

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)}.')Con la tecnología de

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.Con la tecnología de

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)Con la tecnología de

   My name is Mark.Con la tecnología de

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)Con la tecnología de

   My name is Mark and I am 7 years old.Con la tecnología de

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)Con la tecnología de

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Con la tecnología de

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)Con la tecnología de

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.Con la tecnología de

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))Con la tecnología de

   My name is Mark and I am 7 years old.Con la tecnología de

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'Con la tecnología de

   'Hello Mark'Con la tecnología de

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)Con la tecnología de

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Con la tecnología de

¿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)Con la tecnología de

   My name is Alice, I am 30 years old, and my height is 5.6 feet.Con la tecnología de

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)Con la tecnología de

   Name: Mark

   Profession: Astronaut

   Age: 7Con la tecnología de

 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)Con la tecnología de

   Name: Mark

   Profession: Astronaut

   Age: 7Con la tecnología de

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)Con la tecnología de

   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 TeamCon la tecnología de

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)Con la tecnología de

   [ERROR 404]

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

   URL: /missing-page

 

   The requested page could not be found.Con la tecnología de

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 = '[email protected]'


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


print(query)Con la tecnología de

   SELECT *

   FROM users

   WHERE email = '[email protected]';Con la tecnología de

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}')Con la tecnología de

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Con la tecnología de

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))Con la tecnología de

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3Con la tecnología de

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%}")Con la tecnología de

   Success rate: 87.50%Con la tecnología de

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}")Con la tecnología de

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Con la tecnología de

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']}.")Con la tecnología de

   My name is Alice, I am 30 years old, and I live in New York.Con la tecnología de

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))Con la tecnología de

   My name is Alice and I am 7 years old.Con la tecnología de

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']}") Con la tecnología de

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




   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'Con la tecnología de

print(f"City: {person.get('city', 'Not specified')}")Con la tecnología de

   City: Not specifiedCon la tecnología de

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!'}Con la tecnología de

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('Con la tecnología de

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}')Con la tecnología de

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

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

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

   NameError: name 'c' is not definedCon la tecnología de

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}}")Con la tecnología de

   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")Con la tecnología de

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsCon la tecnología de

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))Con la tecnología de

   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.Con la tecnología de

• 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))Con la tecnología de

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Con la tecnología de

• 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)Con la tecnología de

   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  Con la tecnología de

• 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 = }") Con la tecnología de

   value = 42Con la tecnología de

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