Question

Sometimes I have a lot of prints scattered around function to print debug output.
To switch this debug outputs I came up with this:

def f(debug=False): 
    print = __builtins__.print if debug else lambda *p: None

Or if I need to print something apart from debug message, I create dprint function for debug messages.

The problem is, when debug=False, this print statements slow down the code considerably, because lambda *p: None is still called, and function invocation are known to be slow.

So, my question is: Is there any better way to efficiently disable all these debug prints for them not to affect code performance?

---

All the answers are regarding my not using logging module. This is a good to notice, but this doesn’t answer the question how to avoid function invocations that slow down the code considerably – in my case 25 times (if it’s possible (for example by tinkering with function code object to through away all the lines with print statements or somehow else)). What these answers suggest is replacing print with logging.debug, which should be even slower. And this question is about getting rid of those function calls completely.

I tried using logging instead of lambda *p: None, and no surprise, code became even slower.

---

Maybe someone would like to see the code where those prints caused 25 slowdown: http://ideone.com/n5PGu

And I don’t have anything against logging module. I think it’s a good practice to always stick to robust solutions without some hacks. But I thinks there is nothing criminal if I used those hacks in 20-line one-time code snippet.

---

Not as a restriction, but as a suggestion, maybe it’s possible to delete some lines (e.g. starting with print) from function source code and recompile it? I laid out this approach in the answer below. Though I would like to see some comments on that solution, I welcome other approaches to solving this problem.

Answer 1

Ned Batchelder wrote in the comment:

I suspect the slow down is in the calculation of the arguments to
your debug function. You should be looking for ways to avoid those
calculations. Preprocessing Python is just a distraction.

And he is right as slowdown is actually caused by formatting string with format method which happens regardless if the resulting string will be logged or not.

So, string formatting should be deferred and dismissed if no logging will occur. This may be achieved by refactoring dprint function or using log.debug in the following way:

log.debug('formatted message: %s', interpolated_value)

If message won’t be logged, it won’t be formatted, unlike print, where it’s always formatted regardless of if it’ll be logged or discarded.

The solution on log.debug‘s postponed formatting gave Martijn Pieters here.