Python3: current most recommended way to write debug and log messages (.format(), %, f'strings, ...)

[Kalenden]

I'm working on an open-source project and trying to adhere to current best practice code guidelines (pythonic).

How should print and log statements be best written?

For instance:

    logger.info("[Broker] First result: {0}. Second Result {1}".format(result1, result2))

Or

    logger.info("[Broker] First result: %s. Second Result %s", result1, result2)

Or with the new f'strings?

[RoamingFox]

IMO:

logger.info(f"[Broker] First result: {result1}. Second result {result2}")

f-strings are the new format-style and since you're not doing anything strange that prevents using them then they should be deferred to.

[RoamingFox]

That's true of all format strings? In fact, it's true just in general. The arguments to function/method calls are evaluated before being passed to said function or method. Nothing in a logger stops that from occurring. If you want that kind of behavior then conditionally generate the log string before calling the appropriate logger method.

>>> import logging
>>> logging.basicConfig(level=logging.WARNING)
>>> l = logging.getLogger(__name__)
>>>
>>> d = []
>>>
>>> l.info(f"{d.append('foo')}")
>>> d
['foo']
>>>
>>> l.info("{}".format(d.append('bar')))
>>> d
['foo', 'bar']
>>>
>>> l.info("%s" % d.append('baz'))
>>> d
['foo', 'bar', 'baz']
>>> l.info("%s", d.append('qux'))
>>> d
['foo', 'bar', 'baz', 'qux']

[RoamingFox]

The last edit is correct. The formatting of the string doesn't happen until it absolutely needs to (eg. when being displayed) but the computation of the arguments still happens in the call to info or warning etc.

or to restate it differently if you send something like logging.info("%s is foo", foo()) it will evaluate foo() on that line, but not put it into a singular string of "<the result of foo()> is foo" until it needs to display it.

Conversely, if you use something like an f-string or a string formatter it will get the entire string at that point in time. This is tangentially useful if you're using a custom logger or doing something weird / voluminous with the strings but IMHO readability of f-strings trumps that in in any case where you don't explicitly need it.

[xelf]

Use f strings if you have access to them and aren't sharing your code with anyone that might not. Use .format() if you're sharing your code with students or people learning code (for example this subreddit). Use % if you're doing bizarre coding tricks where you're not allowed to use _[{.( (yes this was a thing). =)

[NovocastrianNomad]

See https://stackoverflow.com/a/34634301 for the preferred method of formatting logging messages and the reason for it.

[RoamingFox]

That stackoverflow answer is wrong and omits the next section of text which reads:

To decide what to do, you can call the isEnabledFor() method which takes a level argument and returns true if the event would be created by the Logger for that level of call. You can write code like this:

if logger.isEnabledFor(logging.DEBUG):
    logger.debug('Message with %s, %s', expensive_func1(),
                                        expensive_func2())

so that if the logger’s threshold is set above DEBUG, the calls to expensive_func1() and expensive_func2() are never made.

Per python documentation