Formatação de string:% vs. formato

O Python 2.6 introduziu o str.format()método com uma sintaxe ligeiramente diferente do %operador existente . Qual é o melhor e para que situações?

1. A seguir, use cada método e tenha o mesmo resultado. Qual é a diferença?

   #!/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. Além disso, quando ocorre a formatação de string no Python? Por exemplo, se o meu nível de log estiver definido como HIGH, ainda receberei um resultado para executar a %operação a seguir ? E se sim, existe uma maneira de evitar isso?

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

Responder à sua primeira pergunta ... .formatparece mais sofisticado de várias maneiras. Uma coisa irritante %também é como ela pode pegar uma variável ou uma tupla. Você acha que o seguinte sempre funcionaria:

"hi there %s" % name

no entanto, se nameacontecer (1, 2, 3), lançará a TypeError. Para garantir que sempre seja impresso, você precisará fazer

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

o que é feio. .formatnão tem esses problemas. Também no segundo exemplo que você deu, o .formatexemplo é muito mais limpo.

Por que você não o usaria?

• sem saber sobre isso (eu antes de ler isso)
• tendo que ser compatível com Python 2.5

Para responder à sua segunda pergunta, a formatação da string ocorre ao mesmo tempo que qualquer outra operação - quando a expressão de formatação da string é avaliada. E Python, não sendo uma linguagem lenta, avalia expressões antes de chamar funções, portanto, no seu log.debugexemplo, a expressão "some debug info: %s"%some_infoserá avaliada primeiro como, por exemplo "some debug info: roflcopters are active", a sequência que será transmitida log.debug().

Algo que o operador do módulo (%) não pode fazer:

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

Muito útil.

Outro ponto: format()sendo uma função, pode ser usado como argumento em outras funções:

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

Resulta em:

['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

Supondo que você esteja usando o loggingmódulo Python , você pode passar os argumentos de formatação de string como argumentos para o .debug()método, em vez de fazer a formatação:

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

que evita a formatação, a menos que o criador de logs realmente registre algo.

A partir do Python 3.6 (2016), você pode usar as strings f para substituir variáveis:

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

Anote o f"prefixo. Se você tentar isso no Python 3.5 ou anterior, obterá um SyntaxError.

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

O PEP 3101 propõe a substituição do %operador pela nova e avançada formatação de string no Python 3, onde seria o padrão.

Mas tenha cuidado, só agora eu descobri um problema ao tentar substituir todos %com .formatno código existente: '{}'.format(unicode_string)vai tentar UNICODE_STRING codificar e provavelmente irá falhar.

Basta olhar para este log de sessão interativa do 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'

sé apenas uma string (chamada 'matriz de bytes' em Python3) e ué uma string Unicode (chamada de 'string' em Python3):

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

Quando você fornece um objeto Unicode como parâmetro ao %operador, ele produz uma cadeia Unicode, mesmo que a cadeia original não fosse 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)

mas a .formatfunção gerará "UnicodeEncodeError":

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

e só funcionará com um argumento Unicode se a cadeia original for Unicode.

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

ou se a sequência de argumentos puder ser convertida em uma sequência (chamada de 'matriz de bytes')

Ainda outra vantagem .format(que não vejo nas respostas): pode levar propriedades de objetos.

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'

Ou, como argumento da palavra-chave:

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

Isso não é possível %, tanto quanto eu posso dizer.

%dá um desempenho melhor do que formatno meu teste.

Código do teste:

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

Parece em Python2, a diferença é pequena, enquanto em Python3, %é muito mais rápido que format.

Obrigado @ Chris Cogdon pelo código de exemplo.

Editar 1:

Testado novamente no Python 3.7.2 em julho de 2019.

Resultado:

> format: 0.86600608
> %: 0.630180146

Não há muita diferença. Eu acho que o Python está melhorando gradualmente.

Edição 2:

Depois que alguém mencionou a string f do python 3 no comentário, fiz um teste para o seguinte código no 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 o fio-f ainda é mais lento que, %mas melhor que format.

Como descobri hoje, a maneira antiga de formatar strings via %não é compatível Decimal, o módulo do Python para aritmética de ponto fixo decimal e ponto flutuante, pronto para uso.

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

Resultado:

0.00000000000000000000000312375239000000009907464850 0.000000000000000000000000000312375239000000000000000000

Certamente pode haver soluções alternativas, mas você ainda pode considerar o uso do format()método imediatamente.

Se o seu python> = 3.6, o literal formatado em F-string é seu novo amigo.

É mais simples, limpo e com melhor desempenho.

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 uma observação lateral, você não precisa ter um impacto no desempenho para usar a nova formatação de estilo com o log. Você pode passar qualquer objeto a logging.debug, logging.infoetc., que implementa o __str__método mágico. Quando o módulo de registro decide que deve emitir seu objeto de mensagem (seja ele qual for), ele chama str(message_object)antes de fazê-lo. Então você poderia fazer algo assim:

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

Tudo isso está descrito na documentação do Python 3 ( https://docs.python.org/3/howto/logging-cookbook.html#formatting-styles ). No entanto, ele também funcionará com o Python 2.6 ( https://docs.python.org/2.6/library/logging.html#using-arbitrary-objects-as-messages ).

Uma das vantagens de usar essa técnica, além do fato de ser agnóstico no estilo de formatação, é que ela permite valores preguiçosos, por exemplo, a função expensive_funcacima. Isso fornece uma alternativa mais elegante aos conselhos dados nos documentos do Python aqui: https://docs.python.org/2.6/library/logging.html#optimization .

Uma situação em que %pode ajudar é quando você está formatando expressões regex. Por exemplo,

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

aumenta IndexError. Nesta situação, você pode usar:

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

Isso evita escrever a regex como '{type_names} [a-z]{{2}}'. Isso pode ser útil quando você possui duas expressões regulares, em que uma é usada sozinha sem formato, mas a concatenação de ambas é formatada.

Eu acrescentaria que desde a versão 3.6, podemos usar fstrings como o seguinte

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

Que dão

Meu nome é john smith

Tudo é convertido em strings

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

Resultado:

mylist = ['foo', 'bar']

você pode passar a função, como no método de outros formatos

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

Dando por exemplo

Olá, aqui é a data: 16/04/2018

Para a versão python> = 3.6 (consulte PEP 498 )

s1='albha'
s2='beta'

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

#output
'albha      beta'

Comparativo do Python 3.6.7:

#!/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()

Resultado:

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

Mas uma coisa é que também se você tiver chaves aninhadas, não funcionará para o formato, mas %funcionará.

Exemplo:

>>> '{{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}'
>>>