Python Input Methods for Competitive Programming

Python is generally slower than C++ or Java, but choosing the right input method helps reduce time and avoid errors. Below, we’ll look at the most common input techniques in Python, when to use them, and their pros and cons.

Example Problem 

Let’s consider a problem: Find the sum of N numbers entered by the user.

Example

Input: 5
1 2 3 4 5
Output: 15

We’ll now explore different input methods in Python that can help solve such problems efficiently.

Different Input Methods

Below are the main ways to take input in Python, Let’s go through them one by one.

1. Normal Method

This is the simplest and most commonly used method using input() for taking input and print() for displaying output.

• input() always reads input as a string, so we need to typecast it (e.g., to int).
• For arrays/lists, we can use split() and map() to convert them into integers.
• It works fine for small inputs, but it is slow for large inputs, which is why competitive programmers prefer other methods.

Example: This code takes n as the number of inputs, then reads n integers, sums them up and prints the result.

n = int(input())
arr = [int(x) for x in input().split()]
summation = 0
for x in arr:
    summation += x
print(summation)

Explanation:

• first line n = int(input()) takes the number of elements.
• second line reads the elements as space-separated integers.
• loop calculates the sum and finally, print() displays the result.

2. Faster Method Using stdin and stdout

Python’s sys.stdin and sys.stdout are much faster than input() and print().

• stdin.readline() reads input directly from the input buffer.
• stdout.write() outputs results faster because it avoids the formatting overhead of print().

This method is widely used in competitive programming for speed optimization.

Example: This program reads input using stdin.readline(), computes the sum of numbers and prints it using stdout.write().

from sys import stdin, stdout 
def main():
    n = int(stdin.readline())
    arr = [int(x) for x in stdin.readline().split()]
    summation = sum(arr)
    stdout.write(str(summation))

if __name__ == "__main__":
    main()

Explanation:

• stdin.readline() reads input as raw text much faster.
• stdout.write() avoids extra formatting overhead of print().

Timing comparison (100k lines each):

• print(): 6.040s
• Writing to file: 0.122s
• stdout.write(): 0.121s

Clearly, stdin + stdout is much faster.

3. Taking User Input in Separate Variables

Sometimes, we need to unpack multiple values directly into separate variables. For example, if input is:

5 7 19 20

We want:

a = 5
b = 7
c = 19
d = 20

Instead of writing parsing code repeatedly, we can create a helper function.

Example: This function reads a line of space-separated integers and unpacks them into variables.

import sys
def get_ints(): 
    return map(int, sys.stdin.readline().strip().split())
a, b, c, d = get_ints()

Explanation: get_ints() uses map(int, split()) to convert input into integers. The values are directly assigned to variables in one line.

4. Taking User Inputs as a List of Integers

When you want the entire line of numbers stored in a list, you can use another helper function. For example, input:

1 2 3 4 5 6 7 8

We want:

Arr = [1, 2, 3, 4, 5, 6, 7, 8]

Example: This program reads integers from a single line and stores them in a list.

import sys
def get_list(): 
    return list(map(int, sys.stdin.readline().strip().split()))
Arr = get_list()

Explanation: map(int, split()) converts all numbers to integers. Wrapping it in list() gives us a proper list. Now Arr holds all the integers as a list.

5. Taking String Input Efficiently

Sometimes, instead of numbers, we just need a string input. For example:

GeeksforGeeks is the best platform to practice Coding.

We want:

string = "GeeksforGeeks if the best platform to practice coding."

Example: This function reads a line of text input as a string.

import sys
def get_string(): 
    return sys.stdin.readline().strip()
string = get_string()

Explanation: sys.stdin.readline() reads the entire line. .strip() removes trailing newlines. The result is stored as a plain string.

6. Adding a buffered pipe io (Python 2.7) 

When inputs/outputs are very large, even sys.stdin may not be enough. In such cases, we can use a buffered pipe (io.BytesIO) to further speed up I/O. This is more advanced and usually required only for problems with huge input sizes (2MB+ files).

Example: This program uses a buffer to speed up output operations.

import atexit, io, sys

# A buffer for output
buffer = io.BytesIO()
sys.stdout = buffer

# Print via buffer
@atexit.register
def write():
    sys.__stdout__.write(buffer.getvalue())

#####################################
# Example program
n = int(input())
arr = [int(x) for x in input().split()]
summation = sum(arr)
print(summation)

Explanation: Output is written into an in-memory buffer instead of directly printing. At program exit, atexit.register writes all data at once. This reduces the overhead of multiple print() calls.