x = " \{ Hello \} {0} "
print(x.format(42))
mi da : Key Error: Hello\\
Voglio stampare l'output: {Hello} 42
{{ }}
), utilizzare string.Template
. Lì sostituisci gli identificatori del modulo $foo
(utile per generare codice LaTeX).
x = " \{ Hello \} {0} "
print(x.format(42))
mi da : Key Error: Hello\\
Voglio stampare l'output: {Hello} 42
{{ }}
), utilizzare string.Template
. Lì sostituisci gli identificatori del modulo $foo
(utile per generare codice LaTeX).
Risposte:
Devi raddoppiare {{
e e }}
:
>>> x = " {{ Hello }} {0} "
>>> print(x.format(42))
' { Hello } 42 '
Ecco la parte rilevante della documentazione di Python per la sintassi della stringa di formato :
Le stringhe di formato contengono "campi di sostituzione" circondati da parentesi graffe
{}
. Tutto ciò che non è contenuto tra parentesi graffe è considerato testo letterale, che viene copiato invariato nell'output. Se è necessario includere un carattere parentesi graffa nel testo letterale, può essere evitato raddoppiando:{{
e}}
.
"{{{0}}}".format(42)
!
"{ something { } {value}".format(42)
non funziona
{0}
significa?
{0}
riferisce al primo argomento di .format()
. È possibile stampare più di un valore {0} {1} {2}
, purché si fornisca lo stesso numero di argomenti .format()
. Vedi docs.python.org/library/string.html#format-examples per esempi esaurienti.
Fuggilo raddoppiando le parentesi graffe.
Per esempio:
x = "{{ Hello }} {0}"
print(x.format(42))
Python 3.6+ (2017)
Nelle recenti versioni di Python si userebbero le stringhe f (vedere anche PEP498 ).
Con le stringhe f si dovrebbe usare double {{
o}}
n = 42
print(f" {{Hello}} {n} ")
produce il desiderato
{Hello} 42
Se devi risolvere un'espressione tra parentesi invece di usare il testo letterale avrai bisogno di tre serie di parentesi:
hello = "HELLO"
print(f"{{{hello.lower()}}}")
produce
{hello}
L'OP ha scritto questo commento:
Stavo cercando di formattare un piccolo JSON per alcuni scopi, in questo modo:
'{"all": false, "selected": "{}"}'.format(data)
per ottenere qualcosa del genere{"all": false, "selected": "1,2"}
È abbastanza comune che il problema delle "parentesi graffe" si presenti quando si ha a che fare con JSON.
Suggerisco di fare questo:
import json
data = "1,2"
mydict = {"all": "false", "selected": data}
json.dumps(mydict)
È più pulito dell'alternativa, che è:
'{{"all": false, "selected": "{}"}}'.format(data)
L'uso della json
libreria è sicuramente preferibile quando la stringa JSON diventa più complicata dell'esempio.
Anche se non meglio, solo per riferimento, puoi anche fare questo:
>>> x = '{}Hello{} {}'
>>> print x.format('{','}',42)
{Hello} 42
Può essere utile ad esempio quando qualcuno vuole stampare {argument}
. È forse più leggibile di'{{{}}}'.format('argument')
Si noti che si omettono le posizioni degli argomenti (ad es. {}
Anziché {0}
) dopo Python 2.7
Se lo farai molto, potrebbe essere utile definire una funzione di utilità che ti consenta invece di utilizzare sostituti del tutore arbitrario, come
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}'
Si noti che funzionerà con parentesi che sono una stringa di lunghezza 2 o un iterabile di due stringhe (per i delimitatori a più caratteri).
Di recente mi sono imbattuto in questo, perché volevo iniettare stringhe in JSON preformattato. La mia soluzione era quella di creare un metodo di supporto, come questo:
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
Puoi quindi fare qualcosa del tipo:
formatted = preformat("""
{
"foo": "{{bar}}"
}""").format(bar="gas")
Ottiene il lavoro svolto se le prestazioni non sono un problema.
Se è necessario mantenere due parentesi graffe nella stringa, sono necessarie 5 parentesi graffe su ciascun lato della variabile.
>>> myvar = 'test'
>>> "{{{{{0}}}}}".format(myvar)
'{{test}}'
Il motivo è che {}
la sintassi di .format()
così nel tuo caso .format()
non riconosce {Hello}
quindi ha generato un errore.
puoi ignorarlo utilizzando le parentesi graffe doppie {{}},
x = " {{ Hello }} {0} "
o
prova %s
per la formattazione del testo,
x = " { Hello } %s"
print x%(42)
Mi sono imbattuto in questo problema quando ho provato a stampare il testo, che posso copiare e incollare in un documento in lattice. Estendo questa risposta e utilizzo i campi di sostituzione nominati:
Diciamo che vuoi stampare un prodotto di variabili multiple con indici come
, che in Latex sarebbe $A_{ 0042 }*A_{ 3141 }*A_{ 2718 }*A_{ 0042 }$
Il seguente codice fa il lavoro con i campi con nome in modo che per molti indici rimanga leggibile:
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 si desidera stampare solo una parentesi graffa (ad esempio {
), è possibile utilizzare {{
e, se lo si desidera, è possibile aggiungere più parentesi successivamente nella stringa. Per esempio:
>>> 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 stai solo cercando di interpolare le stringhe di codice, ti suggerisco di usare jinja2, che è un motore di template completo per Python, ovvero:
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))
Quindi non sarai costretto a duplicare le parentesi graffe come suggerisce tutto il gruppo di altre risposte
Puoi farlo usando il metodo della stringa grezza semplicemente aggiungendo il carattere 'r' senza virgolette prima della stringa.
# to print '{I am inside braces}'
print(r'{I am inside braces}')
\{I am inside braces\}
.