How to Fix EOFError in Python

A traceback pointing at `name = input()` can end with `EOFError: EOF when reading a line`. The fact that one read with no line waiting on stdin can trigger it makes me pause.

That location gives you a concrete way to separate a missing input line from a source-code problem. You’ll pin down what EOFError means in Python by looking at what the failed read expected.

What EOFError means in Python

EOFError means an operation reached the end of its input before it could return the value it requested. For input(), the Python reference says EOF raises the exception when the call has no line to return.

I got the exact message “EOFError: EOF when reading a line” by redirecting an empty file to input(). The failed call identifies stdin as the missing source. The main guard selects whether the entry-point code runs.

Pressing Enter gives input() an empty string. An empty stream has no line to return, so input() raises EOFError.

The if __name__ == ‘__main__’ guard decides whether the entry-point code runs during direct execution or import. An unclosed parenthesis or invalid indentation is a source error, reported as SyntaxError or IndentationError.

Python’s exception reference says text stream read() and readline() return an empty string at EOF. input() raises EOFError because it cannot return a line.

Check how your program receives input

input() reads one line from standard input, also called stdin.

• Run an interactive script in a terminal, then type one line for each input() call.
• For an online IDE or coding platform, add the expected lines to its stdin or input panel and follow the problem’s input format.
• For redirected input, check that the run configuration selects the intended file and that the file contains the records your program reads.

Each input() call consumes one line, so a later call reaches EOF when stdin supplies too few lines for the program’s read sequence.

AskPython’s input() tutorial covers prompts and converting returned text. For EOFError, check whether the process receives a line at all.

How to fix an input() EOFError

I reproduced the failure with empty stdin and got success after piping one name into the same guarded program.

Step 1, confirm stdin is empty

In a POSIX shell, create an empty file, then run the second command to reproduce the traceback without involving the main guard.

: > empty.txt
python3 -c "print(input())" < empty.txt

The call fails because the input file has no line to return. If the same code runs in an IDE, add the missing line to its input field. The main guard is separate from that field.

Step 2, provide the expected line

This small script reads one name and prints a greeting. The guard keeps main() from running on import, and input() reads from stdin when main() runs.

def main():
    print("Enter your name:")
    name = input()
    print(f"Hello, {name}!")


if __name__ == "__main__":
    main()

Pipe one line into the program from a POSIX shell, so the newline ends the line that input() reads.

printf 'Ada\n' | python3 ask_name.py

I got “Hello, Ada!” from that run. For an online runner, enter the same line in its stdin panel instead of using the shell pipe.

Step 3, choose a fallback only for optional input

If the value is optional, catch EOFError at that read and choose a deliberate default. Keep required data out of this fallback, because a made-up value can change the result.

print("Optional nickname:")
try:
    nickname = input()
except EOFError:
    nickname = ""

nickname = nickname.strip() or "friend"
print(f"Hello, {nickname}!")

Run it with no input to exercise the fallback. A blank line also becomes the default, because the code treats an empty string as missing.

python3 optional_name.py < empty.txt

For a required value, supply the missing line or stop with a clear error message, because a default would invent a value the program needs from input. Catching EOFError and continuing with invented data hides the input problem.

When the message says “Ran out of input”

EOFError: Ran out of input points to a read of serialized data, such as pickle.load(). The loader reaches the end before it can rebuild an object, so check the path and confirm the file was fully written or downloaded.

I reproduced “EOFError: Ran out of input” by passing the empty file to pickle.load().

python3 -c "import pickle; pickle.load(open('empty.txt', 'rb'))"

Python’s pickle documentation says to unpickle only trusted data. If your error comes from pandas read_pickle(), see AskPython’s pandas pickle-loading article for file and compatibility checks.

The main guard selects the entry point

The guard decides whether the entry-point block runs, and input() reads from the process’s stdin when that code calls it.

Python’s __main__ documentation describes the execution boundary. When a traceback points at input(), inspect how that process receives stdin before changing the guard.

Frequently asked questions