系列文章目录

---

前言

一、做题技巧

1、提高通过率原则：

1. 本地IDE调试代码速度更快；
2. 修改已>0%的代码比新做一道题更快；
3. 一定要看清题意；

2、提高通过率技巧：

1. 时间复杂度问题：

• 增加条件break或continue出循环，能break尽量break；
• 减少不必要的判断条件（比如在不在字典中）；
• 做一些排序来减少后期的工作量；

2. 空间复杂度问题：
3. 边界条件：某些数据是不是始终存在；

提示：测试用例通过但0%的原因：有可能没有理解题意。

二、主要函数

1、input()

1）input() Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
2）print() 用于打印输出，常用参数sep、end
3）print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

4）map() 根据提供的函数对指定序列做映射。返回列表或迭代器。
list() 用于将元组或字符串转换为列表。

map(function,iterable,…)会根据提供的函数对指定序列做映射，python2.x返回列表，python3.x返回迭代器。

5）split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串，返回分割后的字符串列表。
6）str.split(str=“”, num=string.count(str))

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。默认为 -1, 即分隔所有。

7）try:可能抛出异常的语句
8）except:捕获异常，处理异常

2、sys.stdout()与print()|sys.stdin与input

sys.stdout()与print()
当我们在python中打印对象调用print obj时候，事实上是调用了sys.stdout.write(obj+‘\n’)，print将我们需要的内容打印到了控制台，然后追加了一个换行符。

print会调用sys.stdout的write方法，以下两行在事实上等价：

import sys
sys.stdout.write('hello'+'\n')
print('hello')
1
2
3

输出：

hello
hello
1
2

sys.stdin与input
当我们用raw_input(‘input promption’)时，事实上是先把提示信息输出，然后捕获输入：

import sys

hi = input('Hello Python!')
print('Hello Python!',) # comma to stay in the same line
hi = sys.stdin.readline()[:-1] # -1用来丢弃最后的\n
1
2
3
4
5

输出：
Hello Python!
Hello Python!

3、从控制台重定向到文件

原始的sys.stdout指向控制台，如果把文件的对象的引用赋给sys.stdout,那么print调用的就是文件对象的write方法。

import sys
f_handler = open('out.log','w')
sys.stdout = f_handler
print('Hello Python!')
1
2
3
4

提示：
this Hello Python! can’t be viewed on concole;
this Hello Python! is in file out.log.

记住，如果，如果我们还想在控制台打印的话，要先将原始数据的控制台对象引用保存下来，向文件中打印之后再恢复sys.stdout.

4、同时重定向到控制台和文件

三、NC 输入与输出问题

1、字符串

单行：

import sys
line = sys.stdin.readline().strip()
print(line) # 输出为字符串

# 用input()也一样
line = input()
print(line) # 输出为字符串
1
2
3
4
5
6
7

多行：

import sys
if __name__ == '__main__':
    data = []

while True:
    line = sys.stdin.readline().strip() 
    if not line:
        break
    data.append(line)
print("".join(data))
1
2
3
4
5
6
7
8
9
10

1
2
3
4
5

12345
1
2
3
4
5
6
7

2、数字

num = int(input())
print(num) # 输出为数字
1
2

3、单行输入为数组

l = list(map(int,input().split(" ")))
print(l)
1
2

输入：
1 2 3 4
输出：
[1, 2, 3, 4]
1
2
3
4

4、输出形式为矩阵

import sys 
if __name__ == "__main__":
    data = []

while True:
    line = sys.stdin.readline().strip()
    if not line:
        break
    tmp = list(map(int,line.split(" ")))
    data.append(tmp)
print(data)
1
2
3
4
5
6
7
8
9
10
11

1 2 2
1 2 3
1 2 4

[[1, 2, 2], [1, 2, 3], [1, 2, 4]]
1
2
3
4
5

5、sys.stdin.readline()和input()区别

import sys

# input()方法：
str1 = input()
print('input 输入：',str1,'len = ',len(str1))
print('循环遍历输入得到输入的每个字符的ASCII码如下：')
for i in str1:
    print(ord(i))

#sys.stdin.readline()方法：
str2 = sys.stdin.readline()
print('sys.stdin.readlien() 输入：',str2,'len = ',len(str2))
print('循环遍历输入得到输入的每个字符的ASCII码如下：')
for i in str2:
    print(ord(i))
print('换行的ASCII码是',ord('\n'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

abc
input 输入： abc len =  3
循环遍历输入得到输入的每个字符的ASCII码如下：
97
98
99
abc
sys.stdin.readlien() 输入： abc
 len =  4
循环遍历输入得到输入的每个字符的ASCII码如下：
97
98
99
10
换行的ASCII码是 10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结论：如果上述代码想要固定输入数字，只需将input()和sys.stdin.readline()加上int()的限制，可知上面两种输入，sys.stdin.readline()方法会获取每行数据的最后的换行符。

6、sys.stdin.readline()和input() 输入一行数据，以空格分割，返回list

print('input()输入：')
list1 = [x for x in input().split()]
print(list1)

print('sys.stdin.readline()输入：')
import sys
list2 = [x for x in sys.stdin.readline().split()]
print(list2)
1
2
3
4
5
6
7
8

input()输入：
a b c
['a', 'b', 'c']
sys.stdin.readline()输入：
a b c
['a', 'b', 'c']
1
2
3
4
5
6

7、sys.stdin.readline()和input() 指定行数，输入多行数据，返回二维list

print('请输入数据的行数：')
N = int(input())
print('N=',N)
print('input()输入：')
list1 = [[x for x in input().split()] for y in range(N)]
print(list1)

print('sys.stdin.readline()输入：')
import sys
list2 = [[x for x in sys.stdin.readline().split()] for y in range(N)]
print(list2)
1
2
3
4
5
6
7
8
9
10
11

请输入数据的行数：
3
N= 3
input()输入：
1 2 3
4 5 6
7 8 9
[['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]
sys.stdin.readline()输入：
1 2 3
4 5 6
7 8 9
[['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9']]
1
2
3
4
5
6
7
8
9
10
11
12
13

8、sys.stdin.readline()和input() 不指定行数，输入多行数据，返回二维list

不指定输入的行数，但是必须以最后下一行只输入空格或者什么都不输入为结束

import sys
try:
    ssn = []
    while True:
        sn = sys.stdin.readline().strip()
        # 若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list
        if sn == '':
            break
        sn = list(sn.split())
        ssn.append(sn)
    print(ssn)
except:
    pass



import sys
try:
    ssn = []
    while True:
        sn = input().strip()
        # 若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list
        if sn == '':
            break
        sn = list(sn.split())
        ssn.append(sn)
    print(ssn)
except:
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

1 2 3
w e r
ss   ss    sss

[['1', '2', '3'], ['w', 'e', 'r'], ['ss', 'ss', 'sss']]
1 2 3
w e r
ss   ss    sss

[['1', '2', '3'], ['w', 'e', 'r'], ['ss', 'ss', 'sss']]
1
2
3
4
5
6
7
8
9
10

9、sys.stdin.readline()和input() 不指定行数，但是输入一行就处理一行，持续等待输入

import sys
try:
    while True:
        sn = input().strip()
        #sn = sys.stdin.readline().strip()
        # 若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list
        if sn == '':
            break
        sn = list(sn.split())
        print('此行输入为：',sn)
except:
    pass
1
2
3
4
5
6
7
8
9
10
11
12

1 2 3
此行输入为： ['1', '2', '3']
2 2 2
此行输入为： ['2', '2', '2']
3 4 5
此行输入为： ['3', '4', '5']
……
1
2
3
4
5
6
7

四、输入与输出集锦

1、多个字符串

m = [i for i in input().split()]
print(m)
1
2

输入：1,2,3,4
输出：['1,2,3,4']

输入：1 2 3 4
输出：['1', '2', '3', '4']
1
2
3
4
5

2、多行输入

m,n = list(map(int,input().split()))
lines = []
for _ in range(m):
    lines.append(list(map(int,input().split(' '))))
    #lines.append([int(x) for x in input().split()])
print(lines)
1
2
3
4
5
6

输入：
2 3
1 1 1
1 1 1
输出：
[[1, 1, 1], [1, 1, 1]]
1
2
3
4
5
6

3、未知行数，持续等待输入

代码1：

# 未知行数
res = []
while True:
    try:
        s = input()
        res.append(list(map(int,s.split(' '))))
        #res.append(s.split(' '))
    except:
        break
1
2
3
4
5
6
7
8
9

代码2：

import sys
for line in sys.stdin:
    #a = line.split()
    a = list(map(int,line.split()))
print(a[0]+a[1])

1
2
3
4
5
6

五、其它

1、常用数据结构

list和dict比较好用，不能导入numpy库
list：做整体的排序；
dict：做局部排序，

2、跳出输入循环

python中的input()函数在输入时，遇到回车符，那么一次输入就结束了，这不能满足多行文本并且行数也不确定的情况，当然输入空行也是允许的。

• 方法一：利用异常处理机制实现：

lines = []
while True:
    try:
        lines.append(input())
    except:
        break
print(lines)
1
2
3
4
5
6
7

输出：

xz
zw
yq
ruozhu
qingcheng
chuanmu
^Z
['xz', 'zw', 'yq', 'ruozhu', 'qingcheng', 'chuanmu']
1
2
3
4
5
6
7
8

在集成开发环境中运行时，请按ctrl+D组合键结束多行输入：
实际运行时，可以输入多行，当输入最后一行并回车后，按组合键Ctrl+D，表示EOF，即End of File,文件尾的意思。此时，input()函数会遇到EOF异常，python的异常处理机制将捕获到此异常，执行except部分语句，break跳出循环。
在Windows命令行下用"python 源代码文件名.py”方式运行时，请按ctrl+Z组合键结束多行输入

• 方法二：利用标准输入文件对象sys.stdin的readlines()函数实现：

因为键盘是标准输入设备，计算机操作系统将键盘也是当做文件来对待的，其实计算机操作系统将包括键盘，显示器，鼠标等外部设备都当做文件对待，python中与键盘对应的文件对象时sys.stdin，因此，可以利用sys.stdin.readlines()函数来实现读取多行文本，一直遇到EOF为止。

import sys
lines = sys.stdin.readlines()
print(lines)
1
2
3

输出：

xz
zw
yq
ruozhu
qingcheng
chuanmu
^Z
['xz\n', 'zw\n', 'yq\n', 'ruozhu\n', 'qingcheng\n', 'chuanmu\n']
1
2
3
4
5
6
7
8

可以看出，方式二与方式一的输出差别在于每行末尾有\n符，即回车符。

---

总结

分享：
沉默给人以缜密的思考，清醒的意识，安定的内心，能培养一种自省的气质。不事张扬，踏实做事，这种沉默是一种迅速成长的修炼。一个多思少说又比较深沉的人，往往才是真正的大智之人。