Formatação de string:% vs. formato


1349

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)


2
Para iniciantes: Aqui está um tutorial muito bom que ensina os dois estilos. Pessoalmente, uso o %estilo antigo com mais frequência, porque se você não precisar dos recursos aprimorados do format()estilo, o %estilo geralmente será muito mais conveniente.
Lutz Prechelt



1
Para responder à sua segunda pergunta, uma vez que 3.2 você pode usar {} formato se você usar um formatador personalizado (veja docs.python.org/3/library/logging.html#logging.Formatter )
yanjost

Respostas:


953

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


113
o que dizer"%(a)s, %(a)s" % {'a':'test'}
ted

128
Observe que você perderá tempo, log.debug("something: %s" % x)mas não para. log.debug("something: %s", x) A formatação da string será tratada no método e você não obterá o desempenho atingido se não for registrado. Como sempre, Python antecipa suas necessidades =)
darkfeline

63
ted: é um truque de aparência pior para fazer o mesmo que '{0}, {0}'.format('test').
ovelha voadora

19
O ponto é: O argumento recorrente de que a nova sintaxe permite a reordenação de itens é um ponto discutível: você pode fazer o mesmo com a sintaxe antiga. A maioria das pessoas não sabe que isso já está definido no Ansi C99 Std! Confira uma cópia recente de man sprintfe aprender sobre a $notação dentro %espaços reservados
TPI

29
@cfi: Se você quer dizer algo como, printf("%2$d", 1, 3)para imprimir "3", isso é especificado no POSIX, não no C99. A própria página do manual que você referenciou observa: "O padrão C99 não inclui o estilo usando '$' ...".
Thanatos

307

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

17
Você pode usar a formatação de estilo antigo maptão facilmente quanto o formato. map('some_format_string_%s'.__mod__, some_iterable)
agf

3
@cfi: por favor, prove que você está certo, reescrevendo o exemplo acima em C99
MarcH

9
@ MarcH: printf("%2$s %1$s\n", "One", "Two");compilado com gcc -std=c99 test.c -o test, a saída é Two One. Mas permaneço corrigido: na verdade, é uma extensão POSIX e não C. Não consigo encontrá-la novamente no padrão C / C ++, onde pensei ter visto. O código funciona mesmo com o sinalizador 'c90' std. sprintfpágina de manual . Isso não lista, mas permite que as bibliotecas implementem um superconjunto. Meu argumento original ainda é válido, substituindo CporPosix
cfi

8
Meu primeiro comentário aqui, não se aplica a esta resposta. Lamento o fraseado. No Python, não podemos usar o operador modulo %para reordenar espaços reservados. Eu ainda gostaria de não excluir esse primeiro comentário por uma questão de consistência aqui. Peço desculpas por ter desabafado minha raiva aqui. É direcionado contra a afirmação frequentemente feita de que a sintaxe antiga por si só não permitiria isso. Em vez de criar uma sintaxe completamente nova, poderíamos ter introduzido as extensões stix Posix. Nós poderíamos ter os dois.
Cfi

17
'módulo' refere-se ao operador que avalia um restante após uma divisão. nesse caso, o sinal de porcentagem não é um operador de módulo.
Octopus

148

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.


10
Esta é uma informação útil que acabei de aprender agora. É uma pena que não tenha sua própria pergunta, pois parece separado da questão principal. Pena que o OP não tenha dividido sua pergunta em duas perguntas separadas.
snth

12
Você pode usar a formatação dict como esta: log.debug("some debug info: %(this)s and %(that)s", dict(this='Tom', that='Jerry')) No entanto, você não pode usar a nova .format()sintaxe de estilo aqui, nem mesmo no Python 3.3, o que é uma pena.
Cito


26
O principal benefício disso não é o desempenho (a interpolação de string será rápida em comparação com o que você estiver fazendo com a saída do log, por exemplo, exibindo em um terminal, salvando em disco). É que, se você possui um agregador de log, posso dizer "você recebeu 12 instâncias dessa mensagem de erro", mesmo que todas tenham valores diferentes 'some_info'. Se a formatação da string for feita antes de passar a string para log.debug, isso será impossível. O agregador pode apenas dizer "você teve 12 mensagens de log diferentes"
Jonathan Hartley

7
Se você está preocupado com o desempenho, use dict literal {} sintaxe em vez de uma instanciação de classe dict (): doughellmann.com/2012/11/...
trojjer

119

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


1
Isso não responde à pergunta. Outra resposta que menciona f-cordas, pelo menos, fala sobre o desempenho: stackoverflow.com/a/51167833/7851470
Georgy

60

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.


14
Falso: "A compatibilidade com versões anteriores pode ser mantida deixando os mecanismos existentes no lugar."; é claro, .formatnão substituirá a % formatação da string.
Tobias

12
Não, a postulação do BrainStorms é verdadeira: "pretendida como uma substituição do '%' existente". A citação de Tobias significa que ambos os sistemas coexistirão por algum tempo. RTFPEP
phobie 19/08/2015

54

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


12
Não há simplesmente nenhuma razão para mudar o código de trabalho a menos que os recursos adicionais do novo formatmétodo são realmente necessário ...
Tobias

concordo absolutamente com você, Tobias, mas às vezes é necessário quando a atualização para versões mais recentes do Python
wobmene

2
Por exemplo? AFAIK, nunca foi necessário; Não considero provável que a %interpolação de cordas vá embora.
Tobias

4
Considero a função .format () mais segura que% para strings. Muitas vezes vejo erros de iniciantes como este "p1=%s p2=%d" % "abc", 2ou "p1=%s p2=%s" % (tuple_p1_p2,). Você pode pensar que é culpa do codificador, mas eu acho que é apenas uma sintaxe estranha que parece boa para o script rápido, mas é ruim para o código de produção.
Wobmene

3
Mas eu não gosto da sintaxe de .format (), eu estaria mais feliz com o bom e velho %s, %02dcomo "p1=%s p2=%02d".format("abc", 2). Eu culpo aqueles que inventaram e aprovaram a formatação do aparelho que precisa de você para escapar deles {{}}e que parece feio.
Wobmene

35

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.


4
Isso parece mais ilegível do que o necessário em comparação com o equivalente 'x is {0}, y is {1}'.format(a.x, a.y). Só deve ser usado quando a a.xoperação é muito cara.
dtheodor 29/03/2015

13
@dtheodor Com um ajuste de usar um argumento de palavra-chave em vez de argumento posicional ... 'x is {a.x}, y is {a.y}'.format(a=a). Mais legível que os dois exemplos.
precisa saber é o seguinte

1
@CivFan Ou, se você tem mais de um objeto,'x is {a.x}, y is {a.y}'.format(**vars())
Jack

1
Observe também este da mesma forma: '{foo[bar]}'.format(foo={'bar': 'baz'}).
Antoine Pinsard

3
Isso é incrivelmente útil para aplicativos voltados para o cliente, nos quais o aplicativo fornece um conjunto padrão de opções de formatação com uma sequência de formatos fornecida pelo usuário. Eu uso isso o tempo todo. O arquivo de configuração, por exemplo, terá alguma propriedade "messagestring", que o usuário pode fornecer Your order, number {order[number]} was processed at {now:%Y-%m-%d %H:%M:%S}, will be ready at about {order[eta]:%H:%M:%S}ou o que quiser. Isso é muito mais limpo do que tentar oferecer a mesma funcionalidade com o formatador antigo. Torna as strings de formato fornecidas pelo usuário muito mais poderosas.
Taywee

35

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


42
Em vez disso, str.formatfornece mais funcionalidades (especialmente formatação especializada em tipos, por exemplo '{0:%Y-%m-%d}'.format(datetime.datetime.utcnow())). O desempenho não pode ser o requisito absoluto de todos os trabalhos. Use a ferramenta certa para o trabalho.
Minhee

36
"Otimização prematura é a raiz de todo mal" ou assim Donald Knuth disse uma vez ...
Yatharth Agarwal

22
Seguir um esquema de formatação conhecido (desde que atenda às necessidades, o que ocorre na grande maioria dos casos) e que seja duas vezes mais rápido, não é uma "otimização prematura", mas simplesmente razoável. BTW, o %operador permite reutilizar o printfconhecimento; interpolação de dicionário é uma extensão muito simples do princípio.
Tobias

5
Na verdade, experimentei o oposto em uma situação. A formatação de novo estilo foi mais rápida. Você pode fornecer o código de teste que você usou?
David Sanders

8
Parece um post seriamente desperdiçado, sem exemplos ou raciocínio, apenas reivindicações.
Kevr 29/05

31

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.


1
Provavelmente, porque a formatação com novo estilo chama str(d)antes de expandir o parâmetro, enquanto a formatação com estilo antigo provavelmente chama float(d)primeiro.
David Sanders

3
Você pensaria assim, mas str(d)retorna "3.12375239e-24", não"0.00000000000000000000000312375239000000000000000000"
Jack

18

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)

15

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 .


2
Eu gostaria de poder votar mais isso. Ele permite fazer logon formatsem o desempenho atingido - substitui com __str__precisão o que loggingfoi projetado - reduz a chamada de função para uma única letra ( N) que se parece muito com algumas das maneiras padrão de definir strings - E permite preguiçosos chamada de função. Obrigado! 1
CivFan

2
O resultado é diferente do uso do logging.Formatter(style='{')parâmetro?
DavidA

10

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.


3
Ou apenas use '{type_names} [a-z]{{2}}'.format(type_names='triangle|square'). É como dizer que .format()pode ajudar ao usar strings que já contêm um caractere de porcentagem. Certo. Você tem que escapar deles então.
Alfe 02/03

1
@ Alfe Você está certo, e é por isso que a resposta começa com "One situation where % may help is when you are formatting regex expressions."Especificamente, suponha que a=r"[a-z]{2}"seja um pedaço de regex que você será usado em duas expressões finais diferentes (por exemplo, c1 = b + ae c2 = a). Suponha que c1precise ser formateditado (por exemplo, bprecisa ser formatado em tempo de execução), mas c2não precisa. Então você precisa a=r"[a-z]{2}"para c2e a=r"[a-z]{{2}}"para c1.format(...).
Jorge Leitao

7

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


4

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

s1='albha'
s2='beta'

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

#output
'albha      beta'

2

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

3
Você deve executar cada exemplo várias vezes, uma única execução pode ser enganosa, por exemplo, o sistema operacional pode estar geralmente ocupado, portanto a execução do seu código é adiada. consulte os documentos: docs.python.org/3/library/timeit.html . (agradável avatar, Guybrush!)
jake77

1

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

2
você poderia fazer isso, mas concordo que é awefull '{{{0}, {1}}}' format (1, 2).
Sylvan LE DEUNFF

A palavra-chave aninhada curly-braces funciona e é bonita.
CivFan 6/01
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.