Within each placeholder, the value that will be formatted can be followed by a conversion and a format specifier.

>>> f'{status!s}' # Converting the string using `str`
'off'
>>> f'{status!r}' # Converting the string using `repr`
"'off'"

>>> f'{count:#b}' # binary, with a prefix (because of the #)
'0b1000'
>>> f'{count:<5}' # left-aligned within a "field"
'8    '
>>> f'{count:05}' # right-aligned (the default) and zero-padded
'00008'
>>> f'{count:e}' # scientific notation
'8.000000e+00'
>>> f'{count:{"5"}}' # numbers here can also use placeholders
'    8'

The builtin function format (a plain function, not the method of string objects) implements the logic for formatting a single value that will replace a placeholder. With one argument, it's basically equivalent to calling str to convert the object to string:

>>> format([1, 2, 5, 'Three, sir.'])
"[1, 2, 5, 'Three, sir.']"

The second argument can be a format specifier that works just like for f-strings:

>>> format(8, '#010b')
'0b00001000'

To emulate conversions, just do that conversion to the first argument instead:

>>> f'{"®"!a}' # for reference
"'\\xae'"
>>> format(ascii('®'))
"'\\xae'"

This format function is a wrapper for the __format__ magic method, which implements a type's logic for handling format specifiers. This can be used to implement custom rules for formatting, that can also be customized in a custom way in the template.

For example:

class Fancy(str):
    def __format__(self, spec):
        # The `str` call here avoids unbounded recursion.
        return f'{spec}{str(self.upper())}!{spec[::-1]}'

Which enables:

>>> meal = Fancy(spam)
>>> f'{meal:-+*}'
'-+*SPAM!*+-'

The advantage over f-strings is that the "template" string can be stored for later use, and explicitly fill in the values later, and that the placeholders can usefully be empty:

>>> template = 'I have {} cans of Spam®; baked beans are {}'
>>> template.format(count, status)
'I have 8 cans of Spam®; baked beans are off'

However, the syntax is much more limited. The values that will be formatted need to be passed in as arguments - any calculation happens at or before that point, not as part of the template.

>>> '{x} + {x}'.format(x=1)
'1 + 1'

>>> x = 1
>>> '{x}'.format(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'x'

>>> # for example, for localization
>>> 'In English, {0} {1} {2}.'.format('a', 'dead', 'parrot')
'In English, a dead parrot.'
>>> 'En Français, {0} {2} {1}.'.format('un', 'mort', 'perroquet')
'En Français, un perroquet mort.'
>>> # or just repetition
>>> '{0}, {0}, {0}, {0}, {0}, {1} {0}, {0}'.format('spam', 'lovely')
'spam, spam, spam, spam, spam, lovely spam, spam'

>>> '{}'.format('spam', 'eggs')
'spam'
>>> '{1}'.format('spam', 'eggs')
'eggs'
>>> '{veggie}'.format(meat='spam', veggie='baked beans')
'baked beans'

>>> # Doesn't work with negative numbers or slices.
>>> '{[0]}'.format([1, 2, 3])
'1'
>>> # Only works with keys that are strings.
>>> '{[key]}'.format({'key': 'value'})
'value'
>>> '{.imag}'.format(1+2j)
'2.0'

>>> '{x+y}'.format(x=1, y=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'x+y'

>>> # This negative index gets interpreted as a string key instead.
>>> '{[-1]}'.format([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list indices must be integers or slices, not str

The format_map method is a minor variation on the format method that is rarely seen. It takes a single parameter which is some kind of mapping; it works like format, except looking up keys in the mapping instead of keyword arguments.

Calling .format_map(mapping) is similar to calling .format(**mapping), but it allows the mapping to compute values on-demand when the keys are looked up, and doesn't require the mapping to know what its keys are. It's possible to define custom mappings, like so:

>>> class ExampleMapping(dict):
...     def __missing__(self, key):
...         return f'value for {key}'
... 
>>> '{ham} and {eggs}'.format(**ExampleMapping()) # doesn't work
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'ham'
>>> '{ham} and {eggs}'.format_map(ExampleMapping()) # this is needed
'value for ham and value for eggs'

>>> # This does not try an empty string key!
>>> '{}'.format_map(ExampleMapping()) 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Format string contains positional fields

The standard library string module provides a class called Formatter which is a pure-Python implementation of the format method's logic. A call like string.Formatter().format(my_string, ...) is equivalent to my_string.format(...), with whatever positional and keyword arguments replacing the .... The purpose of this class is to provide hooks for changing how the formatting process works.

A simple (sort of...) example, where the "template" is now a plain list of comma-separated items:

class CommaFormatter(string.Formatter):
    def parse(self, fstr):
        # This will also be called to look for nested placeholders within
        # format specs. Ignoring these fully requires special handling.
        if fstr is None:
            return
        field_names = [f.strip() for f in fstr.split(',')]
        leading = ''
        for fname in field_names:
            yield (leading, fname, None, 's')
            leading = ', ' # for each item except the first

Which allows:

>>> cf = CommaFormatter().format
>>> cf('meat, veggies', meat='spam', veggies='baked beans')
'spam, baked beans'
>>> cf('0,0,0,0,0,0,1,0,0,0,0,0', 'spam', 'baked beans')
'spam, spam, spam, spam, spam, spam, baked beans, spam, spam, spam, spam, spam'

And, perhaps counter-intuitively:

>>> cf('', 'spam', 'baked beans')
'spam'
>>> cf(',', 'spam', 'baked beans')
'spam, baked beans'

>>> t.substitute()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python3.11/string.py", line 121, in substitute
    return self.pattern.sub(convert, self.template)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.11/string.py", line 114, in convert
    return str(mapping[named])
               ~~~~~~~^^^^^^^
KeyError: 'count'

>>> t.safe_substitute(status='off')
'I have $count cans of Spam®; baked beans are off'

Use {} to clarify the placeholder name if there need to be letters immediately after the substituted value:

>>> Template('${b}a${c}o$n').substitute(b='b',c='c',n='n')
'bacon'

To escape a literal $, double it up (I'm noticing a theme...):

>>> Template('ca$$h $cash').substitute(cash='money')
'ca$h money'

For really advanced use cases, the Template class can also be subclassed - refer to the documentation for details.