You can also:

    a = 4
    'A is: %(a)d' % locals()

Perhaps is my experience programming in C, but "format" looks lees familiar and I tend to use the old style formatting.

Might not work in some special cases though. Try:

  def foo():
      a = 4
      def bar():
          print("a = {a}".format(**locals()))
      bar()
        
  foo()

which will raise a KeyError, while it will work fine if you add a

  print(a)

to the end of bar().

Actually, if you reference 'a' at all in bar, it will work:

    def foo():
        a = 4
        def bar():
            a
            print("a = {a}".format(**locals()))
        bar() 
    foo()

successfully prints

    a = 4

which is a bit confusing, but makes sense if you think about it.

In this case, 'a' isn't a local variable binding though.

Right, but it's accessible in scope though. It's just a "gotcha" for that method that might be easy to overlook if you aren't paying attention (or if someone with less experience stumbles onto this 'trick' in production code).

I've seen this and tried to avoid it since getting bitten my moving code around and not catching which variables were used. It might have been even more obscured with something like TEMPLATED_STRING.format(locals())

Why not just

    a = 4
    'A is:{}'.format(a)

I think the point would be to do something like:

    a = 3
    b = 4
    c = 6
    "A is {a}, C is {c}, B is {b}".format(**locals())

Then you don't have to figure out specifying order or definitions like ".format(a=a, b=b, c=c)". I'd probably go the more explicit route in production code anyway, but for debugging / unstable development it seems useful.

I'm still not convinced. In order to write the string portion of the code, I need to know the names of the variables in play and I have to order them in them in some order in the string regardless.

So I still don't think

    "A is {a}, C is {c}, B is {b}".format(**locals())

is better than

   "A is {}, C is {}, B is {}".format(a, c, b)

str.format_map takes a mapping directly (added in 3.2).