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

Supongamos que deseas mostrar el nombre y la profesión de una persona. Podrías escribir un programa simple de la siguiente manera.

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


# Mostrar información
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 mejor solución. Permite insertar variables, expresiones o salidas de funciones directamente en una cadena, haciendo que la manipulación de cadenas sea dinámica y eliminando la necesidad de concatenación manual.

Usando un enfoque de interpolación de cadenas, podríamos reescribir el código de la siguiente manera.

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


# Mostrar información
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 la necesidad de concatenaciones desordenadas. Como puedes ver, es un enfoque mucho más limpio.

Interpolación Básica de Cadenas en Python

Existen varias técnicas de interpolación de cadenas diferentes disponibles en Python. El método más comúnmente recomendado es el de literales de cadena formateados, también conocidos como f-strings, que están disponibles desde Python 3.6.

Otro método, comúnmente visto en el código más antiguo que Python 3.6, es el método .format(). Aunque este método es más verboso que las f-strings, ocasionalmente tiene ventajas (detalles abajo).

Finalmente, puedes encontrarte con % formato al estilo de legado.

Usando f-strings (Python 3.6+)

f-strings (literales de cadena formateados) son una manera poderosa y concisa de formatear cadenas en Python. Fueron introducidas en Python 3.6 y proporcionan una forma legible y eficiente de insertar variables, expresiones y llamadas de funciones directamente en las cadenas.

Un ejemplo simple de la sintaxis básica de una f-string es el siguiente.

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

   My name is Mark.

En este código, la variable output_string se le asigna una f-string. El f prefijo antes de la comilla de apertura indica que la cadena admite expresiones incrustadas. La variable name se evalúa y su valor se inserta en la cadena, lo que resulta en la salida: "Mi nombre es Mark."

No solo los valores de las variables, sino también cálculos o expresiones pueden insertarse en las f-strings. Considera este ejemplo.

import math


a = 3.0
b = 4.0


# Usar interpolación de cadena para la fórmula
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.

Usando el método .format()

Al igual que las f-strings, el .format() método permite insertar variables y expresiones en una cadena. La sintaxis básica del .format() método 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 es determinado por el argumento proporcionado al .format() método.

Argumentos posicionales

¿Qué sucede si necesitas múltiples marcadores de posición para varias variables? Considera el siguiente código.

name = 'Mark'
age = 7


# Los marcadores de posición se llenan en orden de los argumentos
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* porque su ubicación en la cadena está determinada por su posición en la lista de argumentos del método.

Marcadores de posición indexados y nombrados

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

name = 'Mark'
age = 7


# Imprimir la edad dos veces
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í, reutilizamos el valor de la variable age dos veces. Incluir la misma variable múltiples veces de esta manera es torpe y resta legibilidad. ¿Hay alguna forma de reutilizar una variable en una cadena formateada con el .format() sin repetirla? Sí, la hay, utilizando lo que se llama *marcadores de posición indexados*.

name = 'Mark'
age = 7


# Usar marcadores de posición indexados
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, definimos 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 en el índice 1 en lugar de repetirla.

Como alternativa a la indexación posicional, también puedes usar argumentos nombrados, donde cada argumento recibe 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 {name} marcador de posición es reemplazado con el valor "Mark", y el {age} marcador de posición es reemplazado con 30.

Utilizando el operador %.

El método final para la interpolación de cadenas es el operador %. Funciona de manera similar al comando printf() en C. Su uso está obsoleto y se desaconseja fuertemente a favor de las f-strings o el método .format(). Se menciona aquí porque es posible que lo encuentres en bases de código heredadas.

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

'Hello %s' % 'Mark'

   'Hello Mark'

Otros especificadores de formato comunes se muestran en la siguiente tabla.

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

name = "Alice"
age = 30
height = 5.6


# El operador % es difícil de escanear
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.

¿Es este código claro a simple vista? Probablemente no. Hay mucho análisis visual de un lado a otro desde el marcador de posición hasta las variables que llenan los espacios en blanco. Es fácil confundirse (o marearse) con todo ese escaneo de un lado a otro.

Ahora, considera un código equivalente usando f-strings.

# Esto es mucho más limpio
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 hay escaneo y no se requieren cadenas de formato oscuras. 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 con la pista de habilidades de programación de Python de DataCamp. . 

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

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

Interpolación de cadenas multilinea en Python

Las f-strings también se pueden usar para contenido multilinea usando el signo f con comillas triples (simples o dobles). El texto se puede escribir en varias líneas y aparecerá en la salida exactamente como se formateó.

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


# Este es un ejemplo de una cadena multilinea
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Las cadenas multilínea también se pueden crear usando el método .format().

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


# Esta es una cadena multilínea con .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Casos de uso para la interpolación de cadenas multilínea

¿Por qué querrías usar la interpolación de cadenas multilínea? Hay muchos usos para la interpolación de cadenas multilínea. Aquí hay algunos casos de uso:

• Generación de correos electrónicos o mensajes multilínea
• Registro y depuración
• Generación dinámica de consultas SQL

Generación de correos electrónicos o mensajes multilínea

Supongamos que estás enviando una carta modelo 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 f-strings, crear una carta modelo es simple y eficiente. Para cambiar el nombre, el evento o la fecha, simplemente cámbialos en las variables y la cadena cambia 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 los mensajes de registro estructurados y facilita la depuración con registros correctamente formateados.

Generación dinámica de consultas SQL

Las consultas SQL se pueden construir dinámicamente usando cadenas multilínea.

table = 'users'
column = 'email'
value = '[email protected]'


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


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

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

Otros casos de uso incluyen:

• Redacción de contratos formateados
• Creación de documentos Markdown o $\LaTeX$
• Plantillas HTML/XML multilineales
• Generando respuestas de API o texto similar a JSON

Ventajas de la interpolación de cadenas multilínea

Como podemos ver, hay varias ventajas de la interpolación de cadenas multilínea.

• 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 de texto dinámico sin romper la indentación.

Formateo de números y valores especiales

Para controlar el número de decimales mostrados usando un f-string, utiliza la sintaxis:f'{valor:.nf}', donde valor es el número de punto flotante, n es el número de decimales, y f (el que va después del .) significa formato flotante.

Para ilustrar, el siguiente código imprime $\pi$ en diferentes lugares 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 .format() método 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 usar una f-string para formatear porcentajes utilizando la :.nf sintaxis combinada con %, donde n es el número de lugares decimales.

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

   Success rate: 87.50%

Puedes usar una f-string para formatear la moneda utilizando :, para 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

Usando f-strings con diccionarios y listas

Para usar f-strings con un diccionario en Python, accede a los valores del diccionario dentro de las llaves utilizando la notación de corchetes cuadrados (dict[‘clave’]) o desempaquetando 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 a cada clave manualmente, puedes desempaquetar el diccionario en una f-string de la siguiente manera.

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 claves faltantes, utiliza get() para acceder al diccionario.

person = {"name": "Alice"}


# Error: falta la clave 'ciudad'
print(f"City: {person['city']}") 

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

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

         3 # Error: falta la clave 'ciudad'

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







   KeyError: 'city'

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

   City: Not specified

Pros y contras de los métodos de interpolación de cadenas

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

¿Cuándo deberías usar .format() en lugar de f-strings?

Desafíos comunes y mejores prácticas

A continuación, puedes encontrar algunos métodos de solución de problemas y consejos principales para usar la interpolación de cadenas en Python.

Avoiding syntax errors with curly braces

Hay muchos errores de sintaxis que se pueden cometer al utilizar la interpolación de cadenas que involucran llaves.

• Asegúrate de que cada { tenga su correspondiente }

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.

• Usa {{ y }} para mostrar {} literales

¿Qué sucede si quieres imprimir llaves dentro de una cadena interpolada? Todo lo que esté dentro de llaves (intentará) ser evaluado.

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 con a. Dado que no existe tal variable, genera un KeyError. La solución es usar dobles llaves {{}}.

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

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

Comparación de rendimiento: f-strings vs .format()

Comparemos el rendimiento de f-strings y .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Medir el rendimiento de las f-strings
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


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


# Medir el rendimiento de las f-strings con expresiones
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Medir el rendimiento de .format() con expresiones
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Imprimir resultados
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 se puede ver, desde un punto de vista de eficiencia, se deberían preferir las f-strings a .format().

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

Para asegurar que tu formato de cadena sea claro, eficiente y mantenible, sigue estas mejores prácticas cuando uses cadenas interpoladas.

• Preferir f-strings para legibilidad (Python 3.6+)

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


# No recomendado (Menos legible)
print("My name is {} and I am {} years old.".format(name, age))


# Evitar el uso de formateo % (Obsoleto)
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.

• Usar marcadores de posición con nombres para mayor claridad

# Marcadores con nombres (legibles)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Uso de índices en .format() (menos legible)
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.

• Mantenga 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  

• Utilice f-strings para depuración más efectiva

Python 3.8 y versiones posteriores admiten = para depuración en f-strings.

value = 42


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

   value = 42

Conclusión

La interpolación de cadenas es una característica poderosa en Python que hace que el formateo de cadenas sea más limpio, legible y eficiente. Entre los métodos disponibles, las f-strings son el enfoque más moderno y recomendado, ofreciendo un mejor rendimiento, claridad y flexibilidad sobre métodos más antiguos como .format() y formateo %. 

Al seguir las mejores prácticas, como usar marcadores de posición con nombre, controlar la precisión decimal, alinear el texto para facilitar la lectura y manejar de forma adecuada las claves faltantes en el diccionario, puedes escribir formatos de cadena limpios, profesionales y mantenibles en Python.

Ya sea que estés generando informes formateados, mensajes de varias líneas u salidas de datos estructurados, las f-strings proporcionan una forma simple pero poderosa de integrar variables y expresiones sin problemas. Adoptar las f-strings no solo mejorará la calidad de tu código, sino que también mejorará su eficiencia.

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

• Formato de cadenas f en Python tutorial
• Agregar cadena en Python: 6 técnicas esenciales de concatenación
• Programación en Python pista de habilidades
• Fundamentos de Python pista de habilidades
• Introducción a la Ciencia de Datos en Python curso