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.

# io.thecodeforge — Python tutorial

import time
import sys

# Simulates a long-running data import job.
# Without flush=True, none of these progress lines appear
# until the entire job finishes — which is useless for monitoring.

def run_import_job(total_records: int) -> None:
    print(f"Starting import of {total_records} records...")

    for batch_number in range(1, total_records + 1):
        # Simulate work being done on each record
        time.sleep(0.1)

        # flush=True forces Python to push this line to stdout RIGHT NOW
        # instead of waiting for the buffer to fill.
        # Without this, in a piped or containerised environment,
        # you'd see nothing until the program exits.
        print(
            f"Processed record {batch_number}/{total_records}",
            flush=True  # <-- this is the line that makes monitoring actually work
        )

    # '\n' at the start gives a blank line after the last progress entry
    # so the completion message stands visually apart.
    print("\nImport complete.", flush=True)


if __name__ == "__main__":
    run_import_job(total_records=5)

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.

# io.thecodeforge — Python tutorial

import sys
from datetime import datetime

# Imagine this is a checkout service generating a transaction receipt.
# Each parameter of print() is doing real work here.

def print_receipt(
    order_id: str,
    items: list[tuple[str, float]],
    log_file_path: str
) -> None:

    # Open a file to log receipts — print() will write there instead of stdout
    with open(log_file_path, "a") as receipt_log:

        # sep='\n' puts each argument on its own line.
        # end='\n' keeps the normal line break after the last item.
        print(
            "=" * 40,
            f"ORDER ID : {order_id}",
            f"TIMESTAMP: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
            sep="\n",   # each argument printed on its own line
            end="\n",  # normal newline after the last item
            file=receipt_log,  # writes to the file, not the terminal
            flush=True  # flush immediately so log isn't lost if service crashes
        )

        # Print each line item — sep is a pipe character for readability
        for item_name, item_price in items:
            print(
                f"  {item_name}",
                f"£{item_price:.2f}",  # :.2f formats float to 2 decimal places
                sep=" | ",  # separator between item name and price
                file=receipt_log,
                flush=True
            )

        # Calculate and print total
        total = sum(price for _, price in items)
        print(f"\nTOTAL: £{total:.2f}", file=receipt_log, flush=True)
        print("=" * 40, file=receipt_log, flush=True)

    # Confirm to the terminal (stdout) — separate from the file log
    print(f"Receipt for order {order_id} written to {log_file_path}")


if __name__ == "__main__":
    cart = [
        ("Wireless Headphones", 79.99),
        ("USB-C Cable", 12.49),
        ("Screen Protector", 8.00),
    ]
    print_receipt(
        order_id="ORD-20240812-7743",
        items=cart,
        log_file_path="receipts.log"
    )

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.

# io.thecodeforge — Python tutorial

# Realistic scenario: a sales reporting script that prints
# a formatted summary table to the terminal each morning.
# This is the kind of internal tooling that lives in every company
# and is almost always badly formatted because nobody knew f-string specifiers.

from datetime import date

def print_sales_report(
    report_date: date,
    regional_sales: list[tuple[str, int, float]]
) -> None:

    # Header with dynamic date
    print(f"\n{'DAILY SALES REPORT':^50}")
    print(f"{'Date: ' + str(report_date):^50}")
    print("-" * 50)

    # Column headers — :<20 left-aligns in a 20-char wide column
    # :>10 right-aligns in a 10-char column
    print(f"{'Region':<20} {'Units':>10} {'Revenue':>15}")
    print("-" * 50)

    total_units = 0
    total_revenue = 0.0

    for region_name, units_sold, revenue in regional_sales:
        total_units += units_sold
        total_revenue += revenue

        # :, adds thousands separators: 12000 becomes 12,000
        # :.2f formats to 2 decimal places for currency
        # The full :>15,.2f means: right-align in 15 chars, comma separator, 2 decimal places
        print(
            f"{region_name:<20} "
            f"{units_sold:>10,} "
            f"£{revenue:>14,.2f}"
        )

    print("=" * 50)

    # Conditional expression inside f-string — shows performance status inline
    performance_flag = "✓ On Target" if total_revenue >= 50_000 else "⚠ Below Target"
    print(f"{'TOTAL':<20} {total_units:>10,} £{total_revenue:>14,.2f}")
    print(f"\nStatus: {performance_flag}")


if __name__ == "__main__":
    sales_data = [
        ("North",   4210,  18_430.50),
        ("South",   3875,  15_200.00),
        ("East",    2990,  12_750.75),
        ("West",    5100,  21_880.25),
    ]
    print_sales_report(
        report_date=date(2024, 8, 12),
        regional_sales=sales_data
    )

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.

# io.thecodeforge — Python tutorial

# Shows the difference between print() for user-facing terminal output
# and the point where you should switch to the logging module.
# This is a simplified auth flow for illustration.

import logging
import sys

# Configure logging — this is the pattern you use instead of print()
# for anything that runs in the background or in production.
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d — %(message)s",
    stream=sys.stdout  # you can also point this at a file handler
)

logger = logging.getLogger(__name__)


def attempt_login(username: str, provided_password: str) -> bool:
    """Simulates a login check with both print() and logging to show the contrast."""

    # print() is fine here — this is deliberate user-facing terminal output
    print(f"\nAttempting login for: {username}")

    # logging.debug is the right call for internals —
    # it includes timestamp, file, and line number automatically
    logger.debug("Login attempt started for user: %s", username)

    # Simulated password check (never store plain passwords — this is just illustration)
    stored_password_hash = "hashed_secret_123"  # placeholder
    password_matches = provided_password == "correct_password"  # simplified check

    if not password_matches:
        # logging.warning is appropriate — it's an event worth recording with severity
        logger.warning("Failed login attempt for user: %s", username)

        # print() for the user-facing message — they need to see this
        print("Login failed. Check your credentials.")
        return False

    logger.info("Successful login for user: %s", username)
    print(f"Welcome back, {username}!")
    return True


if __name__ == "__main__":
    # Demonstrates: multiple values in one print(), sep, and special characters
    print("=" * 40)
    print("Username:", "Status:", "Result:", sep="\t")  # tab-separated header
    print("=" * 40)

    attempt_login(username="alice", provided_password="wrong_password")
    print("-" * 40)
    attempt_login(username="alice", provided_password="correct_password")