Learn How to Get Output in Python: Absolute Beginners Tutorial

When a Python script runs and produces no output, there is no way to know if it worked. print() is how a program speaks. This tutorial covers how to produce output in Python from your very first print() call through f-strings, separators, and line endings — building not just syntax knowledge, but a mental model of what the interpreter is actually doing at each step.

Producing output is how a program communicates. Without it, a script can run perfectly but leave no trace. Python makes this straightforward through the built-in print() function, which works from the first line you ever write and scales to cover formatted multi-line reports. This tutorial walks through every piece of that function so you understand not just what to type, but why each part works the way it does.

The print() Function

The print() function is built into Python, meaning you never need to import anything to use it. You call it by typing its name followed by parentheses, and you place whatever you want to display inside those parentheses. Python's official documentation describes print() as sending its arguments to the standard output stream, which in practice means your terminal window.

The complete signature of print(), as documented by the Python Software Foundation, is:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Every parameter except *objects has a default. That is why print("hello") works — you are relying on every default at once. The parameters you will use at this stage are sep (the separator between values), end (what to print at the end of the call), file (where to send output — defaults to the terminal), and flush (whether to force the output buffer to empty immediately — added in Python 3.3, defaults to False). Each is covered in context through this tutorial.

print("Hello, world!")

Running that single line produces:

Hello, world!

Printing Numbers and Empty Lines

You can pass integers and floats directly to print() without wrapping them in quotes. Python converts numeric values to their string representations automatically. Calling print() with nothing inside produces a blank line, which is useful for spacing output.

print(42)
print(3.14)
print()
print("After a blank line")

42
3.14

After a blank line

Printing Variables and Multiple Values

Programs rarely print fixed text only. Usually you need to display the result of a calculation or the current value of a variable. You pass a variable to print() the same way you pass a string — just use the variable name without quotes.

name = "Alex"
age = 29
print(name)
print(age)

Alex
29

The sep Parameter

Pass multiple values to print() by separating them with commas. Python places a single space between each value by default. The sep parameter lets you replace that space with any string you choose, including an empty string to remove spacing entirely.

# Default sep is a single space
print("Python", "is", "fun")

# Custom sep
print("2026", "04", "03", sep="-")

# No spacing between values
print("http", "//", "example.com", sep="")

Python is fun
2026-04-03
http//example.com

The end Parameter

By default, print() adds a newline character at the end of every call, so the next call starts on a fresh line. The end parameter replaces that newline with any string you specify. Setting end="" keeps all output on the same line.

# Default end (newline after each call)
print("Line one")
print("Line two")

# Same line using end=""
print("Loading", end="")
print("...", end="")
print(" done")

Line one
Line two
Loading... done

print("A", "B", "C", sep="|", end="!\n")
print("done")

Escape Sequences and Multi-Line Output

String literals in Python support escape sequences — special two-character combinations that start with a backslash and represent characters that would otherwise be difficult or impossible to type directly inside a string. Beginners encounter them constantly because print() uses them internally for its own defaults.

The two you will see most often are \n (newline) and \t (tab). They can appear anywhere inside a string passed to print().

# \n inserts a newline inside a string
print("Line one\nLine two\nLine three")

# \t inserts a tab stop
print("Name:\tJordan")
print("Score:\t98")

Line one
Line two
Line three
Name:	Jordan
Score:	98

Triple-Quoted Strings for Multi-Line Output

When you need to print a long block of text across multiple lines, embedding \n throughout a single string quickly becomes hard to read. Triple quotes — either """ or ''' — let you write the text exactly as it should appear, with real line breaks inside the string itself.

print("""Name:  Jordan
Score: 98
Grade: A""")

Name:  Jordan
Score: 98
Grade: A

Other String Formatting Methods

f-strings are the recommended approach for new Python code, but you will encounter two older formatting methods when reading existing code or third-party libraries. Knowing how they work prevents confusion when you see them in the wild.

str.format()

The str.format() method, introduced in Python 2.6 via PEP 3101, works by placing empty curly braces {} as placeholders inside a string, then passing the values to fill them in as arguments to .format(). Positional and named placeholders are both supported.

name = "Jordan"
score = 98

# Positional placeholders — filled in order
print("Name: {}, Score: {}".format(name, score))

# Named placeholders — order does not matter
print("Score: {s}, Name: {n}".format(n=name, s=score))

# Format spec works the same way as in f-strings
price = 49.99
print("Total: ${:.2f}".format(price))

Name: Jordan, Score: 98
Score: 98, Name: Jordan
Total: $49.99

The % Operator (Legacy)

Python's original string formatting method uses the % operator, inherited from C's printf and available since Python 1. You write format codes like %s (string) and %d (integer) inside a string, then provide the values after the % operator. You will encounter it in older code and tutorials.

name = "Jordan"
score = 98

# % formatting — two formats codes, two values in a tuple
print("Name: %s, Score: %d" % (name, score))

# Float with two decimal places
price = 49.99
print("Total: $%.2f" % price)

Name: Jordan, Score: 98
Total: $49.99

When using the + operator to build output strings, Python requires every value to already be a string. Passing an integer directly raises a TypeError. This is one of the first errors beginners encounter, and understanding why it happens makes it easy to fix.

age = 29

# This raises a TypeError — cannot concatenate str and int
print("Age: " + age)

# Fix 1: wrap the integer with str()
print("Age: " + str(age))

# Fix 2 (preferred): use an f-string instead
print(f"Age: {age}")

TypeError: can only concatenate str (not "int") to str
Age: 29
Age: 29

name = "Sam"
score = 42
print(f"Player: {name}, Score: {score * 2}")

Concatenating strings and variables with the + operator works but gets cluttered quickly. f-strings, introduced in Python 3.6, give you a cleaner syntax. Prefix a string literal with the letter f and place any variable name or expression inside curly braces. Python evaluates what is inside the braces and inserts the result into the string.

PEP 498, which introduced f-strings to Python 3.6, describes them as providing a concise, readable way to include the value of Python expressions inside strings — a design intent that also yields measurable performance improvements over older formatting methods. (Source: PEP 498, Python Software Foundation)

name = "Jordan"
score = 98

# Using + concatenation (works but messy)
print("Name: " + name + ", Score: " + str(score))

# Using an f-string (clean and readable)
print(f"Name: {name}, Score: {score}")

Name: Jordan, Score: 98
Name: Jordan, Score: 98

Expressions Inside f-Strings

The curly braces in an f-string accept any valid Python expression, not just variable names. You can perform arithmetic, call functions, or use conditional expressions directly inside the braces.

price = 49.99
quantity = 3

print(f"Total: ${price * quantity:.2f}")
print(f"Item count: {quantity}")
print(f"{'In stock' if quantity > 0 else 'Out of stock'}")

Total: $149.97
Item count: 3
In stock

price = 49.99
quantity = 3
print(f"{price=}")
print(f"{quantity=}")
print(f"{price * quantity=}")

price=49.99
quantity=3
price * quantity=149.97

import sys

# Both print the same text — print() uses stdout by default
print("Sent to stdout")
print("Also stdout", file=sys.stdout)

# This sends to stderr instead (used for error/diagnostic messages)
print("This is an error message", file=sys.stderr)

print(True, 0, 3.5, sep=" | ")

Python Output Summary Points

1. print() is a built-in function that sends values to stdout — the standard output stream — which appears as your terminal by default. No import is needed.
2. String literals passed to print() must be wrapped in single or double quotes. Variable names are passed without quotes. print() calls str() internally on every argument, which is why it can display integers and floats without raising a TypeError.
3. Multiple values separated by commas inside print() are joined with a space by default. sep is a keyword argument that replaces that space with any string you choose.
4. Each print() call appends a newline by default. end is a keyword argument that replaces the newline with any other string, including an empty string.
5. Escape sequences like \n (newline) and \t (tab) can appear anywhere inside a string to control layout. They are not print()-specific — the same sequences appear in file I/O, network output, and log messages. Triple-quoted strings (""") preserve real line breaks without any escape sequences.
6. f-strings (prefix f before the opening quote) are Python's string interpolation feature. Expressions inside curly braces are evaluated eagerly — at the moment the string is created — and the results are embedded in place. Any valid Python expression works inside the braces.
7. The :.2f syntax after a colon inside f-string braces is a format specification. It controls how the evaluated value is rendered as text (decimal places, padding, alignment).
8. str.format() is an older interpolation method you will encounter in existing code. Curly-brace placeholders are filled in by values passed to .format(). f-strings are preferred for new code — they are more readable and faster, because they are compiled into optimized bytecode at parse time rather than invoking a method call at runtime.
9. Python is strongly typed: it does not silently convert values in expressions. The + operator requires both sides to be the same type. Passing an integer without converting it first with str() raises a TypeError. f-strings and print() handle this conversion internally.
10. print() has a file keyword argument that accepts any file-like object. This lets you redirect output to sys.stderr for error messages, or to an open file handle. The three standard streams — stdin, stdout, stderr — are a universal operating system concept, not Python-specific.

With these tools and the mental model behind them, you can produce any output a beginner program requires. The concepts that appear here — keyword arguments, type conversion, standard streams, string interpolation — are not beginner scaffolding. They are the real mechanisms Python uses at every level of complexity.