Formateo de cadenas con f-Strings de Python 3

    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.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *