Python print() — Print Buffering Drops Docker Output

Every Python developer has done it: spent 45 minutes convinced there's a logic bug, only to realise print() was buffering output and they were reading stale data the entire time. Not a beginner mistake — I've watched a senior engineer waste a morning on this during a live incident because stdout was line-buffered inside a Docker container and nothing was flushing to the log aggregator.

print() looks like the simplest thing in Python. One function, one job — show something on screen. But it has five parameters most beginners never touch, a buffering model that silently eats your debug output at the worst possible moment, and formatting options that, once you know them, make you wonder how you ever lived without them. The gap between knowing print() exists and actually knowing how it works is wider than it looks.

By the end of this article you'll be able to use every parameter print() accepts, format output cleanly using f-strings and the sep and end arguments, write output to files instead of the terminal, force-flush buffered output so it actually appears when you need it, and spot the exact mistakes that cause beginners to think their code isn't running when it's running just fine.

What print() Actually Does — and the Buffering Trap Nobody Warns You About

Before you can use print() well, you need a mental model of what happens when you call it. You type print('hello') and a word appears on screen. Simple. But there are three invisible steps between those two events: Python converts your value to a string, hands it to the operating system's standard output stream (stdout), and the OS decides when to actually display it. That last step is the one that bites people.

Stdout is buffered. That means Python doesn't necessarily write your output to the screen the instant you call print(). It stacks up output in memory and flushes it in chunks — usually when the buffer fills up, when the program ends cleanly, or when a newline character is written. In an interactive terminal, Python uses line-buffering, so you see output after each newline. But pipe that program's output to a file, run it inside Docker, or wrap it in a subprocess, and you get full block-buffering. Your print() calls appear to do nothing until the program exits.

I've seen this burn people specifically in long-running data pipeline scripts — a developer adds print() calls for progress reporting, runs the script piped to tee to capture logs, and sees nothing for 30 minutes then gets a wall of text all at once when the script finishes. The fix is the flush parameter, which we'll get to. But knowing this buffering model exists is the first thing you need, because without it the symptom looks exactly like a hung process.

The Full print() Syntax: All Five Parameters, Actually Explained

The full signature of print() is: print(*objects, sep=' ', end=' ', file=sys.stdout, flush=False). Most tutorials show you the first argument and quietly ignore the other four. That's a mistake, because those four parameters are where print() becomes genuinely useful.

*objects means you can pass as many values as you want, separated by commas. Python converts each one to a string using str() before printing. sep is what gets placed between those values — it defaults to a single space, but you can make it anything: a pipe character, a tab, a comma, an empty string. end is what gets appended after the last value — it defaults to a newline character, which is why each print() call appears on its own line. Change it to an empty string and you can print multiple things on one line across multiple calls.

file lets you redirect print() output to any object that has a write() method — a file handle, sys.stderr, a StringIO buffer, or any custom stream. This is genuinely useful for writing lightweight scripts that log to a file without importing the logging module. flush we already covered in depth: it bypasses the OS buffer and writes to the stream immediately. None of these parameters are optional knowledge — they come up the moment you write anything beyond a simple script.

Formatting Output with f-strings: The Right Tool for the Job

You will format strings inside print() constantly. There are three ways to do it in modern Python: concatenation with +, the old .format() method, and f-strings. Don't use concatenation for anything beyond gluing two things together — it breaks the moment you mix strings and non-strings and it's unreadable at scale. Don't use .format() for new code — it was the right answer before Python 3.6 and it's been outdated since. Use f-strings.

An f-string is a string literal prefixed with f. Any expression inside curly braces gets evaluated and inserted. You can put arithmetic, function calls, method calls, conditional expressions — any valid Python expression — directly inside the braces. You can also add format specifiers after a colon inside the braces to control number formatting, padding, and alignment.

The format specifiers are where beginners usually stop reading, which is a shame because they solve real problems. :.2f gives you a float rounded to two decimal places — essential for money. :, adds thousands separators to integers. :>10 right-aligns a value in a 10-character-wide column. :<10 left-aligns. :^10 centres. These turn chaotic number output into readable, aligned tables without reaching for any external library. The combination :>15,.2f means right-align in a 15-character field, add comma separators, show two decimal places — one specifier replaces what used to take three or four string operations.

Printing Multiple Values, Special Characters, and When to Stop Using print()

There are two small mechanics beginners stumble over: printing multiple values in one call, and dealing with special characters. Passing multiple arguments to print() is cleaner than concatenation — print(first_name, last_name) just works, and you control the separator with sep. You don't need to manually add spaces or call str() on each value — print() handles the conversion internally.

Special characters use escape sequences inside strings. is a newline, \t is a tab, \\ is a literal backslash, and \' or \" escape quotes inside a string. You'll use constantly. You'll use \t occasionally for quick-and-dirty alignment, though f-string width specifiers are cleaner and more predictable for anything that needs to stay aligned across different-length values.

Now — the opinion you didn't ask for but need to hear. print() is a debugging and light-output tool. The moment you're writing a production service, a daemon, a web application, or anything that runs unattended, switch to Python's logging module. It gives you log levels (DEBUG, INFO, WARNING, ERROR, CRITICAL), timestamps, filenames, line numbers, and configurable output destinations — all things print() cannot give you. I've inherited codebases where the entire observability strategy was print() calls sprinkled across 15 files, and debugging a production issue in that codebase meant grepping through 200 identical-looking lines with no timestamps and no severity context. The on-call engineer has no idea which print() is relevant to the current incident and which is leftover from someone's debugging session six months ago. Don't build that codebase. Use print() to learn, use it in one-off scripts, use it for deliberate user-facing terminal output. For everything else: logging.

Frequently Asked Questions