Formateo de cadenas con f-Strings de Python 3

F-Strings, tienen el prefijo f y contienen los campos de reemplazo con llaves. Nos permiten formatear cadenas y evaluar expresiones más rápido en Python.

Introducción

Python 3.6 introdujo una nueva forma de formatear cadenas: f-Strings. Es más rápido que otros métodos de formato de cadena en Python y nos permite evaluar las expresiones de Python dentro de una cadena.

En esta publicación, veremos las diversas formas en que podemos formatear cadenas en Python. Luego, analizaremos más a fondo las cadenas f, y veremos cómo podemos usarlas al mostrar diferentes datos.

Formato tradicional de cadenas en Python

Antes de entrar en f-Strings, echemos un vistazo a las opciones más "tradicionales" formato de cadena disponibles en Python. Si solo quieres pasar a aprender sobre f-Strings, consulta la sección Formateo de cadenas con f-Strings de este artículo.

Concatenación de cadenas

La concatenación de cadenas significa que estamos combinando dos cadenas para crear una nueva. En Python, normalmente concatenamos cadenas con el operador +.

En su intérprete de Python, usemos la concatenación para incluir una variable en una cadena:

1
2
name = "Python"
print("I like " + name + " very much!")

Vería el siguiente resultado:

1
I like Python very much!

La concatenación de cadenas solo funciona en cadenas. Si desea que se incluyan datos que no sean cadenas, debe convertirlos manualmente.

Veamos concatenando un número con una cadena:

1
2
age = (10 + 5) * 2
print("You wouldn't believe me, but I am only " + age + " years old")

Al ejecutar lo anterior, verá este error:

1
2
3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Ahora, vamos a convertir edad en una cadena:

1
2
age = (10 + 5) * 2
print("You wouldn't believe me, but I am only " + str(age) + " years old")

El intérprete mostraría correctamente:

1
You wouldn't believe me, but I am only 30 years old

Este método no siempre es el más rápido de evaluar para Python, ni es fácil de manejar para los humanos con muchas variables. Es mejor usar los métodos de formato de cadena dedicados de Python.

Formato de cadena estilo C

El formato de cadena de estilo C, también conocido como estilo printf, utiliza cadenas como plantillas que están marcadas con % para que las variables puedan sustituirse.

Por ejemplo, %d le dice a Python que estamos sustituyendo un número, mientras que %s le dice a Python que estamos sustituyendo una cadena.

También hay algunos mecanismos de control disponibles, por ejemplo, %02d asegura que el número tenga al menos 2 dígitos, y si no es así, el resto se llenará con ceros. Podemos usar un marcador como %.4f para sustituir un decimal con exactamente 4 puntos flotantes en la cadena.

En su intérprete de Python, escriba el siguiente código para que podamos ver el formato de cadena de estilo C en acción:

1
2
3
print('Here is an integer %02d' % 4)
print('And a float: %.2f' % 3.141592)
print("And a %s with %d replacements" % ("mess", 2))

Su salida debe ser:

1
2
3
Here is an integer 04
And a float: 3.14
And a mess with 2 replacements

Como puede ver, con más y más argumentos, se vuelve bastante complicado y difícil de seguir. Entonces, Python lleva esto un paso más allá y le permite usar diccionarios en formato %.

Aunque no es una gran mejora en su estética general, podría ayudar un poco en el frente de la legibilidad.

Intente formatear una cadena de estilo C con un diccionario:

1
print('Using %(dictionary)s format in C-style string formatting, here is %(num)d number to make it more interesting!' % {'dictionary': "named", "num": 1})

Como puedes ver, podemos especificar el nombre entre paréntesis entre el % y el resto del identificador.

Su intérprete debe mostrar:

1
Using named format in C-style string formatting, here is 1 number to make it more interesting!

Si no ha pasado los últimos 42 años desarrollando en C, es posible que la sintaxis anterior no sea de su agrado. Como tal, Python nos da otra opción usando el método format() en cadenas.

Función de formato de Python() {#función de formato de Python}

La función format() se comporta de manera similar al formato de estilo C, pero es mucho más legible. Funciona invocando el método format() en su cadena mientras proporciona los reemplazos en la plantilla entre corchetes - {}.

Usando su intérprete de Python, usaremos el método format () para formatear una cadena. Comencemos sustituyendo una cadena:

1
print("This is a first {}".format("attempt!"))

La salida será:

1
This is a first attempt!

Podemos usar corchetes varias veces, sustituyendo las variables en orden:

1
print("And {} can add {} string too.".format("we", "more"))

Producción:

1
And we can add more string too.

También podemos nombrar las variables que estamos formateando:

1
print("String format also supports {dictionary} arguments.".format(dictionary="named"))

El código anterior debe imprimir:

1
String format also supports named arguments.

Si bien este método es muy legible, Python es más eficiente con f-Strings, además de ser legible. Echemos un vistazo a f-Strings más de cerca.

Formato de cadenas con f-Strings

F-Strings, o literales de cadena con formato, tienen el prefijo f y contienen los campos de reemplazo con llaves. Se evalúan en tiempo de ejecución, lo que las convierte en la opción de formato de cadena más rápida en Python (al menos en la implementación estándar de CPython).

Primero, verifique que tenga una versión de Python que sea 3.6 o superior:

1
2
$ python3 --version
Python 3.6.0

Si su versión de Python es inferior a 3.6, debe actualizar para usar esta función.

Los literales de cadena F comienzan con una f, seguida de cualquier tipo de cadena (es decir, comillas simples, comillas dobles, comillas triples), luego puede incluir su expresión de Python dentro de la cadena, entre corchetes.

Hagamos una cadena para usar una f-String en su shell de Python:

1
2
name = "f-String"
print(f"hello {name}!")

Y ahora ejecútalo para ver la magia:

1
hello f-String!

Es muy similar a usar la función format(). Sin embargo, viene con muchas características que no están disponibles con otros métodos de formateo.

Echemos un vistazo a esas características, comenzando con cadenas de varias líneas.

Cadenas f multilínea {#cadenas multilínea}

F-Strings permite cadenas de varias líneas, todo lo que tiene que hacer es envolverlas entre paréntesis:

1
2
3
4
5
6
7
name = "World"
message = (
  f"Hello {name}. "
  "This is from a multi-lined f-string. "
  f"Have a good day, {name}"
)
print(message)

Verá esto impreso:

1
Hello World. This is from a multi-lined f-string. Have a good day, World

No olvide poner el literal f delante de las líneas que tienen reemplazos. De lo contrario, las sustituciones no funcionarán.

Evaluación de expresiones Python en f-Strings

Los f-Strings de Python le permiten hacer expresiones directamente en la propia cadena. La siguiente cadena es válida:

1
2
number = 10
print(f"{number} + 1 = {number+1}")

Y salidas:

1
10 + 1 = 11

Puede incluir cualquier expresión válida que desee, siempre que no tenga caracteres especiales. Por ejemplo, podemos tener llamadas a funciones:

1
2
3
4
def func():
  return 42

print(f"func() = {func()}")

Esto devuelve:

1
func() = 42

Clases de formato con f-Strings

Puede incluir objetos creados a partir de clases en un f-String. Cada clase tiene dos métodos diferentes que permiten convertir un objeto en una cadena:

  • El método __str__() de un objeto debe devolver una cadena que el usuario pueda mostrar y comprender. Eso significa que no debe tener ninguna información secreta que deba mantenerse oculta para el usuario, y no debe tener ningún mensaje de depuración.
  • El método __repr__() de un objeto debería devolver una cadena más detallada, que posiblemente contenga información de depuración.

f-Strings llama automáticamente a __str__() para el objeto que les proporcionas.

Probemos nuestros f-Strings con una clase para verlo por nosotros mismos. Crearemos una clase Usuario que almacene nuestro nombre y el ID de la base de datos asociada que utiliza nuestro sistema imaginario.

Cree un nuevo archivo llamado fstring_classes.py y agregue lo siguiente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# fstring_classes.py

class User:
    def __init__(self, name, db_id):
        self.name = name
        self.db_id = db_id

    def __str__(self):
        return f"User with name: {self.name}"

my_user = User("Sajjad", 12)
print(f"{my_user}")

En su Terminal, ejecute el archivo con Python:

1
$ python fstring_classes.py

Este programa mostrará:

1
User with name: Sajjad

Si quisiéramos usar un f-String con el método __repr_() de un objeto, puedes poner un !r delante del objeto que vas a sustituir.

Edite el archivo fstring_classes.py y cambie la última línea:

1
print(f"{my_user}")

En lo siguiente, que incluye el sufijo !r:

1
print(f"{my_user!r}")

Ahora podemos ejecutar este programa de nuevo:

1
$ python fstring_classes.py

Y nuestra salida será:

1
User with name: Sajjad with id 12

Manejo de caracteres especiales en f-Strings

F-Strings, como cualquier otra cadena de Python, admite el uso de barras invertidas para escapar de los caracteres. Todos los siguientes son Python f-Strings válidos:

1
print(f'escaping with \\ is also possible, like: \'')

Ejecutar esto imprimirá:

1
escaping with \ is also possible, like: '

Sin embargo, hay una limitación, no podemos usar barras invertidas dentro de las llaves (la parte de expresión de la cadena f). Si intenta lo siguiente en su intérprete de Python:

1
print(f'{ord("\n")}')

Obtendrá el siguiente error:

1
2
  File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash

La misma limitación se aplica a las comillas del mismo tipo. El código a continuación:

1
2
a = {"key": "value"}
print(f"the value is {a["key"]}")

Nos da este error de sintaxis:

1
2
3
4
  File "<stdin>", line 1
    print(f"the value is {a["key"]}")
                               ^
SyntaxError: invalid syntax

Para evitar estos problemas, podemos calcularlos fuera de la f-String:

1
2
ord_newline = ord("\n")
print(f'{ord_newline}')

Que imprime:

1
10

O podemos usar diferentes tipos de cotización:

1
2
a = {"key": "val"}
print(f"The value is {a['key']}")

Que muestra:

1
The value is val

Conclusión

En esta publicación, analizamos diferentes métodos de formato de cadena en Python, con un enfoque en el método f-String. En Python, tenemos muchas opciones, ya que podemos concatenar cadenas, usar formato C-Style con % o el método format() en cadenas.

Sin embargo, con f-Strings, obtenemos una solución legible para la que Python se ha optimizado. Aparte de sus ventajas de velocidad, hemos visto lo bien que funciona f-Strings con la evaluación de expresiones y objetos de clases. lases.

Licensed under CC BY-NC-SA 4.0