Come posso stampare letteralmente caratteri di parentesi graffe in una stringa di pitone e usare anche .format su di essa?

x = " \{ Hello \} {0} "
print(x.format(42))

mi da : Key Error: Hello\\

Voglio stampare l'output: {Hello} 42

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

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 jsonlibreria è sicuramente preferibile quando la stringa JSON diventa più complicata dell'esempio.

Prova a fare questo:

x = " {{ Hello }} {0} "
print x.format(42)

Prova questo:

x = "{{ Hello }} {0}"

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 %sper 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}')