How do I escape curly-brace ({}) characters in a string while using .format (or an f-string)?

Asked 2023-09-20 20:30:30 View 526,016

Non-working example:

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

Desired output:

 {Hello} 42 
  • See also: stackoverflow.com/questions/35574349 - anyone
  • For those who want to avoid doubling braces ({{ }}), use string.Template. There you substitute identifiers of the form $foo (handy for generating LaTeX code). - anyone
  • For those who want to avoid doubling braces, and who are not averse to adding another dependency to their Python projects, there is also Jinja2 which definitively solves this problem, by allowing user-defined custom placeholder delimiter syntax. - anyone

Answers

You need to double the {{ and }}:

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

Here's the relevant part of the Python documentation for format string syntax:

Format strings contain “replacement fields” surrounded by curly braces {}. Anything that is not contained in braces is considered literal text, which is copied unchanged to the output. If you need to include a brace character in the literal text, it can be escaped by doubling: {{ and }}.

Answered   2023-09-20 20:30:30

  • So if you want to print "{42}", you'd use "{{{0}}}".format(42) ! - anyone
  • What about if you want a single curly brace? "{ something { } {value}".format(42) doesn't work. - anyone
  • "{{".format() and "}}".format() print single curly braces. In your example: print "{{ something {{ }} {0}".format(42) will print "{ something { } 42". - anyone
  • What does the {0} mean? - anyone
  • @Imray: {0} refers to the first argument to .format(). You can print more than one value like {0} {1} {2} as long as you give the same number of arguments to .format(). See docs.python.org/library/string.html#format-examples for extensive examples. - anyone

Python 3.6+ (2017)

In the recent versions of Python one would use f-strings (see also PEP498).

With f-strings one should use double {{ or }}

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

produces the desired

 {Hello} 42

If you need to resolve an expression in the brackets instead of using literal text you'll need three sets of brackets:

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

produces

{hello}

Answered   2023-09-20 20:30:30

  • From my_greet = "HELLO" you can get {hello} as output, using just 2 sets of brackets, with print(f"{ {my_greet.lower()} }"). Just leave a space between brackets. - anyone
  • This should now be the accepted answer if you are using Python3.6+ in the times of the rona. - anyone
  • @Gwi7d31 No, f-strings are not a replacement for str.format(). For example, this answer I wrote is not possible with f-strings since the template is coming from input, not source code. - anyone
  • @wjandrea your link really doesn't pertain to the OPs question. The OP wants to keep curly-braces while you are removing them in your linked answer via .format() and your dictionary unpacking method. If you want to preserve {} in Python 3.6+ and you want to insert a value into a string, this is the way. That's the question at hand. I also never said f-strings are a replacement for .format(). You said that. - anyone
  • @Gwi What I'm saying is, this question is about str.format(), not f-strings, and they're not mutually compatible. - anyone

You escape it by doubling the braces.

Eg:

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

Answered   2023-09-20 20:30:30

You want to format a string with the character { or }

You just have to double them.

format { with f'{{' and }with f'}}'

So :

name = "bob"
print(f'Hello {name} ! I want to print }} and {{ or {{ }}')

Output :

Hello bob ! I want to print } and { or { }

OR for the exact example :

number = 42
print(f'{{Hello}} {number}')

Will print :

{Hello} 42

Finally :

number = 42
string = "bob"
print(f'{{Hello}} {{{number}}} {number} {{{string}}} {string} ')

{Hello} {42} 42 {bob} bob

Answered   2023-09-20 20:30:30

The OP wrote this comment:

I was trying to format a small JSON for some purposes, like this: '{"all": false, "selected": "{}"}'.format(data) to get something like {"all": false, "selected": "1,2"}

It's pretty common that the "escaping braces" issue comes up when dealing with JSON.

I suggest doing this:

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

It's cleaner than the alternative, which is:

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

Using the json library is definitely preferable when the JSON string gets more complicated than the example.

Answered   2023-09-20 20:30:30

  • Amen! It might seem like more work, but using libraries to do what libraries are supposed to do versus cutting corners...makes for better things. - anyone
  • But the order of the keys in a Python object isn't guaranteed... Still, the JSON library is guaranteed to serialise in a JSON way. - anyone
  • wizzwizz4: Good point. From Python 3.6 onward, dictionaries are insertion ordered, so it wouldn't be an issue. Versions of Python between 2.7 and 3.5 can use OrderedDict from the collections library. - anyone
  • The alternative is also terribly wrong if, e.g., data = 'foo"', because the " in the value of data won't be properly escaped. - anyone
  • If you're dealing with JSON, this answer is for you. It wins in terms of readability and maintainability - imagine dealing with complex JSON structures and a lot of double braces in it - anyone

Try this:

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

Answered   2023-09-20 20:30:30

Try doing this:

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

Answered   2023-09-20 20:30:30

Although not any better, just for the reference, you can also do this:

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

It can be useful for example when someone wants to print {argument}. It is maybe more readable than '{{{}}}'.format('argument')

Note that you omit argument positions (e.g. {} instead of {0}) after Python 2.7

Answered   2023-09-20 20:30:30

key = "FOOBAR"
print(f"hello {{{key}}}")

outputs

hello {FOOBAR}

In case someone wanted to print something inside curly brackets using fstrings.

Answered   2023-09-20 20:30:30

f-strings (python 3)

You can avoid having to double the curly brackets by using f-strings ONLY for the parts of the string where you want the f-magic to apply, and using regular (dumb) strings for everything that is literal and might contain 'unsafe' special characters. Let python do the string joining for you simply by stacking multiple strings together.

number = 42
print(" { Hello }"  
f" {number} " 
"{ thanks for all the fish }")

### OUTPUT:
{ Hello } 42 { thanks for all the fish }

NOTE: Line breaks between the strings are NOT required. I have only added them for readability. You could as well write the code above as shown below:

⚠️ WARNING: This might hurt your eyes or make you dizzy!

print("{Hello}"f"{number}""{thanks for all the fish}")

Answered   2023-09-20 20:30:30

If you need to keep two curly braces in the string, you need 5 curly braces on each side of the variable.

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

Answered   2023-09-20 20:30:30

  • For those using f-strings, use 4 curly braces on either side instead of 5 - anyone
  • @TerryA there isn't a difference in brace behavior between .format and f-strings. The code a = 1; print('{{{{{a}}}}}'.format(a=a)) produces the same results as a = 1; print(f'{{{{{a}}}}}'). - anyone

If you are going to be doing this a lot, it might be good to define a utility function that will let you use arbitrary brace substitutes instead, like

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

Note that this will work either with brackets being a string of length 2 or an iterable of two strings (for multi-character delimiters).

Answered   2023-09-20 20:30:30

  • Thought about that also. Of course, that will work too and the algorithm is simpler. But, imagine you have a lot of text like this, and you just want to parameterize it here and there. Everytime you create an input string you wouldn't want to replace all those braces manually. You would just want to 'drop in' your parameterizations here and there. In this case, I think this method is both easier to think about and accomplish from a user perspective. I was inspired by linux's 'sed' command which has similar capabilities to arbitrarily choose your delimiter based on what is convenient. - anyone
  • In short, I'd rather have the utility function be a little more complex than have it be a pain in the @$$ to use everytime. Please let me know if I misunderstood your proposition. - anyone
  • I've gone ahead and added a short demo to my public.lab space github.com/dreftymac/public.lab/blob/master/topic/python/… - anyone

I recently ran into this, because I wanted to inject strings into preformatted JSON. My solution was to create a helper method, like this:

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

You can then do something like:

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

Gets the job done if performance is not an issue.

Answered   2023-09-20 20:30:30

  • Simple AND elegant to integrate into existing code with little modification required. Thanks! - anyone
  • of course, assuming your text never contained any <<< and >>> to begin with, otherwise those would get overwritten. best to use escape strategies for reliability! - anyone
  • What escape strategy do you suggest? Anyway, you know your templated text and can amend the magic strings in case you worry about clashes. - anyone
  • This approach is highly flexible and is even more workable by just borrowing a convention from Perl. Simply 1) choose a sequence of characters that you know will not appear in the target text (eg QQX); 2) use that sequence as your variable placeholders QQX<name>; 3) do a regex replacement to convert your placeholders to the expected format (eg) r'QQ<([^>]+)>','{$1}'. See also: perl quotelike operator - anyone

Reason is , {} is the syntax of .format() so in your case .format() doesn't recognize {Hello} so it threw an error.

you can override it by using double curly braces {{}},

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

or

try %s for text formatting,

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

Answered   2023-09-20 20:30:30

  • This is so simple. I always forget about percent-style formatting. It is still valid in all Python versions, and it makes my quick and dirty test with a JSON string that needs number formatting so much cleaner. - anyone

I am ridiculously late to this party. I am having success placing the brackets in the replacement element, like this:

print('{0} {1}'.format('{hello}', '{world}'))

which prints

{hello} {world}

Strictly speaking this is not what OP is asking, as s/he wants the braces in the format string, but this may help someone.

Answered   2023-09-20 20:30:31

  • Even print("{} {}".format("{hello}", "{world}")) works - anyone

I stumbled upon this problem when trying to print text, which I can copy paste into a Latex document. I extend on this answer and make use of named replacement fields:

Lets say you want to print out a product of mulitple variables with indices such as enter image description here, which in Latex would be $A_{ 0042 }*A_{ 3141 }*A_{ 2718 }*A_{ 0042 }$ The following code does the job with named fields so that for many indices it stays readable:

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

Answered   2023-09-20 20:30:31

You can use a "quote wall" to separate the formatted string part from the regular string part.

From:

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

to

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

A clearer example would be

string = 10
print(f"{string} {word}")

Output:

NameError: name 'word' is not defined

Now, add the quote wall like so:

string = 10
print(f"{string}"" {word}")

Output:

10 {word}

Answered   2023-09-20 20:30:31

  • This looks more like concatenation, but nice thinking - anyone
  • I would advise against this - it's using a feature of the language which is itself controversial and described by Guido as a mistake (implicit string concatenation) and using it in a way that is, itself, unusual and therefore confusing. Many people who hit this are going to struggle to work out what is going on. It's essentially just going f"{string}" + " {word}" which is simple and straightforward but doing so in a more confusing way. It reminds me of the fake 'getting the single element of a set operator' ,= as used in elem ,= {'single_element'} which works but just causes confusion! - anyone

I used a double {{ }} to prevent fstring value injection,

for example, heres my Postgres UPDATE statement to update a integer array column that takes expression of {} to capture the array, ie:

ports = '{100,200,300}'

with fstrings its,

ports = [1,2,3]

query = f"""
   UPDATE table SET ports = '{{{ports}}}' WHERE id = 1
"""

the actual query statement will be,

UPDATE table SET ports = '{1,2,3}'

which is a valid postgres satement

Answered   2023-09-20 20:30:31

If you want to print just one side of the curly brace:

a=3
print(f'{"{"}{a}')
>>> {3

Answered   2023-09-20 20:30:31

  • Unnecessary, doubling the { as explained in the top answer is still sufficient. So f'{{{a}'. - anyone

If you want to only print one curly brace (for example {) you can use {{, and you can add more braces later in the string if you want. For example:

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

Answered   2023-09-20 20:30:31

When you're just trying to interpolate code strings I'd suggest using jinja2 which is a full-featured template engine for Python, ie:

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

So you won't be enforced to duplicate curly braces as the whole bunch of other answers suggest

Answered   2023-09-20 20:30:31

  • I agree that avoiding duplicating curly braces is a good thing — but rather than reach for jinja2 I'd just use python's own string.Template class, which is plenty powerful enough for this kind of thing. - anyone

If you need curly braces within a f-string template that can be formatted, you need to output a string containing two curly braces within a set of curly braces for the f-string:

css_template = f"{{tag}} {'{{'} margin: 0; padding: 0;{'}}'}"
for_p = css_template.format(tag="p")
# 'p { margin: 0; padding: 0;}'

Answered   2023-09-20 20:30:31

  • this question was not about f-strings, and IMO combining f-strings and format in this way makes for pretty unreadable code - anyone
  • It is the first result that comes up when you google how to put curly braces in python f-strings though, and yes I agree it's not pretty but sometimes you just need it. - anyone

Or just parametrize the bracket itself? Probably very verbose.

x = '{open_bracket}42{close_bracket}'.format(open_bracket='{', close_bracket='}') 
print(x)
# {42}

Answered   2023-09-20 20:30:31