What is the best way to toggle python prints?

Question

I\'m running Python 2.4 in a game engine and I want to be able to turn off all prints if needed. For example I\'d like to have the prints on for a debug build, and then turn

Answer 1

I've answered this question on a different post but was the question was marked duplicate:

anyhow, here's what I would do:

from __future__ import print_function
DebugPrints = 0

def print(*args, **kwargs):
    if DebugPrints:
        return __builtins__.print(*args, **kwargs)

print('foo') # doesn't get printed
DebugPrints = 1
print('bar') # gets printed

sadly you can't keep the py2 print syntax print 'foo'

Answer 2

If you really want to toggle printing:

>>> import sys
>>> import os
>>> print 'foo'
foo
>>> origstdout = sys.stdout
>>> sys.stdout = open(os.devnull, 'w')
>>> print 'foo'
>>> sys.stdout = origstdout
>>> print 'foo'
foo

However, I recommend you only use print for throwaway code. Use logging for real apps like the original question describes. It allows for a sliding scale of verbosity, so you can have only the important logging, or more verbose logging of usually less important details.

>>> import logging
>>> logging.basicConfig(level=logging.DEBUG)
>>> logging.debug('foo')
DEBUG:root:foo

For example, usage might be to put debugging logs throughout your code. Then to silence them, change your level to a higher level, one of INFO, WARN or WARNING, ERROR, or CRITICAL or FATAL

>>> logging.root.setLevel(logging.INFO)
>>> logging.debug('foo')
>>>

In a script you'll want to just set this in the basicConfig like this:

import logging
logging.basicConfig(level=logging.INFO)

logging.debug('foo') # this will be silent

More sophisticated usage of logging can be found in the docs.

---

Answer 3

Don't use print, but make a console class which handles all printing. Simply make calls to the console and the console can decide whether or not to actually print them. A console class is also useful for things like error and warning messages or redirecting where the output goes.

Answer 4

yes, you can assign sys.stdout to whatever you want. Create a little class with a write method that does nothing:

class DevNull(object):
    def write(self, arg):
        pass

import sys    
sys.stdout = DevNull()
print "this goes to nirvana!"

With the same technique you can also have your prints logged to a file by setting sys.stdout to an opened file object.

Answer 5

I know an answer has already been marked as correct, but Python has a debug flag that provides a cleaner solution. You use it like this:

if __debug__:
    print "whoa"

If you invoke Python with -O or -OO (as you normally would for a release build), __debug__ is set to False. What's even better is that __debug__ is a special case for the interpreter; it will actually strip out that code when it writes the pyc/pyo files, making the resulting code smaller/faster. Note that you can't assign values to __debug__, so it's entirely based off those command-line arguments.

Answer 6

The logging module is the "best" way.. although I quite often just use something simple like..

class MyLogger:
    def _displayMessage(self, message, level = None):
        # This can be modified easily
        if level is not None:
            print "[%s] %s" % (level, message
        else:
            print "[default] %s" % (message)

    def debug(self, message):
        self._displayMessage(message, level = "debug")
    def info(self, message):
        self._displayMessage(message, level = "info")

log = MyLogger()
log.info("test")