Does python logging incur a performance hit if you log below the set level?

You can save yourself the hassle of formatting the string for logging as the logging module offers you some string formatting on its own.

You should also save yourself the hassle of checking the level manually. That is just what the library is for.

The docs have this nice graph to explain when and how expensive work is done.

In order to use the internal string formatting of the logging module use percent formatting without the % operator but with seperate arguments to logging.debug and freinds:

logging.debug("Check %s and %s out.", "this", "that")
logging.error("The %(foo)s was %(bar)d", dict(foo="answer", bar=43))

Does Python know that I am set to info level and effectively throw the debug statement away?

First of all no Python statement ever disappears. Python is not like C that will just remove unused code. For Python there is no such thing as unused code (unfortunately). The call will always happen, formatting will always happen. So the only question is: is that really a performance issue and what logic happens underneath the call?

First let me address the .debug() call itself. Python doesn't know much on its own. It totally depends on logger implementation. By default Python loggers won't do anything when they are not enabled for a given level. However this behaviour can be overridden. And this is not some abstract, academic situation, third-party libraries do provide their own implementations all the time. On the other hand such behaviour (i.e. do something even though not allowed because of level) would be a very nasty and unfriendly one. And you can assume (as most of us do) that no such thing happens unless you have a reason to doubt it.

Which approach is better for performance?

Now for the string formatting. If you worry about it then IMO you are wasting time. This is a micro optimization and if you need this level of performance then most likely you should not be using Python to begin with.

The only reason logging could be problematic is if it is logging over network or possibly file system.

Either way: measure first, don't speculate.

That being said, if you really are worried about the performance then you can always utilize what these docs talk about:

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

But please do read docs and familiarize with potential issues with .isEnabledFor() call.

If you want to check current level for yourself, you can get the level by using either getEffectiveLevel() docs or isEnabledFor() docs (the latter is probably what you want to use in the case of checking over and over, though probably you should cache the result for best case performance).

Python internally will check in a similar fashion at a very early stage of the logging process and will stop the statement from being logged if needed.

Depending on how intense creating the logging statement is for you (i.e. more than string formatting) then it's probably most performant to let Python internally choose to log or not versus manually checking before creating a simple string. If you were going to do some more intense thing that required many operations, then maybe checking first from a cache would be best.