PyFormat – Practical examples of old and new style string formatting (opens in new tab)

  'result: {long_var_name}'.format(long_var_name=long_var_name)

  'result: %(long_var_name)s'%{"long_var_name":long_var_name}
    -or-
  'result: %(long_var_name)s'%dict(long_var_name=long_var_name)

My experience with '%(name)s' % dict formatting is that I would often forget the terminal 's', and write it as '%(name)'. For template-like strings, where I want named substitutions, I am very much in favor of {}-style formatting.

So if your co-worker insists on named substitutions, then s.format() is less verbose than s % dict.

Regarding logging, there's a section of how to use format templates in the logging system, at https://docs.python.org/3/howto/logging-cookbook.html#format... . In addition to using a LogRecord factory, you could reduce the overhead in old-style logging to only an extra constructor calls:

  log.info(M('result: {} {}', one, two))

Personally, I would like a way to pre-compile the format string:

  fmt = format_compile("result: {} {} {}")
  for result in results:
    print(fmt(*result))

EDIT: Never mind: It can be faster to interpolate the string each time than to call a constructor:

  % python3.3 -mtimeit 's="%s %s %s"' 's % (1, 3, 9)'
  1000000 loops, best of 3: 0.36 usec per loop
  % python3.3 -mtimeit 'class Spam:pass' 'Spam()'
  10000 loops, best of 3: 23.6 usec per loop

I also import print_function from the future, mainly because you can break lines inside the parentheses.

I also use ' '.join([...]) for the same reason when building a large-ish string, you can break lines inside parentheses (or square brackets in this case).

I like breaking lines inside parentheses and other delimiters.

With this approach, my own app needs to do the actually formatting, while `format()` merely concats.

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

    a = 4

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

  % python3.3 -mtimeit 's="%s %s %s"' 's % (1, 3, 9)'
  1000000 loops, best of 3: 0.361 usec per loop
  % python3.3 -mtimeit 's="{} {} {}"' 's.format(1, 3, 9)'
  1000000 loops, best of 3: 0.593 usec per loop
  % python3.3 -mtimeit 'f="{} {} {}".format' 'f(1, 3, 9)'
  1000000 loops, best of 3: 0.569 usec per loop

        TARGET(BINARY_MODULO)
            w = POP();
            v = TOP();
            if (PyUnicode_CheckExact(v))
                x = PyUnicode_Format(v, w);
            else
                x = PyNumber_Remainder(v, w);
            Py_DECREF(v);
            Py_DECREF(w);
            SET_TOP(x);
            if (x != NULL) DISPATCH();
            break;

While the "".format(x) path goes through the normal method invocation path - it has no special treatment.

uhh... so you'd prefer to do something like `1.add(2)` ???

also, if you are going to repeat always the same, you can standardize it in a string var and just use that instead of repeating.

and if you are NOT, then it beats '{:^8} {:*8} {:@8} {:☃8}' anytime, because now you have to know and notice the change in those cryptic chars.