用于竞争性编程的Python输入法

令人难以置信的用户友好的Python语言的唯一缺点是它的速度很慢。它比C、C++和Java.平台的在线编程慢得多，如果C/C++的极限是X，通常情况下，Python提供的时间比Java多5倍。

语言提供各种输入和输出过程，以加快需要大量输入和输出的问题的代码执行速度。

一个典型的例子

考虑一个查询，要求获得N个用户输入的数字的总和。

输入数值N。

N个整数被输入，在一行中用一个空格隔开。

输入。

4
1 2 3 4

输出

各种Python解决问题的方法

正常做法 Python：(Python 2.7) (Python 2.7)

prompt参数对于raw input()来说是可选的。它产生的字符串也没有最后的换行符。
当print用于格式化输入时，会调用特定对象的写作函数(放在args之间，相对来说，在最后更近一些)。

# simple input-output technique # input N
a = int(input())
# input up the array
Array = [int(x) for x in input().split()]
# initialize of the variable
Sum= = 0
# calculating sum
for x in array:
    sum += x
# print the result
print(sum)

输出

3
1 2 3
6

一个利用内置stdin和stdout的更快的技术。2.7 Python

另一方面， sys.stdin 是一个文件对象。为了接收来自文件的输入，它的工作方式与构造任何其他文件对象一样。本例中的文件将是一个典型的输入缓冲区。
stdout.write(‘Dn’) 比print’D’执行得更快。
一次性将所有内容写到stdout甚至更快。

write(“”.join(list-comprehension))然而，这取决于内存利用率方面的输入大小。

# import up the inbuilt standard input output
from sys import stdin, stdout
# Suppose that in a function called main(), all operations are carried out.
def main():
    # input given via readline method
    z = stdin.readline()
    # array input similar method
    Arr1 = [int(x) for x in stdin.readline().split()]
    #initializing the variable
    sum= 0
    # calculating the  sum
    for x in arr1:
        sum += x
    # could use the built-in summation = sum(arr) 
# to display the result, but the write method only allows string operations, 
#so we must convert any input data into strings.
    stdout.write(str(sum))
# call up the main method
if __name__ == "__main__":
    main()

输出

The time difference:
timing overview (100k lines each)
??????????-
Print: 6.04 s
Write time: 0.122 seconds
Print in 0.121 seconds using Stdout

正如我们到目前为止所看到的，为了提高代码的效率，从正常系统中获取数据并给标准系统输入总是一个好主意，这在竞争性编程中总是必要的。不过，你希望每次需要时都写这些冗长的段落吗？那么，使用Python有什么好处呢。

让我们来谈谈如何解决这个问题。我们可以做到的是制作不同的函数，接受不同类型的输入，并根据需要调用它们。

当你希望接受包含特定数量的数字的单行输入时

让我们假设输入有以下格式。

6 7 18 22

而我们希望用不同的变量来指代它们。我们所希望的是

a = 6
 b = 7
c = 18
d = 22

因此，下面是如何编写一个名为get ints()的方法。

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

我们不再需要重复输入这一行。为了接受这种形式的输入，你只需要调用get ints()函数。map函数在get ints方法中被利用。

当我们想接受一个在单行上提供的整数列表的输入时

让我们假设输入的格式如下。

1 2 3 4 5

而我们希望整个整数列表包含在一个单一的变量中。我们所希望的是

Arr = [1, 2, 3, 4 ]

因此，我们将做以下工作，构建一个名为get_list()的函数。

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

你不再需要重复输入这一行。要接受这种格式的输入，你只需要调用 get ints () 函数。

当你希望接受一个字符串输入时

让我们假设输入的格式如下。

Javatpoint is the best platform to practice coding.

而我们希望这个字符串被存储在一个单一的引用变量中。我们所希望的是

string=" Javatpoint is the best platform to practice coding".

因此，我们将做以下工作，构建一个名为get string()的函数。

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

你不再需要重复输入这一行。接受这种格式的输入只需要调用 get string () 函数。

增加了一个缓冲的管道io：2.7 Python

为了使输出更快，只需在提交代码前放置缓冲的IO代码。
io。Bytes IO对象的优点是实现了一个标准接口，也被称为 “类文件 “对象。每次在Bytes IO对象上调用read(n)时，内部指针会前进。
当注册程序正常关闭时要调用的方法时，atexit模块提供了一个直接的接口。sys模块同样提供了一个名为sys.exitfunc的钩子，但那里只能注册一个函数。使用atexit注册表。

#Starts with 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# Import libraries for managing input and output
# On a general scale
import atexit, io, sys
# A stream implementation using an in-memory bytes
# buffer. It inherits BufferedIOBase.
Buffer_in = io.BytesIO()
sys.stdout = buffer
# Printing this page
@atexit.register
def write():
    sys.stdout.write(buffer.getvalue())
# # # ## # # # # # # ## # # # # # # # # # # # # # # # # # # # # # # # #
# template ends with
# standard procedure followed
# enter N
n = int(input())
# enter an array
arr = [int(x) for x in input().split()]
# create a variable
sum = 0
# calculating the sum
for x in arr:
    sum += x
# print response
Print(sum)

在处理大量数据时，标准方法经常会耗尽时间。维护大量的I/O数据，方法2更容易。最快的方法是3。通常情况下，程序2和3对处理大于2或3MB的输入数据文件有帮助。

对于在Python 3.X版本中的使用，请注意上面显示的代码是在Python 2.7中。只需使用Python 3.X中的输入()语法，而不是原始输入()。剩下的应该是有效的。

Reload(module)

重新加载一个之前被导入的模块。由于参数是一个模块对象，它必须已经被成功导入。如果我们使用外部编辑器改变了模块的数据源，并想在离开 Python 解释器时测试升级后的版本，这很有用。模块对象是返回值（与模块参数相同）。

Reload(module) 在以下情况下被调用。

为了定义一组新的对象，这些对象与模块字典中的名字相联系，Python 模块的代码被反向工程，以及再次执行模块级代码。扩展模块不对 init 函数进行第二次调用。
旧的对象，像所有其它的 Python 对象一样，只有在它们的引用计数达到零时才会被回收。
任何新的或修改过的对象都被模块命名空间中更新的标识符所引用。
为了引用一个新的对象，对旧的人工制品的进一步引用 (比如模块外的名字) 必须在它们出现的地方对每个名字空间进行修改。

一个模块的字典，包含了该模块的全局变量，当模块被重新加载时，它被保留下来。这通常不是一个问题，因为对名字的重新解释将优先于以前的定义。如果一个模块的新版本并没有真正定义一个已经被前一版本定义的名字，那么先前的定义将被保留。