Formateo de cadenas con f-Strings de Python 3

F

Introducción

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

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

Formato de cadena tradicional en Python

Antes de entrar en f-Strings, echemos un vistazo a las opciones de formato de cadenas más “tradicionales” disponibles en Python. Si solo desea pasar a aprender sobre f-Strings, consulte la sección Formateo de cadenas con f-Strings en 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:

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

Vería el siguiente resultado:

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:

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

Al ejecutar lo anterior, verá este error:

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

Ahora, vamos a convertir age a una String:

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

El intérprete mostraría correctamente:

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 para los humanos administrarlo con muchas variables. Es mejor utilizar los métodos de formato de cadenas dedicados de Python.

Formato de cadena de 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 lo es, el resto se completará 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:

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

Tu salida debería ser:

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. Así que Python lleva esto un paso más allá y le permite usar diccionarios en % formateo.

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:

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 puede ver, podemos especificar el nombre entre paréntesis entre el % y el resto del identificador.

Su intérprete debe mostrar:

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 format() método en cadenas.

Función de formato Python ()

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

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

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

La salida será:

This is a first attempt!

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

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

Salida:

And we can add more string too.

También podemos nombrar las variables que formateamos:

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

El código anterior debería imprimirse:

String format also supports named arguments.

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

Formateo de cadenas con f-Strings

Las cadenas F, o los literales de cadena formateados, 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 3.6 o superior:

$ python3 --version
Python 3.6.0

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

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

Vamos a encadenar para usar una f-String en su shell de Python:

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

Y ahora ejecútalo para ver la magia:

hello f-String!

Es muy similar a usar el format() función. Sin embargo, viene con muchas funciones que no están disponibles con otros métodos de formato.

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

F-Strings multilínea

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

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:

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

No olvide poner el f literal delante de las líneas que tienen reemplazos. Las sustituciones no funcionarán de otra manera.

Evaluación de expresiones de Python en cadenas f

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

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

Y salidas:

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:

def func():
  return 42

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

Esto devuelve:

func() = 42

Formateo de clases con cadenas f

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:

  • los __str__() El método de un objeto debe devolver una cadena que sea visible para el usuario y comprensible para él. Eso significa que no debe tener ninguna información secreta que deba mantenerse oculta al usuario, y no debe tener ningún mensaje de depuración.
  • los __repr__() El método de un objeto debe devolver una cadena más detallada, posiblemente conteniendo información de depuración.

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

Probemos nuestras f-Strings con una clase para verlo por nosotros mismos. Crearemos un User clase que almacena nuestro nombre y la identificación de la base de datos asociada que utiliza nuestro sistema imaginario.

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

# 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:

$ python fstring_classes.py

Este programa mostrará:

User with name: Sajjad

Si quisiéramos usar un f-String con el __repr_() método de un objeto, puede poner un !r delante de su objeto siendo sustituido.

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

print(f"{my_user}")

En lo siguiente, que incluye el !r sufijo:

print(f"{my_user!r}")

Ahora podemos ejecutar este programa nuevamente:

$ python fstring_classes.py

Y nuestra salida será:

User with name: Sajjad with id 12

Manejo de caracteres especiales en f-Strings

Las cadenas F, como cualquier otra cadena de Python, admiten el uso de barras invertidas para caracteres de escape. Todos los siguientes son cadenas f válidas de Python:

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

Ejecutar esto imprimirá:

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 prueba lo siguiente en su intérprete de Python:

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

Obtendrá el siguiente error:

  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 siguiente código:

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

Nos da este error de sintaxis:

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

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

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

Que imprime:

10

O podemos utilizar diferentes tipos de cotizaciones:

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

Que muestra:

The value is val

Conclusión

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

Sin embargo, con f-Strings, obtenemos una solución legible para la que Python se ha optimizado. Aparte de sus beneficios de velocidad, hemos visto lo bien que funcionan las cadenas f para evaluar expresiones y objetos de clases.

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad