x = " \{ Hello \} {0} "
print(x.format(42))
me dá: Key Error: Hello\\
Quero imprimir a saída: {Hello} 42
{{ }}
), use string.Template
. Lá você substitui os identificadores do formulário $foo
(útil para gerar o código LaTeX).
x = " \{ Hello \} {0} "
print(x.format(42))
me dá: Key Error: Hello\\
Quero imprimir a saída: {Hello} 42
{{ }}
), use string.Template
. Lá você substitui os identificadores do formulário $foo
(útil para gerar o código LaTeX).
Respostas:
Você precisa dobrar o {{
e }}
:
>>> x = " {{ Hello }} {0} "
>>> print(x.format(42))
' { Hello } 42 '
Aqui está a parte relevante da documentação do Python para a sintaxe da string de formato :
As seqüências de formato contêm "campos de substituição" cercados por chaves
{}
. Tudo o que não está contido entre chaves é considerado texto literal, que é copiado inalterado para a saída. Se você precisar incluir um caractere de colchete no texto literal, ele poderá ser escapado dobrando:{{
e}}
.
"{{{0}}}".format(42)
!
"{ something { } {value}".format(42)
não funciona
{0}
significa isso?
{0}
refere-se ao primeiro argumento para .format()
. Você pode imprimir mais de um valor {0} {1} {2}
, desde que dê o mesmo número de argumentos .format()
. Veja docs.python.org/library/string.html#format-examples para exemplos extensos.
Você foge dobrando o aparelho.
Por exemplo:
x = "{{ Hello }} {0}"
print(x.format(42))
Python 3.6+ (2017)
Nas versões recentes do Python, usaria -se strings-f (veja também PEP498 ).
Com as cordas f, deve-se usar o dobro {{
ou}}
n = 42
print(f" {{Hello}} {n} ")
produz o desejado
{Hello} 42
Se você precisar resolver uma expressão entre colchetes, em vez de usar texto literal, precisará de três conjuntos de colchetes:
hello = "HELLO"
print(f"{{{hello.lower()}}}")
produz
{hello}
O OP escreveu este comentário:
Eu estava tentando formatar um pequeno JSON para alguns propósitos, como este:
'{"all": false, "selected": "{}"}'.format(data)
para obter algo como{"all": false, "selected": "1,2"}
É bastante comum que o problema de "escapamento de aparelho" surja ao lidar com o JSON.
Eu sugiro fazer isso:
import json
data = "1,2"
mydict = {"all": "false", "selected": data}
json.dumps(mydict)
É mais limpo que a alternativa, que é:
'{{"all": false, "selected": "{}"}}'.format(data)
O uso da json
biblioteca é definitivamente preferível quando a string JSON fica mais complicada que o exemplo.
Embora não seja melhor, apenas para referência, você também pode fazer isso:
>>> x = '{}Hello{} {}'
>>> print x.format('{','}',42)
{Hello} 42
Pode ser útil, por exemplo, quando alguém deseja imprimir {argument}
. Talvez seja mais legível do que'{{{}}}'.format('argument')
Observe que você omite as posições dos argumentos (por exemplo, em {}
vez de {0}
) após o Python 2.7
Se você fará muito isso, talvez seja bom definir uma função de utilitário que permita o uso de substitutos de chaves arbitrários, como
def custom_format(string, brackets, *args, **kwargs):
if len(brackets) != 2:
raise ValueError('Expected two brackets. Got {}.'.format(len(brackets)))
padded = string.replace('{', '{{').replace('}', '}}')
substituted = padded.replace(brackets[0], '{').replace(brackets[1], '}')
formatted = substituted.format(*args, **kwargs)
return formatted
>>> custom_format('{{[cmd]} process 1}', brackets='[]', cmd='firefox.exe')
'{{firefox.exe} process 1}'
Observe que isso funcionará com parênteses sendo uma sequência de comprimento 2 ou iterável de duas seqüências (para delimitadores de vários caracteres).
Recentemente, me deparei com isso, porque queria inserir seqüências de caracteres no JSON pré-formatado. Minha solução foi criar um método auxiliar, assim:
def preformat(msg):
""" allow {{key}} to be used for formatting in text
that already uses curly braces. First switch this into
something else, replace curlies with double curlies, and then
switch back to regular braces
"""
msg = msg.replace('{{', '<<<').replace('}}', '>>>')
msg = msg.replace('{', '{{').replace('}', '}}')
msg = msg.replace('<<<', '{').replace('>>>', '}')
return msg
Você pode fazer algo como:
formatted = preformat("""
{
"foo": "{{bar}}"
}""").format(bar="gas")
Realiza o trabalho se o desempenho não for um problema.
A razão é que, {}
a sintaxe de .format()
que, no seu caso .format()
, não reconhece {Hello}
, gerou um erro.
você pode substituí-lo usando chaves duplas {{}},
x = " {{ Hello }} {0} "
ou
tente %s
formatar o texto,
x = " { Hello } %s"
print x%(42)
Eu me deparei com esse problema ao tentar imprimir texto, que eu posso copiar e colar em um documento de látex. Eu estendo esta resposta e utilizo os campos de substituição nomeados:
Digamos que você queira imprimir um produto de várias variáveis com índices como
, o que no Latex seria $A_{ 0042 }*A_{ 3141 }*A_{ 2718 }*A_{ 0042 }$
O código a seguir faz o trabalho com campos nomeados para que, para muitos índices, fique legível:
idx_mapping = {'i1':42, 'i2':3141, 'i3':2178 }
print('$A_{{ {i1:04d} }} * A_{{ {i2:04d} }} * A_{{ {i3:04d} }} * A_{{ {i1:04d} }}$'.format(**idx_mapping))
Se você quiser imprimir apenas uma chave (por exemplo {
) {{
, use , e poderá adicionar mais chaves posteriormente na sequência, se desejar. Por exemplo:
>>> f'{{ there is a curly brace on the left. Oh, and 1 + 1 is {1 + 1}'
'{ there is a curly brace on the left. Oh, and 1 + 1 is 2'
Quando você está apenas tentando interpolar cadeias de código, sugiro usar o jinja2, que é um mecanismo de modelo completo para Python, ou seja:
from jinja2 import Template
foo = Template('''
#include <stdio.h>
void main() {
printf("hello universe number {{number}}");
}
''')
for i in range(2):
print(foo.render(number=i))
Portanto, você não será obrigado a duplicar chaves, como sugerem várias outras respostas
Você pode fazer isso usando o método de string bruto, simplesmente adicionando o caracter 'r' sem aspas antes da string.
# to print '{I am inside braces}'
print(r'{I am inside braces}')
\{I am inside braces\}
.