Métodos de entrada de Python para la programación competitiva

Python es un lenguaje increíblemente fácil de usar con el único defecto de ser lento. En comparación con C, C++ y Java, es bastante más lento. Plataformas de codificación en línea, si el límite de C/C++ proporcionado es X . Por lo general, en Java, el tiempo proporcionado es 2X y Python, es 5X .
Para mejorar la velocidad de ejecución del código para problemas intensivos de entrada/salida, los lenguajes tienen varios procedimientos de entrada y salida.
 

Un problema de ejemplo: 
considere la cuestión de encontrar la suma de N números ingresados ​​por el usuario. 
Ingrese un número N . 
Los números de entrada N están separados por un solo espacio en una línea. 
 

Ejemplos: 

Input : 
5
1 2 3 4 5
Output :
15

Diferentes soluciones de Python para el problema anterior: 

Método normal Python: (Python 2.7) 
1. raw_input() toma un argumento de solicitud opcional. También elimina el carácter de nueva línea final de la string que devuelve. 
2. print es solo un envoltorio delgado que formatea las entradas (espacio entre argumentos y nueva línea al final) y llama a la función de escritura de un objeto dado. 
 

# basic method of input output
# input N
n = int(input())
 
# input the array
arr = [int(x) for x in input().split()]
 
# initialize variable
summation = 0
 
# calculate sum
for x in arr:
    summation += x
     
# print answer
print(summation)

Un método un poco más rápido usando stdin incorporado, stdout: (Python 2.7) 
1. sys.stdin por otro lado es un objeto de archivo . Es como crear cualquier otro objeto de archivo que se pueda crear para leer la entrada del archivo. En este caso, el archivo será un búfer de entrada estándar. 
2. stdout.write(‘D\n’) es más rápido que print ‘D’ . 
3. Incluso más rápido es escribir todo una vez con stdout.write(“”.join(list-comprehension)) pero esto hace que el uso de la memoria dependa del tamaño de la entrada. 
 

# import inbuilt standard input output
from sys import stdin, stdout
 
# suppose a function called main() and
# all the operations are performed
def main():
 
    # input via readline method
    n = stdin.readline()
 
    # array input similar method
    arr = [int(x) for x in stdin.readline().split()]
 
    #initialize variable
    summation = 0
     
    # calculate sum
    for x in arr:
        summation += x
 
    # could use inbuilt summation = sum(arr)
 
    # print answer via write
    # write method writes only
    # string operations
    # so we need to convert any
    # data into string for input
    stdout.write(str(summation))
 
# call the main method
if __name__ == "__main__":
    main()   

La diferencia de tiempo: 
 

Resumen de tiempos (100k líneas cada uno) 
——————————– 
Imprimir: 6,040 s 
Escribir en archivo: 0,122 s 
Imprimir con salida estándar: 0,121 s

Como hemos visto hasta ahora, tomar entradas del sistema estándar y dar salida al sistema estándar siempre es una buena idea para mejorar la eficiencia del código, que siempre es una necesidad en la programación competitiva. ¡Pero espera! ¿Te gustaría escribir estas largas líneas cada vez que las necesitas? Entonces, ¿cuál es el beneficio de usar Python? 
Vamos a discutir la solución a este problema. Lo que podemos hacer es crear funciones separadas para tomar entradas de varios tipos y simplemente llamarlas cuando las necesite. 
 

Cuando desea tomar la entrada de números enteros particulares de números enteros dados en una sola línea

Supongamos que la entrada es de la siguiente forma 
 

5 7 19 20

y queremos variables separadas para hacer referencia a ellos. lo que queremos es: 
 

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

entonces, podemos crear una función llamada get_ints() de la siguiente manera: 
 

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

Ahora no tienes que escribir esta línea una y otra vez. Solo tiene que llamar a la función get_ints() para recibir información en este formulario. En la función get_ints estamos usando la función map .

Cuando desea tomar la entrada de la lista de enteros dados en una sola línea

Supongamos que la entrada es de la siguiente forma
 

1 2 3 4 5 6 7 8

y queremos que una sola variable contenga la lista completa de enteros. Lo que queremos es: 
 

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

Entonces, aquí crearemos una función llamada get_list() de la siguiente manera: 
 

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

Ahora no tienes que escribir esta línea una y otra vez. Solo tiene que llamar a la función get_ints() para recibir información en este formulario
 

Cuando quieras tomar entrada de string

Supongamos que la entrada es de la siguiente forma 
 

GeeksforGeeks is the best platform to practice Coding.

y queremos que una sola variable de referencia contenga esta string. Lo que queremos es: 
 

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

Entonces, aquí crearemos una función llamada get_string() de la siguiente manera: 

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

Ahora no tienes que escribir esta línea una y otra vez. Solo tiene que llamar a la función get_string() para tomar la entrada de esta forma
Agregar una canalización almacenada en búfer io: (Python 2.7) 
1. Simplemente, agregue el código de E/S almacenado en búfer antes de su código de envío para que la salida sea más rápida. 
2. El beneficio de los objetos io.BytesIO es que implementan una interfaz común (comúnmente conocida como objeto ‘similar a un archivo’). Los objetos BytesIO tienen un puntero interno y para cada llamada a read(n) el puntero avanza. 
3. El módulo atexit proporciona una interfaz simple para registrar funciones que se llamarán cuando un programa se cierre normalmente. el sistemaEl módulo también proporciona un enlace, sys.exitfunc, pero solo se puede registrar una función allí. El registro atexit puede ser utilizado por múltiples módulos y bibliotecas simultáneamente. 
 

# template begins
#####################################
 
# import libraries for input/ output handling
# on generic level
import atexit, io, sys
 
# A stream implementation using an in-memory bytes
# buffer. It inherits BufferedIOBase.
buffer = io.BytesIO()
sys.stdout = buffer
 
# print via here
@atexit.register
def write():
    sys.stdout.write(buffer.getvalue())
 
#####################################
# template ends
 
# normal method followed
# input N
n = int(input())
 
# input the array
arr = [int(x) for x in input().split()]
 
# initialize variable
summation = 0
 
# calculate sum
for x in arr:
    summation += x
 
# print answer
print(summation)

Aunque normalmente se maneja una gran cantidad de datos, el método normal no se ejecuta dentro del límite de tiempo. El método 2 ayuda a mantener una gran cantidad de datos de E/S. El método 3 es el más rápido. Por lo general, el manejo de archivos de datos de entrada de más de 2 o 3 MB se ayuda a través de los métodos 2 y 3.
Nota: los códigos mencionados anteriormente están en Python 2.7, para usar en las versiones de Python 3.X. Simplemente reemplace raw_input() con la sintaxis input() de Python 3.X. El descanso debería funcionar bien.
Referencias: 
1. Más información sobre la entrada en Python 2.7 
2. Salida a través de la biblioteca sys y otros comandos.  
3. Entrada a través de la biblioteca sys y otros comandos.  
4. Documentos del módulo Python atexit.
Este artículo es aportado porShubham Saxena . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.