Cómo usar formateadores de cadenas en Python 3

### Introducción

El método str.format() de la clase string en Python te permite realizar sustituciones de variables y formatear valores. Esto te permite concatenar elementos juntos dentro de una cadena mediante formato posicional.

Este tutorial te guiará a través de algunos de los usos comunes de formateadores en Python, los cuales pueden ayudar a que tu código y programa sean más legibles y amigables para el usuario.

Prerrequisitos

Deberías tener instalado Python 3 y un entorno de programación configurado en tu computadora o servidor. Si no tienes configurado un entorno de programación, puedes consultar las guías de instalación y configuración para un entorno de programación local o para un entorno de programación en tu servidor adecuado para tu sistema operativo (Ubuntu, CentOS, Debian, etc.)

## Uso de Formateadores

Los formateadores funcionan colocando uno o más campos de reemplazo o marcadores de posición, definidos por un par de llaves {}, en una cadena y llamando al método str.format(). Pasarás al método el valor que deseas concatenar con la cadena. Este valor se pasará en el mismo lugar donde se encuentra tu marcador de posición cuando ejecutes el programa.

Imprimamos una cadena que utilice un formateador:

print("Sammy has {} balloons.".format(5))

Output
Sammy has 5 balloons.

En el ejemplo anterior, construimos una cadena con un par de llaves como marcador de posición:

"Sammy has {} balloons."

Luego agregamos el método str.format() y pasamos el valor del entero 5 a ese método. Esto coloca el valor de 5 en la cadena donde estaban las llaves:

Sammy has 5 balloons.

También podemos asignar una variable para que sea igual al valor de una cadena que tiene marcadores de posición de formateador:

open_string = "Sammy loves {}."
print(open_string.format("open source"))

Output
Sammy loves open source.

En este segundo ejemplo, concatenamos la cadena "open source" con la cadena más grande, reemplazando las llaves en la cadena original.

Los formateadores en Python te permiten usar llaves como marcadores de posición para valores que pasarás con el método str.format().

##Usando Formateadores con Múltiples Marcadores de Posición

Puedes usar múltiples pares de llaves cuando usas formateadores. Si quisiéramos agregar otra sustitución de variable a la oración anterior, podemos hacerlo agregando un segundo par de llaves y pasando un segundo valor al método:

new_open_string = "Sammy loves {} {}."                      #2 {} marcadores de posición
print(new_open_string.format("open-source", "software"))    #Pasar 2 cadenas al método, separadas por una coma

Output
Sammy loves open-source software.

Para agregar otra sustitución, añadimos un segundo par de llaves en la cadena original. Luego, pasamos dos cadenas al método str.format(), separándolas por una coma.

Siguiendo la misma sintaxis, podemos agregar sustituciones adicionales:

sammy_string = "Sammy loves {} {}, and has {} {}."                      #4 {} marcadores de posición
print(sammy_string.format("open-source", "software", 5, "balloons"))    #Pasar 4 cadenas al método

Output
Sammy loves open-source software, and has 5 balloons.

En sammy_string agregamos 4 pares de llaves como marcadores de posición para la sustitución de variables. Luego, pasamos 4 valores al método str.format(), mezclando tipos de datos de cadena e entero. Cada uno de estos valores está separado por una coma.

##Reordenar Formateadores con Argumentos Posicionales y de Palabra Clave

Cuando dejamos las llaves vacías sin ningún parámetro, Python reemplazará los valores pasados a través del método str.format() en orden. Como hemos visto hasta ahora, una construcción de formateador con dos llaves vacías y dos valores pasados se verá así:

print("Sammy the {} has a pet {}!".format("shark", "pilot fish"))

Output
Sammy the shark has a pet pilot fish!

El primer par de llaves se sustituye con el valor de cadena "tiburón", y el segundo par se sustituye con el valor de cadena "pez piloto".

Los valores que existen dentro del método lucen así:

("shark", "pilot fish")

Básicamente son del tipo de datos tupla y cada valor individual contenido en la tupla puede ser llamado por su número de índice, que comienza con el número de índice 0.

Podemos pasar estos números de índice entre llaves que sirven como marcadores de posición en la cadena original:

print("Sammy the {0} has a pet {1}!".format("shark", "pilot fish"))

En el ejemplo anterior, la salida será lo que obtenemos sin pasar números de índice entre las llaves, ya que estamos llamando a los valores en la tupla en orden:

Output
Sammy the shark has a pet pilot fish!

Pero, si invertimos los números de índice con los parámetros de los marcadores de posición, podemos invertir los valores que se pasan a la cadena:

print("Sammy the {1} has a pet {0}!".format("shark", "pilot fish"))

Output
Sammy the pilot fish has a pet shark!

Si llamas a un número de índice 2 en una tupla que tiene valores en las posiciones de índice 0 y 1, entonces estás llamando a un valor que está fuera de rango. Cuando llamas a un número de índice que está fuera de rango, recibirás un mensaje de error:

print("Sammy the {2} has a pet {1}!".format("shark", "pilot fish"))

Output
IndexError: tuple index out of range

El mensaje de error que vemos se refiere a que la tupla solo tiene valores en los números de índice 0 y 1, por lo tanto, colocar el número de índice 2 está fuera de rango.

Añadamos unos cuantos marcadores de posición más y unos cuantos valores más para pasarles, así podremos entender cómo podemos reordenar los formateadores un poco mejor. Primero, aquí hay una nueva cadena con cuatro marcadores de posición:

print("Sammy is a {}, {}, and {} {}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a happy, smiling and blue shark!

Sin parámetros, los valores que se pasan al método str.format() se concatenan en la cadena en orden.

Los valores de cadena contenidos en la tupla corresponden a los siguientes números de índice:

Vamos a usar los números de índice de los valores para cambiar el orden en que aparecen en la cadena:

print("Sammy is a {3}, {2}, and {1} {0}!".format("happy", "smiling", "blue", "shark"))

Output
Sammy is a shark, blue, and smiling happy!

Dado que empezamos con el índice número 3, llamamos primero al último valor de "tiburón". Los otros números de índice incluidos como parámetros cambian el orden en que aparecen las palabras dentro de la cadena original.

Además de los argumentos posicionales, también podemos introducir argumentos de palabras clave que se llaman por su nombre de palabra clave:

print("Sammy the {0} {1} a {pr}.".format("shark", "made", pr = "pull request"))

Output
Sammy the shark made a pull request.

Este ejemplo muestra el uso de un argumento de palabra clave utilizado con argumentos posicionales. Podemos completar el argumento de palabra clave pr junto con los argumentos posicionales, y podemos mover estos argumentos para cambiar la cadena resultante:

print("Sammy the {pr} {1} a {0}.".format("shark", "made", pr = "pull request"))

Output
Sammy the pull request made a shark.

Los argumentos posicionales y de palabras clave utilizados con formateadores de cadenas nos dan más control sobre la manipulación de nuestras cadenas originales mediante la reordenación.

##Especificación de tipo

Podemos incluir más parámetros dentro de las llaves de nuestra sintaxis. Usaremos la sintaxis del código de formato {nombre_campo:conversión}, donde nombre_campo especifica el número de índice del argumento para el método str.format() que vimos en la sección de reordenamiento, y conversión se refiere al código de conversión del tipo de datos que estás utilizando con el formateador.

El tipo de conversión se refiere al código de tipo de un solo carácter que utiliza Python. Los códigos que usaremos aquí son s para cadena, d para mostrar enteros decimales (base 10) y f que usaremos para mostrar números flotantes con decimales. Puede obtener más información sobre el Lenguaje mini de especificación de formato a través de la documentación oficial de Python 3.

Veamos un ejemplo en el que se pasa un entero a través del método, pero queremos mostrarlo como un flotante añadiendo el argumento de tipo de conversión f:

print("Sammy ate {0:f} percent of a {1}!".format(75, "pizza"))

Output
Sammy ate 75.000000 percent of a pizza!

Usamos la sintaxis de {nombre_del_campo:conversión} para el primer campo de reemplazo de llaves para mostrar un flotante. Las segundas llaves solo usan el primer parámetro {nombre_del_campo}.

En el ejemplo anterior, hay muchos números que se muestran después del punto decimal, pero puedes limitar esos. Cuando estás especificando f para valores flotantes, también puedes especificar la precisión de ese valor incluyendo un punto completo . seguido del número de dígitos después del decimal que te gustaría incluir.

Si Sammy se comió el 75.765367% de la pizza, pero no necesitamos tener un alto nivel de precisión, podemos limitar los lugares después del decimal a 3 agregando .3 antes del tipo de conversión f:

print("Sammy ate {0:.3f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.765 percent of a pizza!

Si solo queremos un lugar decimal, podemos reescribir la cadena y el método así:

print("Sammy ate {0:.1f} percent of a pizza!".format(75.765367))

Output
Sammy ate 75.8 percent of a pizza!

Nota que modificar la precisión causará que el número se redondee.

Aunque mostramos un número sin decimales como un flotante, si intentamos cambiar el flotante a un entero usando el tipo de conversión d, recibiremos un error:

print("Sammy ate {0:d} percent of a pizza!".format(75.765367))

Output
ValueError: Unknown format code 'd' for object of type 'float'

Si deseas que no se muestren decimales, puedes escribir tu formateador de la siguiente manera:

print("Sammy ate {0:.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate 76 percent of a pizza!

Esto no convertirá tu flotante a un entero, sino que limitará el número de lugares mostrados después del punto decimal.

## Sustituciones de Variables con Relleno

Debido a que los marcadores de posición son campos de reemplazo, puedes rellenar o crear espacio alrededor de un elemento aumentando el tamaño del campo a través de parámetros adicionales. Esto puede ser útil cuando necesitamos organizar visualmente una gran cantidad de datos.

Podemos agregar un número para indicar el tamaño del campo (en términos de caracteres) después de los dos puntos : en las llaves de nuestra sintaxis:

print("Sammy has {0:4} red {1:16}!".format(5, "balloons"))

Output
Sammy has    5 red balloons        !

En el ejemplo anterior, dimos al número 5 un tamaño de campo de caracteres de 4, y a la cadena globos un tamaño de campo de caracteres de 16 (porque es una cadena larga).

Como vemos, por defecto las cadenas se justifican a la izquierda dentro del campo, y los números se justifican a la derecha. Puedes modificar esto colocando un código de alineación después de los dos puntos. < alineará a la izquierda el texto en un campo, ^ centrará el texto en el campo, y > lo alineará a la derecha.

¡Alineemos el número a la izquierda y centremos la cadena!

print("Sammy has {0:<4} red {1:^16}!".format(5, "balloons"))

Output
Sammy has 5    red     balloons    !

Ahora vemos que 5 está alineado a la izquierda, proporcionando espacio en el campo antes de red, y balloons está centrado en su campo con espacio a su izquierda y derecha.

Por defecto, cuando hacemos un campo más grande con formateadores, Python llenará el campo con caracteres de espacio en blanco. Podemos modificar eso para que sea un carácter diferente especificando el carácter que queremos que sea directamente después de los dos puntos:

print("{:*^20s}".format("Sammy"))

Output
*******Sammy********

Estamos aceptando la cadena que se pasa a str.format() en la posición de índice 0 ya que no lo especificamos de otra manera, incluyendo los dos puntos, y especificando que usaremos * en lugar de espacio para llenar el campo. Estamos centrando la cadena con ^, especificando que el campo tiene un tamaño de 20 caracteres, e indicando también que estamos trabajando con un tipo de conversión de cadena al incluir s.

Podemos combinar estos parámetros con otros parámetros que hemos usado antes:

print("Sammy ate {0:5.0f} percent of a pizza!".format(75.765367))

Output
Sammy ate    76 percent of a pizza!

En los parámetros dentro de las llaves, especificamos el número de campo de índice del flotante e incluimos los dos puntos, indicamos el tamaño del número de campo e incluimos el punto, escribimos el número de lugares después del punto decimal, y luego especificamos el tipo de conversión de f.

##Usando Variables

Hasta ahora, hemos pasado enteros, flotantes y cadenas al método str.format(), pero también podemos pasar variables a través del método. Esto funciona como cualquier otra variable.

nBalloons = 8
print("Sammy has {} balloons today!".format(nBalloons))

Output
Sammy has 8 balloons today!

Podemos usar variables tanto para la cadena original como para lo que se pasa al método:

sammy = "Sammy has {} balloons today!"
nBalloons = 8
print(sammy.format(nBalloons))

Output
Sammy has 8 balloons today!

Las variables pueden ser fácilmente sustituidas por cada parte de nuestra construcción de sintaxis de formateador. Esto facilita el trabajo cuando estamos recibiendo entrada generada por el usuario y asignando esos valores a variables.

##Usando Formateadores para Organizar Datos

Los formateadores pueden apreciarse mejor cuando se utilizan para organizar una gran cantidad de datos de manera visual. Si estamos mostrando bases de datos a los usuarios, el uso de formateadores para aumentar el tamaño del campo y modificar la alineación puede hacer que la salida sea más legible.

Veamos un bucle for típico en Python que imprimirá i, i*i, y i*i*i en el rango de 3 a 12:

for i in range(3,13):
    print(i, i*i, i*i*i)

Output
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
11 121 1331
12 144 1728

Aunque la salida está organizada de alguna manera, los números se desbordan en las columnas de los otros, haciendo que la parte inferior de la salida sea menos legible. Si estás trabajando con un conjunto de datos más grande con muchos números pequeños y grandes, esto puede representar un problema.

Utilicemos formateadores para dar más espacio a estos números:

for i in range(3,13):
    print("{:3d} {:4d} {:5d}".format(i, i*i, i*i*i))

Aquí, en nuestras llaves, no agregamos el nombre del campo para el número de índice y comenzamos con dos puntos, seguido del número para el tamaño del campo y un tipo de conversión d ya que estamos trabajando con enteros. En este ejemplo, nos hemos acomodado al tamaño de cada salida esperada, dando 2 espacios de caracteres adicionales para cada una, dependiendo del tamaño máximo posible del número, por lo que nuestra salida se ve así:

Output
  3    9    27
  4   16    64
  5   25   125
  6   36   216
  7   49   343
  8   64   512
  9   81   729
 10  100  1000
 11  121  1331
 12  144  1728

Podemos especificar un número de tamaño de campo consistente para tener columnas uniformes, asegurándonos de acomodar los números más grandes:

for i in range(3,13):
    print("{:6d} {:6d} {:6d}".format(i, i*i, i*i*i))

Output
     3      9     27
     4     16     64
     5     25    125
     6     36    216
     7     49    343
     8     64    512
     9     81    729
    10    100   1000
    11    121   1331
    12    144   1728

También podemos manipular la alineación de las columnas agregando <, ^, y > para la alineación del texto, cambiar d a f para añadir lugares decimales, cambiar números de índice de nombre de campo, y más para asegurarnos de que estamos mostrando los datos como queremos.

##Conclusión

El uso de formateadores para la sustitución de variables puede ser una forma efectiva de concatenar cadenas y organizar valores y datos. Los formateadores representan una manera básica pero no descriptiva de pasar sustituciones de variables en una cadena, y son útiles para asegurar que la salida sea legible y amigable para el usuario.