Python 2.6 introduced the [`str.format()`][1] method with a slightly different syntax from the existing `%` operator. Which is better and for what situations?

Python 3.6 has now introduced another string formatting format of string literals (aka &quot;f&quot; strings) via the syntax `f&quot;my string&quot;`. Is this formatting option better than the others?

1. The following uses each method and has the same outcome, so what is the difference?

    
        #!/usr/bin/python
        sub1 = &quot;python string!&quot;
        sub2 = &quot;an arg&quot;
    
        sub_a = &quot;i am a %s&quot; % sub1
        sub_b = &quot;i am a {0}&quot;.format(sub1)
        sub_c = f&quot;i am a {sub1}&quot;
    
        arg_a = &quot;with %(kwarg)s!&quot; % {&#39;kwarg&#39;:sub2}
        arg_b = &quot;with {kwarg}!&quot;.format(kwarg=sub2)
        arg_c = f&quot;with {sub2}!&quot;

        print(sub_a)    # &quot;i am a python string!&quot;
        print(sub_b)    # &quot;i am a python string!&quot;
        print(sub_c)    # &quot;i am a python string!&quot;

        print(arg_a)    # &quot;with an arg!&quot;
        print(arg_b)    # &quot;with an arg!&quot;
        print(arg_c)    # &quot;with an arg!&quot;

2. Furthermore when does string formatting occur in Python? For example, if my logging level is set to HIGH will I still take a hit for performing the following `%` operation? And if so, is there a way to avoid this?

        log.debug(&quot;some debug info: %s&quot; % some_info)


  [1]: https://docs.python.org/2/library/stdtypes.html#str.format

String formatting: % vs. .format vs. f-string literal

Is there an easy way with Python f-strings to fix the number of digits after the decimal point? (Specifically f-strings, not other string formatting options like .format or %)

For example, let&#39;s say I want to display 2 digits after the decimal place. 

How do I do that? Let&#39;s say that

    a = 10.1234


Fixed digits after decimal with f-strings

I would like to know how to format this case in a Pythonic way with f-strings:

    names = [&#39;Adam&#39;, &#39;Bob&#39;, &#39;Cyril&#39;]
    text = f&quot;Winners are:\n{&#39;\n&#39;.join(names)}&quot;
    print(text)

The problem is that `&#39;\&#39;` cannot be used inside the `{...}` expression portions of an f-string.
Expected output:

    Winners are:
    Adam
    Bob
    Cyril

How to use newline &#39;\n&#39; in f-string to format output in Python 3.6?

I&#39;m trying to write PEP-8 compliant code for a domestic project and I have a line with an f-string that is more than 80 characters long

![](https://i.stack.imgur.com/Wn6Jh.png) - the solid thin line near the dot at self.text is the 80 char mark.

I&#39;m trying to split it into different lines in the most *pythonic* way but the only aswer that actually works is an error for my linter

*Working Code:*

    def __str__(self):
        return f&#39;{self.date} - {self.time},\nTags:&#39; + \
        f&#39; {self.tags},\nText: {self.text}&#39;


*Output:*

    2017-08-30 - 17:58:08.307055,
    Tags: test tag,
    Text: test text

The linter thinks that i&#39;m not respecting E122 from PEP-8, is there a way to get the string right and the code compliant?

Multiline f-string in Python

I have a string in which I would like curly-brackets, but also take advantage of the f-strings feature. Is there some syntax that works for this?

Here are two ways it does not work. I would like to include the literal text `{bar}` as part of the string.

    foo = &quot;test&quot;
    fstring = f&quot;{foo} {bar}&quot;
`NameError: name &#39;bar&#39; is not defined`

    fstring = f&quot;{foo} \{bar\}&quot;
`SyntaxError: f-string expression part cannot include a backslash`

Desired result:

    &#39;test {bar}&#39;


Edit: Looks like this question has the same answer as https://stackoverflow.com/questions/5466451/how-can-i-print-literal-curly-brace-characters-in-python-string-and-also-use-fo, but you can only know that if you know that `str.format` uses the same rules as the f-string. So hopefully this question has value in tying f-string searchers to this answer.

How to escape curly-brackets in f-strings?

I am using template strings to generate some files and I love the conciseness of the new f-strings for this purpose, for reducing my previous template code from something like this:
     
    template_a = &quot;The current name is {name}&quot;
    names = [&quot;foo&quot;, &quot;bar&quot;]
    for name in names:
        print (template_a.format(**locals()))

Now I can do this, directly replacing variables:

    names = [&quot;foo&quot;, &quot;bar&quot;]
    for name in names:
        print (f&quot;The current name is {name}&quot;)

However, sometimes it makes sense to have the template defined elsewhere — higher up in the code, or imported from a file or something. This means the template is a static string with formatting tags in it. Something would have to happen to the string to tell the interpreter to interpret the string as a new f-string, but I don&#39;t know if there is such a thing.

**Is there any way to bring in a string and have it interpreted as an f-string to avoid using the `.format(**locals())` call?**

Ideally I want to be able to code like this... (where `magic_fstring_function` is where the part I don&#39;t understand comes in):

    template_a = f&quot;The current name is {name}&quot;
    # OR [Ideal2] template_a = magic_fstring_function(open(&#39;template.txt&#39;).read())
    names = [&quot;foo&quot;, &quot;bar&quot;]
    for name in names:
        print (template_a)

...with this desired output (without reading the file twice):

&lt;!-- language: lang-none --&gt;

    The current name is foo
    The current name is bar

...but the actual output I get is:

&lt;!-- language: lang-none --&gt;

    The current name is {name}
    The current name is {name}

How to postpone/defer the evaluation of f-strings?

[f-Strings][1] are available from Python 3.6 and are very useful for formatting strings:

    &gt;&gt;&gt; n=&#39;you&#39;
    &gt;&gt;&gt; f&#39;hello {n}, how are you?&#39;
    &#39;hello you, how are you?&#39;

Reading more about them in [Python 3&#39;s f-Strings: An Improved String Formatting Syntax (Guide)][2]. I found an interesting pattern:

&gt; Note that using triple braces will result in there being only single braces in your string:

&gt;     &gt;&gt;&gt; f&quot;{{{74}}}&quot;
    &#39;{74}&#39;

&gt; However, you can get more braces to show if you use more than triple braces:

&gt;     &gt;&gt;&gt; f&quot;{{{{74}}}}&quot;
    &#39;{{74}}&#39;

And this is exactly the case:

    &gt;&gt;&gt; f&#39;{74}&#39;
    &#39;74&#39;

    &gt;&gt;&gt; f&#39;{{74}}&#39;
    &#39;{74}&#39;

Now if we pass from two `{` to three, the result is the same:

    &gt;&gt;&gt; f&#39;{{{74}}}&#39;
    &#39;{74}&#39;           # same as f&#39;{{74}}&#39; !

So we need up to 4! (`{{{{`) to get two braces as an output:

    &gt;&gt;&gt; f&#39;{{{{74}}}}&#39;
    &#39;{{74}}&#39;

Why is this? What happens with two braces to have Python require an extra one from that moment on?

  [1]: https://www.python.org/dev/peps/pep-0498/
  [2]: https://realpython.com/python-f-strings/





Why is f&#39;{{{74}}}&#39; the same as f&#39;{{74}}&#39; with f-Strings?

I&#39;m using the `.format()` a lot in my Python 3.5 projects, but I&#39;m afraid that it will be deprecated during the next Python versions because of f-strings, the new kind of string literal.

    &gt;&gt;&gt; name = &quot;Test&quot;
    &gt;&gt;&gt; f&quot;My app name is {name}.&quot;
    &#39;My app name is Test.&#39;

Does the formatted string feature come to fully replace the old `.format()`? And from now on, would it be better to use the new style in all cases?

I understand that it&#39;s based on the idea that &quot;Simple is better than complex.&quot; However, what about performance issues; is there any difference between them? Or is it just a simple look of the same feature?

f-strings vs str.format()

I get what the new f strings in python 3.6 do, but what about the ending !r as found in the code snip below. 

    def __repr__(self):
        return (f&#39;Pizza({self.radius!r}, &#39;f&#39;{self.ingredients!r})&#39;)

In Python format (f-string) strings, what does !r mean?

I&#39;m wondering how to use an f-string whilst using `r` to get a raw string literal. I currently have it as below but would like the option of allowing any name to replace `Alex` I was thinking adding an f-string and then replacing `Alex` with curly braces and putting username inside but this doesn&#39;t work with the `r`.

    username = input(&#39;Enter name&#39;)
    download_folder = r&#39;C:\Users\Alex\Downloads&#39;

Combine f-string and raw string literal

Thanks to [David Beazley&#39;s tweet][1], I&#39;ve recently found out that the new [Python 3.6 f-strings][2] can also be nested:

    &gt;&gt;&gt; price = 478.23
    &gt;&gt;&gt; f&quot;{f&#39;${price:0.2f}&#39;:*&gt;20s}&quot;
    &#39;*************$478.23&#39;

Or:

    &gt;&gt;&gt; x = 42
    &gt;&gt;&gt; f&#39;&#39;&#39;-{f&quot;&quot;&quot;*{f&quot;+{f&#39;.{x}.&#39;}+&quot;}*&quot;&quot;&quot;}-&#39;&#39;&#39;
    &#39;-*+.42.+*-&#39;

While I am surprised that this is possible, I am missing on how practical is that, when would nesting f-strings be useful? What use cases can this cover?

Note: The PEP itself does not mention nesting f-strings, but there is a [specific test case][3].


  [1]: https://twitter.com/dabeaz/status/810217326293479425?lang=en
  [2]: https://www.python.org/dev/peps/pep-0536/
  [3]: https://github.com/python/cpython/blob/master/Lib/test/test_fstring.py#L536

Nested f-strings

I am getting a *line too long* [PEP 8][1] *E501* issue.

    f&#39;Leave Request created successfully. Approvers sent the request for approval: {leave_approver_list}&#39;

I tried using a multi-line string, but that brings in a `\n`, which breaks my test:

    f&#39;&#39;&#39;Leave Request created successfully.
    Approvers sent the request for approval: {leave_approver_list}&#39;&#39;&#39;

How can I keep it single line and pass PEP&amp;nbsp;8 linting?

  [1]: https://pep8.org/




How can I split up a long f-string in Python?

I&#39;m trying out Python 3.6. Going through new code, I stumbled upon this new syntax:

    f&quot;My formatting string!&quot;

It seems we can do things like this:

    &gt;&gt;&gt; name = &quot;George&quot;
    &gt;&gt;&gt; print(f&quot;My cool string is called {name}.&quot;)
    My cool string is called George.

Can anyone shed some light on the inner workings of this? In particular what is the scope of the variables that an f-prefixed string can take?

    

String with &#39;f&#39; prefix in python-3.6

How can I do this format with a Python 3.6 F-String?

    person = {&#39;name&#39;: &#39;Jenne&#39;, &#39;age&#39;: 23}

    print(&#39;My name {0[name]} and my age {1[age]}&#39;.format(person, person))
    print(&#39;My name {0} and my age {1}&#39;.format(person[&#39;name&#39;], person[&#39;age&#39;]))




How can I do a dictionary format with f-string in Python 3 .6?

I&#39;m looking for a formatted byte string literal. Specifically, something equivalent to

    name = &quot;Hello&quot;
    bytes(f&quot;Some format string {name}&quot;)

Possibly something like `fb&quot;Some format string {name}&quot;`.

Does such a thing exist?

Is there a formatted byte string literal in Python 3.6+?

The new Python 3.6 f-strings seem like a huge jump in string usability to me, and I would love to jump in and adopt them whole heartedly on new projects which might be running on older interpreters. 2.7, 3.3-3.5 support would be great but at the very least I would like to use these in Python 3.5 code bases. How can I import 3.6&#39;s formatted string literals for use by older interpreters?

I understand that formatted string literals like `f&quot;Foo is {age} {units} old&quot;` are not breaking changes, so would not be included in a `from __future__ import ...` call. But the change is not back-ported (AFAIK) I would need to be sure that whatever new code I write with f-strings is only ran on Python 3.6+ which is a deal breaker for a lot of projects.

Can I import Python&#39;s 3.6&#39;s formatted string literals (f-strings) into older 3.x, 2.x Python?

How can I use f-string with logic to format an `int` as a `float`? I would like if `ppl` is `True` to format `num` to 2 decimal places, and if `ppl` is `False` to rformat it as whatever it is.

Something like `string = f&#39;i am {num:.2f if ppl else num}&#39;` but this does not work. The below code demonstrates the behaviour that I want to achieve with a simpler f-string if possible:

    ppl = True
    num = 3
    string = f&#39;I am {num:.2f}&#39; if ppl else f&#39;I am {num}&#39;
    print(string)
    #if ppl False
    #=&gt; i am 3
    #if ppl True
    #=&gt; i am 3.00

Using f-string with format depending on a condition

I want to use f-string with my string variable, not with string defined with a string literal, `&quot;...&quot;`.

Here is my code:

    name=[&quot;deep&quot;,&quot;mahesh&quot;,&quot;nirbhay&quot;]
    user_input = r&quot;certi_{element}&quot; # this string I ask from user  
    
    for element in name:
        print(f&quot;{user_input}&quot;)

This code gives output:

    certi_{element}
    certi_{element}
    certi_{element}

But I want:

    certi_{deep}
    certi_{mahesh}
    certi_{nirbhay}

How can I do this?

How can I use f-string with a variable, not with a string literal?

I have been examining some of my string format options using the new f-string format.  I routinely need to unpack lists and other iterables of unknown length. Currently I use the following...

    &gt;&gt;&gt; a = [1, &#39;a&#39;, 3, &#39;b&#39;]
    &gt;&gt;&gt; (&quot;unpack a list: &quot; + &quot; {} &quot;*len(a)).format(*a)
    &#39;unpack a list:  1  a  3  b &#39;
This, albeit a bit cumbersome, does the job using pre-3.6 .format notation.
The new f-string format option is interesting given runtime string concatenation.  It is the replication of the number of {} that I am having problems with.  In my previous example, I simply created the necessary structure and unpacked within the .format() section.

Attempts to do this yielded one variant that worked, however:

### 1) Both curly brackets together doesn&#39;t unpack...

    &gt;&gt;&gt; &#39;unpack a list&#39;  f&#39; {{*a}}&#39;
    &#39;unpack a list {*a}&#39;

### 2) Adding spaces around the interior {} pair:

This works but leaves opening and closing braces {, } present:

    &gt;&gt;&gt; &#39;unpack a list&#39;  f&#39; { {*a} }&#39;
    &quot;unpack a list {1, 3, &#39;a&#39;, &#39;b&#39;}&quot;

### 2b) Concatenating the variants into one f-string

This made the look and syntax better, since the evaluation, apparently, is from left to right.  This, however, still left the enclosing curly brackets present:

    &gt;&gt;&gt; f&#39;unpack a list { {*a} }&#39;
    &quot;unpack a list {1, 3, &#39;a&#39;, &#39;b&#39;}&quot;

### 3) Tried automatic unpacking with just `{a}`
Perhaps, I was overthinking the whole procedure and hoping for some form of automatic unpacking.  This simply yielded the list representation with the curly brackets being replaced with `[]` :

    &gt;&gt;&gt; f&#39;unpack a list {a}&#39;
    &quot;unpack a list [1, &#39;a&#39;, 3, &#39;b&#39;]&quot;
    
What is required to suppress the curly brackets in variant (2) above, or must I keep using the existing `.format()` method?  I want to keep it simple and use the new capabilities offered by the f-string and not revert back beyond the python versions which pre-date what I am currently comfortable with.  I am beginning to suspect that f&#39;strings&#39; do not offer a complete coverage of what is offered by its `.format()` sibling.  I will leave it at that for now, since I haven&#39;t even ventured into the escape encoding and the inability to use \ in an f-string.  I have read the PEP and search widely, however, I feel I am missing the obvious or what I wish for is currently not possible.

EDIT several hours later:

### 4) Use subscripting to manually slice off the brackets: `str(a)[1:-2]`

I did find this variant which will serve for some cases that I need

    f&#39;unpack a list: {str(a)[1:-2]}&#39;
    &quot;unpack a list: 1, &#39;a&#39;, 3, &#39;b&quot;

But the slicing is little more than a convenience and still leaves the string quotes around the resultant.

### 5)  and the final solution from @SenhorLucas

     a = np.arange(10)
    
    print(f&quot;{*a,}&quot;)
    (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Unpacking with trailing comma.

All F String Solutions on Gang of Coders

Total of 19 F String Solutions