Input and output: print(), input() and stdin

Every program talks to the outside world through three standard streams. It reads from standard input, writes its results to standard output, and writes error messages to standard error. In a terminal all three are connected to the terminal itself, but the shell can connect them to files or to other programs, and that is how online judges and coding tests feed a program its data and collect its answer.

Writing output with print()

print() writes its arguments to standard output, turning each into text with str(). Four keyword arguments change what it writes and where:

import sys

# By default print() puts a space between values and a line break at the end.
print("tea", "coffee", "juice")
print("tea", "coffee", "juice", sep=", ")
print("tea", "coffee", "juice", sep="")

# end replaces the line break, so the next print() carries on the same line;
# flush=True writes "Saving" out at once instead of keeping it in the buffer.
print("Saving", end="", flush=True)
print("...", end=" ")
print("done")

# Values of any type are written with str(); print() on its own writes an empty line.
print(42, 2.5, True, None, [1, 2])
print()

# file=sys.stderr sends a message to standard error instead of standard output.
print("warning: the price list is empty", file=sys.stderr)

tea coffee juice
tea, coffee, juice
teacoffeejuice
Saving... done
42 2.5 True None [1, 2]

warning: the price list is empty

• sep goes between the values (a space unless you say otherwise), and sep="" glues them together.
• end is written after the last value (a line break unless you say otherwise). end="" or end=" " lets the next print() carry on the same line.
• file=sys.stderr sends the text to standard error. The output above shows it under its own label: error messages stay visible on the screen even when a user saves the normal output in a file with > results.txt, and they do not end up mixed with the results.
• flush=True makes Python write the text at once, as the program does for “Saving”. Output is normally collected in a buffer first: a line at a time in a terminal, and in larger pieces when it goes to a file or a pipe. So a progress message printed with end="" may appear late unless you add flush=True, as in print("Working…", end="", flush=True), and lines on standard output and standard error can come out in a different order from the one the program wrote them in.

Commas in a print() call are often all you need to join values: print("Total:", 5) works where print("Total: " + 5) raises TypeError, because + cannot add a number to a string. An f-string gives you full control over the layout.

Reading a line with input()

input() waits for one line of input and returns it as a string, without the line break at the end. With an argument, it first writes that prompt to standard output, without a line break. Whatever the user types is text, even 29, so a number must be converted, and the conversion must be checked, because people mistype:

name = input("Your name: ").strip()

# Ask again until the answer is a whole number.
while True:
    text = input("Your age: ")
    try:
        age = int(text)
        break
    except ValueError:
        print(f"{text!r} is not a whole number, try again.")

print(f"Hello, {name}! Next year you will be {age + 1}.")

Kavya
twenty
 29

Your name: Your age: 'twenty' is not a whole number, try again.
Your age: Hello, Kavya! Next year you will be 30.

• .strip() removes spaces the user typed by accident. int() ignores spaces and a line break around the digits by itself, so " 29" is read as 29.
• int(text) raises ValueError for text that is not a whole number, such as "twenty". The try block catches it, explains the problem and asks again; the while True loop (the control-flow lessons cover loops) ends with break once a number has been read.
• The output looks run together because the answers came from the input shown above it, not from a keyboard: input() writes each prompt and then reads a line without printing it. In a terminal, the user’s typing is shown by the terminal itself, so each answer appears after its prompt.

When the input runs out

When there is nothing left to read, input() raises EOFError (EOF is short for end of file):

first = input()
print("Read:", first)

# There is no second line, so input() raises EOFError.
second = input()
print("Read:", second)

first line

Read: first line

Traceback (most recent call last):
  File "end_of_input.py", line 5, in <module>
    second = input()
EOFError: EOF when reading a line

When you type the input in a terminal, you end it by pressing Ctrl-D (macOS and Linux) or Ctrl-Z followed by Enter (Windows). A program that reads until the end of its input should not count on a fixed number of input() calls; the next section shows the usual ways.

Reading many lines: judge-style input

Online judges and coding tests give a program all of its input on standard input and compare what it prints with the expected answer. Two patterns cover most problems. The first reads everything at once:

import sys

# Read everything at once and split it into words, whatever the line breaks.
words = sys.stdin.read().split()
total = 0
for word in words:
    total += int(word)
print(len(words), "numbers, total", total)

5
10 20
  30 40   50

6 numbers, total 155

sys.stdin.read() returns the whole input as one string, and split() cuts it into words on spaces and line breaks alike, so the program does not care how the numbers are spread over lines. The second pattern goes line by line:

import sys

# A for loop over sys.stdin reads one line at a time and stops at the end of the input.
for line in sys.stdin:
    print(repr(line), "->", line.rstrip("\n").upper())

# readline() returns "" once the input has run out, instead of raising EOFError.
print(repr(sys.stdin.readline()))

tea
chai latte

'tea\n' -> TEA
'chai latte\n' -> CHAI LATTE
''

A for loop over sys.stdin gets one line per turn, each with its "\n" still on the end (which is what repr() makes visible; only the last line can lack it, when the input does not end with a line break), and stops when the input ends, without an EOFError. sys.stdin.readline() reads a single line and returns an empty string once there is nothing left. On your own computer, you can feed a program a whole file exactly as a judge does: python3 solve.py < input.txt (py solve.py < input.txt in the Windows Command Prompt). PowerShell has no < for input, so there you pipe the file in instead: Get-Content input.txt | py solve.py.

Never eval() what a user types

eval(text) runs text as a Python expression. You may see eval(input()) used to read a number or a list, but it runs anything the user types, and an expression can import modules, read files and delete them. Convert numbers with int() or float(), which accept numbers and nothing else.

For text that holds a Python literal, such as a list or a dictionary, ast.literal_eval() reads the value and refuses anything that would run code:

import ast

# literal_eval() reads Python literals (numbers, strings, lists, dictionaries …) and nothing else.
print(ast.literal_eval("[3, 1, 2]"))
print(ast.literal_eval("{'tea': 20, 'coffee': 30}"))

# Anything that would run code is refused, where eval() would have run it.
try:
    ast.literal_eval("__import__('os').getcwd()")
except ValueError as error:
    print("refused:", type(error).__name__)

[3, 1, 2]
{'tea': 20, 'coffee': 30}
refused: ValueError

Key takeaways

• print() writes to standard output; sep goes between values, end after them, file=sys.stderr sends error messages to standard error and flush=True writes at once.
• input() returns a string without the line break; convert it with int() or float() inside try and handle ValueError.
• At the end of the input, input() raises EOFError, while a loop over sys.stdin simply stops.
• For judge-style input, sys.stdin.read().split() reads every value at once, and a for loop over sys.stdin reads line by line.
• Never pass user input to eval(). Convert numbers with int() or float(), and keep ast.literal_eval() for literals from a source you trust.