¿Cómo puedo imprimir caracteres literales entre llaves en una cadena de Python y también usar .format en él?

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

me da Key Error: Hello\\

Quiero imprimir la salida: {Hello} 42

Necesita duplicar {{y }}:

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

Aquí está la parte relevante de la documentación de Python para la sintaxis de cadenas de formato :

Las cadenas de formato contienen "campos de reemplazo" rodeados de llaves {}. Cualquier cosa que no esté contenida entre llaves se considera texto literal, que se copia sin cambios a la salida. Si necesita incluir un carácter de llave en el texto literal, se puede escapar doblando: {{y }}.

Te escapas doblando los frenos.

P.ej:

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

Python 3.6+ (2017)

En las versiones recientes de Python se usarían cadenas f (ver también PEP498 ).

Con las cadenas f se debe usar doble {{o}}

n = 42  
print(f" {{Hello}} {n} ")

produce el deseado

 {Hello} 42

Si necesita resolver una expresión entre paréntesis en lugar de usar texto literal, necesitará tres conjuntos de paréntesis:

hello = "HELLO"
print(f"{{{hello.lower()}}}")

produce

{hello}

El OP escribió este comentario:

Intenté formatear un pequeño JSON para algunos propósitos, como este: '{"all": false, "selected": "{}"}'.format(data)para obtener algo como{"all": false, "selected": "1,2"}

Es bastante común que surja el problema de "frenos de escape" cuando se trata de JSON.

Sugiero hacer esto:

import json
data = "1,2"
mydict = {"all": "false", "selected": data}
json.dumps(mydict)

Es más limpio que la alternativa, que es:

'{{"all": false, "selected": "{}"}}'.format(data)

Usar la jsonbiblioteca es definitivamente preferible cuando la cadena JSON se vuelve más complicada que el ejemplo.

Intenta hacer esto:

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

Prueba esto:

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

Aunque no es mejor, solo como referencia, también puede hacer esto:

>>> x = '{}Hello{} {}'
>>> print x.format('{','}',42)
{Hello} 42

Puede ser útil, por ejemplo, cuando alguien quiere imprimir {argument}. Es quizás más legible que'{{{}}}'.format('argument')

Tenga en cuenta que omite las posiciones de argumento (por ejemplo, en {}lugar de {0}) después de Python 2.7

Si va a hacer esto mucho, podría ser bueno definir una función de utilidad que le permita utilizar sustitutos de llaves arbitrarios, 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}'

Tenga en cuenta que esto funcionará ya sea con corchetes que son una cadena de longitud 2 o un iterable de dos cadenas (para delimitadores de varios caracteres).

Recientemente me encontré con esto, porque quería inyectar cadenas en JSON preformateado. Mi solución fue crear un método auxiliar, como este:

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

Luego puedes hacer algo como:

formatted = preformat("""
    {
        "foo": "{{bar}}"
    }""").format(bar="gas")

Hace el trabajo si el rendimiento no es un problema.

Si necesita mantener dos llaves en la cuerda, necesita 5 llaves en cada lado de la variable.

>>> myvar = 'test'
>>> "{{{{{0}}}}}".format(myvar)
'{{test}}'

La razón es que {}es la sintaxis de .format()lo que en su caso .format()no reconoce, {Hello}por lo que arrojó un error.

puedes anularlo usando llaves dobles {{}},

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

o

intente %sformatear el texto,

x = " { Hello } %s"
print x%(42)  

Me topé con este problema al intentar imprimir texto, que puedo copiar y pegar en un documento de Latex. Extiendo esta respuesta y hago uso de los campos de reemplazo con nombre:

Digamos que desea imprimir un producto de múltiples variables con índices como , que en Latex sería $A_{ 0042 }*A_{ 3141 }*A_{ 2718 }*A_{ 0042 }$ El siguiente código hace el trabajo con campos con nombre para que para muchos índices permanezca legible:

idx_mapping = {'i1':42, 'i2':3141, 'i3':2178 }
print('$A_{{ {i1:04d} }} * A_{{ {i2:04d} }} * A_{{ {i3:04d} }} * A_{{ {i1:04d} }}$'.format(**idx_mapping))

Si desea imprimir solo una llave (por ejemplo {), puede usarla {{, y puede agregar más llaves más adelante en la cadena si lo desea. Por ejemplo:

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

Cuando solo intentas interpolar cadenas de código, te sugiero que uses jinja2, que es un motor de plantillas con todas las funciones para Python, es decir:

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

Por lo tanto, no se le exigirá que duplique las llaves como lo sugieren todas las otras respuestas

Puede hacer esto utilizando el método de cadena sin procesar simplemente agregando el carácter 'r' sin comillas antes de la cadena.

# to print '{I am inside braces}'
print(r'{I am inside braces}')