Python print() Function: Syntax, Formatting and Real Examples

# 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
        )

    # end='' replaces the default newline with nothing,
    # so the next print() continues on the same line.
    print("\nImport complete.", flush=True)


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

# 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 a new indented line.
        # end='' prevents an extra blank line at the start.
        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"
    )

# 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 — !s calls str() on the date object
    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 YoY 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
    )

# 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
)

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, 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
        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)  # \n is already the default end= so no need to add it
    attempt_login(username="alice", provided_password="correct_password")