Formato de cadena:% vs. formato.

Python 2.6 introdujo el str.format()método con una sintaxis ligeramente diferente del %operador existente . ¿Cuál es mejor y para qué situaciones?

1. Lo siguiente usa cada método y tiene el mismo resultado, entonces, ¿cuál es la diferencia?

   #!/usr/bin/python
   sub1 = "python string!"
   sub2 = "an arg"
   
   a = "i am a %s" % sub1
   b = "i am a {0}".format(sub1)
   
   c = "with %(kwarg)s!" % {'kwarg':sub2}
   d = "with {kwarg}!".format(kwarg=sub2)
   
   print a    # "i am a python string!"
   print b    # "i am a python string!"
   print c    # "with an arg!"
   print d    # "with an arg!"
   

2. Además, ¿cuándo se produce el formateo de cadenas en Python? Por ejemplo, si mi nivel de registro está establecido en ALTO, ¿recibiré un golpe por realizar la siguiente %operación? Y si es así, ¿hay alguna manera de evitar esto?

   log.debug("some debug info: %s" % some_info)

Para responder a su primera pregunta ... .formatsimplemente parece más sofisticado en muchos sentidos. Una cosa molesta %es también cómo puede tomar una variable o una tupla. Uno pensaría que lo siguiente siempre funcionaría:

"hi there %s" % name

sin embargo, si namees así (1, 2, 3), arrojará un TypeError. Para garantizar que siempre se imprima, deberías hacer

"hi there %s" % (name,)   # supply the single argument as a single-item tuple

lo cual es feo .formatNo tiene esos problemas. También en el segundo ejemplo que diste, el .formatejemplo tiene un aspecto mucho más limpio.

¿Por qué no lo usarías?

• sin saberlo (yo antes de leer esto)
• tener que ser compatible con Python 2.5

Para responder a su segunda pregunta, el formateo de cadenas ocurre al mismo tiempo que cualquier otra operación, cuando se evalúa la expresión de formateo de cadenas. Y Python, al no ser un lenguaje vago, evalúa las expresiones antes de llamar a las funciones, por lo que en su log.debugejemplo, la expresión "some debug info: %s"%some_infoprimero evaluará, por ejemplo "some debug info: roflcopters are active", luego se pasará esa cadena log.debug().

Algo que el operador de módulo (%) no puede hacer, afaik:

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

resultado

12 22222 45 22222 103 22222 6 22222

Muy útil.

Otro punto: al format()ser una función, puede usarse como argumento en otras funciones:

li = [12,45,78,784,2,69,1254,4785,984]
print map('the number is {}'.format,li)   

print

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(20))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))

Resultados en:

['the number is 12', 'the number is 45', 'the number is 78', 'the number is 784', 'the number is 2', 'the number is 69', 'the number is 1254', 'the number is 4785', 'the number is 984']

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
2010-09-06 05:40:00
2010-09-19 14:00:00
2010-10-02 22:20:00
2010-10-16 06:40:00
2010-10-29 15:00:00
2010-11-11 23:20:00
2010-11-25 07:40:00
2010-12-08 16:00:00
2010-12-22 00:20:00
2011-01-04 08:40:00
2011-01-17 17:00:00
2011-01-31 01:20:00
2011-02-13 09:40:00
2011-02-26 18:00:00
2011-03-12 02:20:00

Suponiendo que está utilizando el loggingmódulo de Python , puede pasar los argumentos de formato de cadena como argumentos al .debug()método en lugar de hacerlo usted mismo:

log.debug("some debug info: %s", some_info)

lo que evita hacer el formateo a menos que el registrador realmente registre algo.

A partir de Python 3.6 (2016) puede usar cadenas f para sustituir variables:

>>> origin = "London"
>>> destination = "Paris"
>>> f"from {origin} to {destination}"
'from London to Paris'

Tenga en cuenta el f"prefijo. Si intenta esto en Python 3.5 o anterior, obtendrá un SyntaxError.

Ver https://docs.python.org/3.6/reference/lexical_analysis.html#f-strings

PEP 3101 propone el reemplazo del %operador con el nuevo formato de cadena avanzado en Python 3, donde sería el predeterminado.

Pero tenga cuidado, justo ahora descubrí un problema al intentar reemplazar todo %con el .formatcódigo existente: '{}'.format(unicode_string)intentará codificar unicode_string y probablemente fallará.

Solo mira este registro de sesión interactiva de Python:

Python 2.7.2 (default, Aug 27 2012, 19:52:55) 
[GCC 4.1.2 20080704 (Red Hat 4.1.2-48)] on linux2
; s='й'
; u=u'й'
; s
'\xd0\xb9'
; u
u'\u0439'

ses solo una cadena (llamada 'matriz de bytes' en Python3) y ues una cadena Unicode (llamada 'cadena' en Python3):

; '%s' % s
'\xd0\xb9'
; '%s' % u
u'\u0439'

Cuando le das un objeto Unicode como parámetro al %operador, producirá una cadena Unicode incluso si la cadena original no era Unicode:

; '{}'.format(s)
'\xd0\xb9'
; '{}'.format(u)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'latin-1' codec can't encode character u'\u0439' in position 0: ordinal not in range(256)

pero la .formatfunción generará "UnicodeEncodeError":

; u'{}'.format(s)
u'\xd0\xb9'
; u'{}'.format(u)
u'\u0439'

y funcionará con un argumento Unicode bien solo si la cadena original era Unicode.

; '{}'.format(u'i')
'i'

o si la cadena de argumento se puede convertir en una cadena (llamada 'matriz de bytes')

Otra ventaja más .format(que no veo en las respuestas): puede tomar propiedades de objeto.

In [12]: class A(object):
   ....:     def __init__(self, x, y):
   ....:         self.x = x
   ....:         self.y = y
   ....:         

In [13]: a = A(2,3)

In [14]: 'x is {0.x}, y is {0.y}'.format(a)
Out[14]: 'x is 2, y is 3'

O, como argumento de palabra clave:

In [15]: 'x is {a.x}, y is {a.y}'.format(a=a)
Out[15]: 'x is 2, y is 3'

Esto no es posible con %lo que puedo decir.

%da un mejor rendimiento que el formatde mi prueba.

Código de prueba:

Python 2.7.2:

import timeit
print 'format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')")
print '%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')")

Resultado:

> format: 0.470329046249
> %: 0.357107877731

Python 3.5.2

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))

Resultado

> format: 0.5864730989560485
> %: 0.013593495357781649

Se ve en Python2, la diferencia es pequeña, mientras que en Python3, %es mucho más rápido que format.

Gracias @Chris Cogdon por el código de muestra.

Editar 1:

Probado nuevamente en Python 3.7.2 en julio de 2019.

Resultado:

> format: 0.86600608
> %: 0.630180146

No hay mucha diferencia Supongo que Python está mejorando gradualmente.

Edición 2:

Después de que alguien mencionó la cadena f de python 3 en el comentario, hice una prueba para el siguiente código en python 3.7.2:

import timeit
print('format:', timeit.timeit("'{}{}{}'.format(1, 1.23, 'hello')"))
print('%:', timeit.timeit("'%s%s%s' % (1, 1.23, 'hello')"))
print('f-string:', timeit.timeit("f'{1}{1.23}{\"hello\"}'"))

Resultado:

format: 0.8331376779999999
%: 0.6314778750000001
f-string: 0.766649943

Parece que f-string es aún más lento %pero mejor que format.

Como descubrí hoy, la antigua forma de formatear cadenas a través de %no es compatible Decimal, el módulo de Python para punto fijo decimal y aritmética de punto flotante, fuera de la caja.

Ejemplo (usando Python 3.3.5):

#!/usr/bin/env python3

from decimal import *

getcontext().prec = 50
d = Decimal('3.12375239e-24') # no magic number, I rather produced it by banging my head on my keyboard

print('%.50f' % d)
print('{0:.50f}'.format(d))

Salida:

0.00000000000000000000000312375239000000009907464850 0.00000000000000000000000312375239000000000000000000

Seguramente puede haber soluciones, pero aún puede considerar usar el format()método de inmediato.

Si su python> = 3.6, el literal con formato de F-string es su nuevo amigo.

Es más simple, limpio y mejor rendimiento.

In [1]: params=['Hello', 'adam', 42]

In [2]: %timeit "%s %s, the answer to everything is %d."%(params[0],params[1],params[2])
448 ns ± 1.48 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %timeit "{} {}, the answer to everything is {}.".format(*params)
449 ns ± 1.42 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit f"{params[0]} {params[1]}, the answer to everything is {params[2]}."
12.7 ns ± 0.0129 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

Como nota al margen, no tiene que tomar un golpe de rendimiento para usar el nuevo formato de estilo con el registro. Puede pasar cualquier objeto a logging.debug, logging.info, etc., que implementa el __str__método mágico. Cuando el módulo de registro ha decidido que debe emitir su objeto de mensaje (sea lo que sea), llama str(message_object)antes de hacerlo. Entonces podrías hacer algo como esto:

import logging


class NewStyleLogMessage(object):
    def __init__(self, message, *args, **kwargs):
        self.message = message
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        args = (i() if callable(i) else i for i in self.args)
        kwargs = dict((k, v() if callable(v) else v) for k, v in self.kwargs.items())

        return self.message.format(*args, **kwargs)

N = NewStyleLogMessage

# Neither one of these messages are formatted (or calculated) until they're
# needed

# Emits "Lazily formatted log entry: 123 foo" in log
logging.debug(N('Lazily formatted log entry: {0} {keyword}', 123, keyword='foo'))


def expensive_func():
    # Do something that takes a long time...
    return 'foo'

# Emits "Expensive log entry: foo" in log
logging.debug(N('Expensive log entry: {keyword}', keyword=expensive_func))

Todo esto se describe en la documentación de Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ). Sin embargo, también funcionará con Python 2.6 ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

Una de las ventajas de usar esta técnica, además del hecho de que es independiente del estilo de formato, es que permite valores vagos, por ejemplo, la función expensive_funcanterior. Esto proporciona una alternativa más elegante a los consejos que se dan en los documentos de Python aquí: https://docs.python.org/2.6/library/logging.html#optimization .

Una situación en la que %puede ayudar es cuando está formateando expresiones regex. Por ejemplo,

'{type_names} [a-z]{2}'.format(type_names='triangle|square')

plantea IndexError. En esta situación, puede usar:

'%(type_names)s [a-z]{2}' % {'type_names': 'triangle|square'}

Esto evita escribir la expresión regular como '{type_names} [a-z]{{2}}'. Esto puede ser útil cuando tiene dos expresiones regulares, donde una se usa sola sin formato, pero la concatenación de ambas está formateada.

Agregaría que desde la versión 3.6, podemos usar cadenas f como la siguiente

foo = "john"
bar = "smith"
print(f"My name is {foo} {bar}")

Que dan

Mi nombre es john smith

Todo se convierte en cuerdas.

mylist = ["foo", "bar"]
print(f"mylist = {mylist}")

Resultado:

mylist = ['foo', 'bar']

puede pasar la función, como en el método de otros formatos

print(f'Hello, here is the date : {time.strftime("%d/%m/%Y")}')

Dando por ejemplo

Hola, aquí está la fecha: 16/04/2018

Para la versión de Python> = 3.6 (ver PEP 498 )

s1='albha'
s2='beta'

f'{s1}{s2:>10}'

#output
'albha      beta'

Python 3.6.7 comparativo:

#!/usr/bin/env python
import timeit

def time_it(fn):
    """
    Measure time of execution of a function
    """
    def wrapper(*args, **kwargs):
        t0 = timeit.default_timer()
        fn(*args, **kwargs)
        t1 = timeit.default_timer()
        print("{0:.10f} seconds".format(t1 - t0))
    return wrapper


@time_it
def new_new_format(s):
    print("new_new_format:", f"{s[0]} {s[1]} {s[2]} {s[3]} {s[4]}")


@time_it
def new_format(s):
    print("new_format:", "{0} {1} {2} {3} {4}".format(*s))


@time_it
def old_format(s):
    print("old_format:", "%s %s %s %s %s" % s)


def main():
    samples = (("uno", "dos", "tres", "cuatro", "cinco"), (1,2,3,4,5), (1.1, 2.1, 3.1, 4.1, 5.1), ("uno", 2, 3.14, "cuatro", 5.5),) 
    for s in samples:
        new_new_format(s)
        new_format(s)
        old_format(s)
        print("-----")


if __name__ == '__main__':
    main()

Salida:

new_new_format: uno dos tres cuatro cinco
0.0000170280 seconds
new_format: uno dos tres cuatro cinco
0.0000046750 seconds
old_format: uno dos tres cuatro cinco
0.0000034820 seconds
-----
new_new_format: 1 2 3 4 5
0.0000043980 seconds
new_format: 1 2 3 4 5
0.0000062590 seconds
old_format: 1 2 3 4 5
0.0000041730 seconds
-----
new_new_format: 1.1 2.1 3.1 4.1 5.1
0.0000092650 seconds
new_format: 1.1 2.1 3.1 4.1 5.1
0.0000055340 seconds
old_format: 1.1 2.1 3.1 4.1 5.1
0.0000052130 seconds
-----
new_new_format: uno 2 3.14 cuatro 5.5
0.0000053380 seconds
new_format: uno 2 3.14 cuatro 5.5
0.0000047570 seconds
old_format: uno 2 3.14 cuatro 5.5
0.0000045320 seconds
-----

Pero una cosa es que también si ha anidado llaves, no funcionará para el formato, pero %funcionará.

Ejemplo:

>>> '{{0}, {1}}'.format(1,2)
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    '{{0}, {1}}'.format(1,2)
ValueError: Single '}' encountered in format string
>>> '{%s, %s}'%(1,2)
'{1, 2}'
>>>