W1203 with F-strings

[pzelnip]

Question

The logging-fstring-interpolation (W1203) warning reads:

  | Use % formatting in logging functions and pass the % parameters as arguments 
Used when a logging statement has a call form of "logging.<logging method>
(format_string.format(format_args...))". Such calls should use % formatting instead, 
but leave interpolation to the logging function by passing the parameters as arguments.
This message is emitted if f-string was used, and it can be disabled if you like.

It's not clear to me from that paragraph if its recommended to still use the formatting operator in logging statements, or if f-strings should be used. My understanding is the original intent of W1203 was to prefer the formatting operator over calls to format() as then the string interpolation is done lazily. I'm guessing the same is true with f-strings correct? Ie F-strings would not be evaluated lazily, so the same reasons for preferring the formatting operator over .format() with log statements apply, and as such the same warning is emitted when f-strings are used with log statements.

Is that correct?

[PCManticore]

Hi, thanks for reporting an issue. That's right, this message is emitted when f-strings are used with logging methods, and it recommends to switch to % instead.

[charlescbeebe]

Is there a PEP that justifies this, or perhaps a thread in which 2+ core Python devs agree with this stance? If not, what makes this an objectively good idea?

[neitsa]

@charlescbeebe If I'm not mistaken % formatted strings are not "built" (formatted) if the logger level is below the one configured for the handlers for that logger (e.g. your logger level is set to logging.INFO and you have a call to logger.debug() then nothing is formatted). On the other hand f-strings are always built...

[pzelnip]

@neitsa you are correct, if the loglevel is such that the statement does not get emitted, then using % formatting will save you the cost of string interpolation.

However, in practice because f-strings are so performant even when doing the string interpolation, the savings in time is extremely negligible (see the timeit results at #2395).

Furthermore, if the interpolation is happening (ex if log level is set to debug and you're doing a logging.info()), then it's very likely that f-strings are actually faster than % formatting. For some discussion of why, see https://cito.github.io/blog/f-strings/ (under "Performance considerations") and https://medium.com/@augustogoulart/python-f-strings-fun-strings-fast-strings-beeae4ddd1a

So if you follow the Pylint suggestion and don't use f-strings you're making your code slower in some places and maybe slightly faster in others (depending on loglevel and how many logging statements you're suppressing by loglevel). At the end of the day though, unless you're logging a lot of calls at a loglevel that's ignored (like on the order of millions), then the performance difference is going to be not-noticeable regardless of which you choose.

Additionally, putting the performance discussion aside, f-strings have many other advantages over % formatting from a readability and/or flexibility perspective.