Jak mogę wydrukować dosłowne znaki nawiasu klamrowego w łańcuchu python, a także użyć na nim formatu .format?

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

daje mi : Key Error: Hello\\

Chcę wydrukować wynik: {Hello} 42

Musisz podwoić {{i }}:

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

Oto odpowiednia część dokumentacji Pythona dotycząca składni ciągu formatu :

Ciągi formatujące zawierają „pola zastępcze” otoczone nawiasami klamrowymi {}. Wszystko, co nie jest zawarte w nawiasach klamrowych, jest uważane za dosłowny tekst, który jest kopiowany bez zmian do wyniku. Jeśli musisz wstawić znak nawiasu klamrowego w dosłownym tekście, można go uniknąć, podwajając: {{i }}.

Uciekasz mu, podwajając nawiasy klamrowe.

Na przykład:

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

Python 3.6+ (2017)

W najnowszych wersjach Pythona używa się f-stringów (patrz także PEP498 ).

W przypadku strun f należy stosować podwójne {{lub}}

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

produkuje pożądane

 {Hello} 42

Jeśli chcesz rozwiązać wyrażenie w nawiasach zamiast literalnego tekstu, potrzebujesz trzech zestawów nawiasów:

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

produkuje

{hello}

OP napisał ten komentarz:

Próbowałem sformatować mały JSON do niektórych celów, takich jak ten: '{"all": false, "selected": "{}"}'.format(data)aby uzyskać coś takiego{"all": false, "selected": "1,2"}

Podczas pracy z JSON często pojawia się problem „uciekających nawiasów klamrowych”.

Sugeruję zrobienie tego:

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

Jest czystszy niż alternatywa, czyli:

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

Korzystanie z jsonbiblioteki jest zdecydowanie lepsze, gdy łańcuch JSON staje się bardziej skomplikowany niż w przykładzie.

Spróbuj to zrobić:

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

Spróbuj tego:

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

Chociaż nie ma nic lepszego, tylko dla odniesienia, możesz również to zrobić:

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

Może być przydatny na przykład, gdy ktoś chce drukować {argument} . Być może jest bardziej czytelny niż'{{{}}}'.format('argument')

Zauważ, że pomijasz pozycje argumentów (np. {}Zamiast {0}) po Pythonie 2.7

Jeśli zamierzasz to często robić, dobrze jest zdefiniować funkcję narzędzia, która pozwoli ci zamiast tego używać dowolnych zamienników nawiasów klamrowych, takich jak

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

Zauważ, że zadziała to z nawiasami będącymi łańcuchem o długości 2 lub iterowalnym z dwóch łańcuchów (w przypadku ograniczników wieloznakowych).

Ostatnio na to wpadłem, ponieważ chciałem wstrzyknąć ciągi znaków do wstępnie sformatowanego JSON. Moim rozwiązaniem było stworzenie metody pomocniczej, takiej jak ta:

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

Następnie możesz zrobić coś takiego:

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

Wykonuje zadanie, jeśli wydajność nie stanowi problemu.

Jeśli potrzebujesz dwóch nawiasów klamrowych w ciągu, potrzebujesz 5 nawiasów klamrowych po każdej stronie zmiennej.

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

Powodem jest to, {}że składnia .format()tak, że w twoim przypadku .format()nie rozpoznaje, {Hello}więc zgłosił błąd.

możesz to zmienić, używając podwójnych nawiasów klamrowych {{}},

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

lub

spróbuj %ssformatować tekst,

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

Natknąłem się na ten problem, próbując wydrukować tekst, który mogę skopiować wklej do dokumentu lateksowego. Opieram się na tej odpowiedzi i korzystam z nazwanych pól zastępczych:

Powiedzmy, że chcesz wydrukować produkt wielu zmiennych z indeksami takimi jak , którym w Lateksie byłoby: $A_{ 0042 }*A_{ 3141 }*A_{ 2718 }*A_{ 0042 }$ Poniższy kod wykonuje zadanie z nazwanymi polami, aby dla wielu indeksów był czytelny:

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

Jeśli chcesz wydrukować tylko jeden nawias klamrowy (na przykład {), możesz użyć {{i możesz dodać więcej nawiasów klamrowych później w ciągu, jeśli chcesz. Na przykład:

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

Gdy próbujesz interpolować ciągi kodu, sugeruję użycie jinja2, który jest w pełni funkcjonalnym silnikiem szablonów dla Pythona, tj .:

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

Więc nie będziesz zmuszony do powielania nawiasów klamrowych, jak sugeruje cała masa innych odpowiedzi

Możesz to zrobić, używając metody nieprzetworzonego ciągu, po prostu dodając znak „r” bez cudzysłowów przed ciągiem.

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