Python Language
Formato de cadena

Introducción

Sintaxis

• "{}". formato (42) ==> "42"
• "{0}". Formato (42) ==> "42"
• "{0: .2f}". Formato (42) ==> "42.00"
• "{0: .0f}". Formato (42.1234) ==> "42"
• "{answer}". formato (no_answer = 41, respuesta = 42) ==> "42"
• "{answer: .2f}". format (no_answer = 41, answer = 42) ==> "42.00"
• "{[clave]}". formato ({'clave': 'valor'}) ==> "valor"
• "{[1]}". Formato (['cero', 'uno', 'dos']) ==> "uno"
• "{answer} = {answer}". formato (respuesta = 42) ==> "42 = 42"
• '' .join (['stack', 'overflow']) ==> "stack overflow"

Observaciones

Conceptos básicos de formato de cadena

foo = 1
bar = 'bar'
baz = 3.14

Puedes usar str.format para formatear la salida. Los pares de corchetes se reemplazan con argumentos en el orden en que se pasan los argumentos:

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

Los índices también se pueden especificar dentro de los corchetes. Los números corresponden a los índices de los argumentos pasados ​​a la función str.format (basado en 0).

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

Los argumentos con nombre también se pueden utilizar:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

Se puede hacer referencia a los atributos de los objetos cuando se pasan a str.format :

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

Las claves del diccionario se pueden utilizar también:

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

Lo mismo se aplica a los índices de lista y tupla:

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

Nota: Además de str.format , Python también proporciona el operador de módulo % también conocido como operador de formateo o interpolación de cadenas (ver PEP 3101 ), para el formato de cadenas. str.format es un sucesor de % y ofrece una mayor flexibilidad, por ejemplo, al facilitar la realización de múltiples sustituciones.

Además de los índices de argumentos, también puede incluir una especificación de formato dentro de los corchetes. Esta es una expresión que sigue reglas especiales y debe ser precedido por dos puntos ( : ). Consulte la documentación para obtener una descripción completa de la especificación de formato. Un ejemplo de especificación de formato es la directiva de alineación :~^20 ( ^ significa alineación central, ancho total 20, relleno con ~ carácter):

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format permite un comportamiento no posible con % , por ejemplo, la repetición de argumentos:

t = (12, 45, 22222, 103, 6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)    
# Out: 12 22222 45 22222 103 22222 6 22222

Como el format es una función, se puede usar como un argumento en otras funciones:

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

from datetime import datetime,timedelta
    
once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)
    
gen = (once_upon_a_time + x * delta for x in xrange(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 2010-07-01 12:00:00
#     2010-07-14 20:20:00
#     2010-07-28 04:40:00
#     2010-08-10 13:00:00
#     2010-08-23 21:20:00

Alineación y relleno.

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

Nota: puede obtener los mismos resultados utilizando las funciones de cadena ljust() , rjust() , center() , zfill() , sin embargo, estas funciones están en desuso desde la versión 2.5.

Formato literales (f-string)

Las cadenas de formato literal se introdujeron en PEP 498 (Python3.6 y versiones posteriores), lo que le permite anteponer f al comienzo de un literal de cadena para aplicar efectivamente el .format con todas las variables en el alcance actual.

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

Esto también funciona con cadenas de formato más avanzadas, incluida la alineación y la notación de puntos.

>>> f'{foo:^7s}'
'  bar  '

Nota: La f'' no denota un tipo particular como b'' para bytes ou u'' para unicode en python2. El formateo se aplica inmediatamente, lo que resulta en una agitación normal.

Las cadenas de formato también se pueden anidar :

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

Las expresiones en una cadena-f se evalúan en orden de izquierda a derecha. Esto es detectable solo si las expresiones tienen efectos secundarios:

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

Formato de cadena con fecha y hora

Cualquier clase puede configurar su propia sintaxis de formato de cadena a través del método __format__ . Un tipo en la biblioteca estándar de Python que hace un uso práctico de esto es el tipo datetime , donde se pueden usar códigos de formato similares a strftime directamente dentro de str.format :

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

Se puede encontrar una lista completa de la lista de formateadores de fecha y hora en la documentación oficial .

Formato utilizando Getitem y Getattr

Cualquier estructura de datos que admita __getitem__ puede tener su estructura anidada formateada:

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

A los atributos de los objetos se puede acceder usando getattr() :

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

Formato flotante

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

Lo mismo vale para otra forma de referenciar:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

Los números de punto flotante también se pueden formatear en notación científica o como porcentajes:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

También puede combinar las notaciones {0} y {name} . Esto es especialmente útil cuando desea redondear todas las variables a un número de decimales preespecificado con 1 declaración :

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

Formato de valores numéricos

El método .format() puede interpretar un número en diferentes formatos, tales como:

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

Formato de enteros a diferentes bases (hex, oct, binario)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

Use el formato para convertir una tupla flotante RGB en una cadena hexadecimal de color:

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

Solo se pueden convertir enteros:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

Formato personalizado para una clase

Nota:

Todo lo siguiente se aplica al método str.format , así como a la función de format . En el texto de abajo, los dos son intercambiables.

Para cada valor que se pasa a la función de format , Python busca un método __format__ para ese argumento. Por lo tanto, su propia clase personalizada puede tener su propio método __format__ para determinar cómo la función de format mostrará y formateará su clase y sus atributos.

Esto es diferente al método __str__ , ya que en el método __format__ puede tener en cuenta el idioma del formato, incluida la alineación, el ancho del campo, etc. e incluso (si lo desea) implementar sus propios especificadores de formato y sus propias extensiones de lenguaje de formato. 1

object.__format__(self, format_spec)

Por ejemplo :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

Nota:

Si su clase personalizada no tiene un método __format__ personalizado y se __format__ una instancia de la clase a la función de format , Python2 siempre usará el valor de retorno del método __str__ o el método __repr__ para determinar qué imprimir (y si no existe ninguno, entonces se utilizará la repr predeterminada), y deberá usar el especificador de formato s para formatear esto. Con Python3 , para pasar su clase personalizada a la función de format , necesitará definir el método __format__ en su clase personalizada.

Formateo anidado

Algunos formatos pueden tomar parámetros adicionales, como el ancho de la cadena con formato o la alineación:

>>> '{:.>10}'.format('foo')
'.......foo'

También se pueden proporcionar como parámetros para format anidando más {} dentro de {} :

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

En el último ejemplo, la cadena de formato '{:{}{}{}}' se modifica a '{:*^15}' (es decir, "centro y pad con * a una longitud total de 15") antes de aplicarla a la cadena real 'foo' para ser formateada de esa manera.

Esto puede ser útil en casos en que los parámetros no se conocen de antemano, por ejemplo al alinear datos tabulares:

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

Acolchado y cuerdas truncantes, combinadas.

Digamos que quieres imprimir variables en una columna de 3 caracteres.

Nota: doblando { y } se les escapa.

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

Salida:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

Marcadores de posición nombrados

Las cadenas de formato pueden contener marcadores de posición con nombre que se interpolan usando argumentos de palabras clave para dar format .

Usando un diccionario (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

Usando un diccionario (Python 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map permite usar diccionarios sin tener que descomprimirlos primero. También se usa la clase de data (que podría ser un tipo personalizado) en lugar de un dict recién llenado.

Sin un diccionario:

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'