Logging instead of print

print() is perfect for a quick experiment. In a script that runs every night or a program other people use, it falls short: you cannot turn the noisy messages off, you do not know when something happened, and errors get mixed into normal output. The standard library’s logging module fixes all three.

The core idea: levels

Every log message has a level. You pick a threshold once, and messages below it are dropped.

• DEBUG: details you only want while hunting a bug.
• INFO: normal progress (“Loaded 120 orders”).
• WARNING: something unexpected, but the program continues. This is the default threshold.
• ERROR: an operation failed.
• CRITICAL: the program probably cannot continue.

A minimal, correct setup

import logging

logger = logging.getLogger(__name__)


def load_orders(path):
    logger.info("Loading orders from %s", path)
    try:
        with open(path, encoding="utf-8") as f:
            lines = f.read().splitlines()
    except FileNotFoundError:
        logger.exception("Could not read %s", path)
        return []
    logger.debug("Read %d lines", len(lines))
    if not lines:
        logger.warning("%s is empty", path)
    return lines


def main():
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
        datefmt="%H:%M:%S",
    )
    load_orders("orders.txt")


if __name__ == "__main__":
    main()

Output looks like 09:07:05 INFO __main__: Loading orders from orders.txt. Change level=logging.INFO to logging.DEBUG and the debug line appears too, with no other edits.

Four habits that matter

1. One logger per module: logger = logging.getLogger(__name__) at the top. The logger name then tells you which file produced each line.
2. Configure once, at the entry point: call logging.basicConfig() only in main() or the if __name__ == "__main__" block. Library modules should never configure logging; they only create loggers and log.
3. Pass values as arguments: write logger.info("Saved %s", path), not an f-string. The text is only formatted if the message is actually emitted, and tools that group logs can recognize identical messages.
4. Use logger.exception() inside except: it logs at ERROR level and appends the full traceback automatically.

Sending logs to a file and the console

basicConfig covers most scripts; it also accepts filename="app.log". When you want different destinations with different thresholds, attach handlers yourself:

import logging
import sys

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

console = logging.StreamHandler(sys.stderr)
console.setLevel(logging.INFO)
console.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))

logfile = logging.FileHandler("myapp.log", encoding="utf-8")
logfile.setLevel(logging.DEBUG)
logfile.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))

logger.addHandler(console)
logger.addHandler(logfile)

logger.debug("only in the file")
logger.info("in both places")
logging.getLogger("myapp.db").warning("child loggers propagate to myapp")

Logger names form a tree split on dots. myapp.db is a child of myapp, so its messages travel up to the parent’s handlers. That is why naming loggers with __name__ (which follows your package layout) works so well.

Where print() still belongs

Use print() for the program’s actual output: the report a CLI tool produces, or JSON another program will read. Use logging for messages about what the program is doing. Logging writes to standard error by default, so python tool.py > result.json keeps the data clean while progress messages still appear in the terminal.

For long-running services, look at logging.handlers.RotatingFileHandler so log files do not grow forever, or log to standard error and let your container platform or systemd collect it.