python ACM模式的输入输出以及刷力扣的常用

1.Python的输入是字符串，所以要自己转类型
2.strip去掉左右两端的空白符，返回str
3.slipt把字符串按空白符拆开，返回[str]
4.map把list里面的值映射到指定类型，返回[type]

使用input

'''多行输入，指定行数'''

n, m = map(int, input().strip().split())#获取第一行，获取第二行可以再写一句同样的语句
#需要矩阵承接数据时
data = []
for i in range(n):
	tmp = list(map(int, input().split()))
	data.append(tmp)

'''多行输入，不指定行数'''
try:
	data = []
	while True:
		line = input().strip() #strip去除左右两边的空白符
		if line == ' ':
			break
		tmp = list(map(int, line.split())) #split按空白符拆开
		data.append(tmp)
expect:
	pass

使用sys.stdin.readline()

如果使用该语句，默认是读取的字符串+’\n’
为了去除末尾’\n’的影响，可以使用strip()
strip()用于去除字符串首尾的字符，默认是空格、\n、\t ，且只能去除首尾的

把input 换成sys.stdin.readline()

import sys
try:
    lis=[]
    while True:
        line=sys.stdin.readline().strip()
        if line =='':
            break
        lines=list(map(int,line.split()))
        lis.append(lines)
    print(lis)
except:
    pass

python做题常用

list

#初始化
l = [0] * len(array)
l=[]
lst.append(4)     # 添加元素
lst.pop()         # 删除末尾元素   
lst.pop([index])  #返回值：被移除的元素
lst.insert(i, x)  # 插入元素
lst.remove(2)     # 删除第一个匹配元素
lst.sort()        # 原地排序
lst.reverse()     # 反转列表
lst[1] = 20       # 直接修改元素



#从后往前访问
l[-1]表示最后一个数
for i in range(0, -10, -1)     #0, -1, -2, -3, -4, -5, -6, -7, -8, -9
for j in reversed(range(len(nums)-1)) #加一个reverse可以直接颠倒

#enumerate 枚举
l = ["a", "b", "c"]
for i, v in enumerate(l):
    print(i, v)
#0 a
#1 b
#2 c 

#map
#可以将参数一一映射来计算， 比如
date = "2019-8-15"
Y, M, D = map(int, date.split('-'))    #Y = 2019, M = 8, D = 15
#map返回的是迭代对象而不是一个列表，要转成列表要加list


#sort
1.调用sort()排序，不会产生新的列表。lst.sort()升序排序
降序排序lst.sort(reverse=True)  升序排序lst.sort()
2.使用内置函数sorted()排序，会产生新的列表对象
lst1=sorted(lst)升序排序   lst2=sorted(lst,reverse=True)降序排序
l1 = [(1,2), (0,1), (3,10) ]
l2 = sorted(l1, key=lambda x: x[0])#按照 tuple 的第一个元素进行排序key允许传入一个自定义参数
# l2 = [(0, 1), (1, 2), (3, 10)]
#排序默认从小到大。可以用reverse=True倒序

#列表生成式 
lst = [i*j for i in range(1,10)]
#lambda函数
lambda 参数列表: 表达式
add = lambda a, b: a + b



#ZIP
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)#[(1, 4), (2, 5), (3, 6)]
```keys(), values(), items()
这三个方法可以分别获得key, value, {key: value}的数组。

#max可以代替if来更新更大的数
maxnums=max(maxnums,tmp)

#多维数组
res = [[], []]
res[0].append()

#extend一次性添加多个元素
lst1.extend(lst2)
#insert在i位置添加x
lst.insert(i, x)
#赋值
注意原来已有列表，需要整体改变这个列表的值，替换为列表2的值，需要使用for循环一个一个赋值
此外，lst1=lst2是引用的复制（不是拷贝），操作lst1会改变lst2的值（指向同一个地址），为了不改变lst2的值，需要使用lst1=lst2[:]（创建新的列表，但是还是属于浅拷贝）
浅拷贝（共享嵌套对象的引用）：
lst_copy = lst.copy()  # 或 lst[:]	外层独立，嵌套对象共享
深拷贝（完全独立，需import copy）：
import copy
deep_copy = copy.deepcopy(lst)#如果列表中包含嵌套的可变对象（如列表、字典），需使用 copy.deepcopy() 实现完全独立

二维列表

ls = [] #二维列表新建可以直接建一个一维列表，后面直接append列表数据就可以了
ls_T = list(map(list, zip(*ls)))# 转置，用于取列元素
if 元素 in ls_T[0]: #判断是不是在0列里面
	j = ls_T[0].index(元素) #第0列中该元素的位置，即多少行
	
##矩阵转置
A = [[1,2,3],[4,5,6],[7,8,9]]
print(len(A)) #矩阵行数#
print(len(A[0])) #矩阵列数#
B = [[A[j][i] for j in range(len(A))] for i in range(len(A[0]))]
print(B)# 输出# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

	
#二维列表向左向右向上向下四个方向
DIRS=[[0,1],[1,0],[0,-1],[-1,0]]
#方法1
di=0
nx,ny=x+DIRS[di][0],y+DIRS[di][1]
传入di+1

#方法2
DIRS=[(0,1),(1,0),(0,-1),(-1,0)]
for dx,dy inDIRS:
      nx,ny=x+dx, y+dy

A = [[1,2,3],[4,5,6],[7,8,9]]
print(len(A)) #矩阵行数#print(len(A[0])) #矩阵列数#B = [[A[j][i] for j in range(len(A))] for i in range(len(A[0]))]print(B)# 输出# [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

remove()括号里面不是索引，是具体的数
Pop()括号里面是索引号，索引从1开始

string字符串

ord('a')# 返回单个字符的 unicode:
chr(100)# 返回'd'

#strip和split
'   spacious   '.strip()#strip()移除 string 前后的字符串，默认来移除空格
'1,2,3'.split(',') #['1', '2', '3'],按照某个字符串来切分，返回一个 list,
'1,2,3'.split(',', maxsplit=1)#['1', '2,3'],传入一个参数maxsplit来限定分离数

#将字符串和列表相互转换
字符串转换成列表，注意交换字符需要先转换成列表
#1.list
str1 = '12345'
list1 = list(str1)
print(list1) #['1', '2', '3', '4', '5']
#2.str.split()通过指定分隔符对字符串进行切片
str3 = 'this is string example'
list3 = str3.split('i', 1)
print(list3) #['th', 's is string example']

列表转换成字符串，join里面的可以是list、set
#1.split.join(str),split是指定的分隔符，str是要转换的字符串
list1 = ['1', '2', '3', '4', '5']
str1 = "".join(list1)#12345 

list3 = ['www', 'baidu', 'com']
str3 = ".".join(list3)#www.baidu.com

#是元音
def isVowel(ch:str) -> bool:
            return ch in "aeiouAEIOU"
isVowel(s[i])

deque双端队列

append，添加到末尾
appendleft, 添加到开头
pop, 剔除末尾
popleft，移除开头

set

里面元素不能重复

s.add(4)          # 添加元素
s.remove(2)       # 删除元素
s1 | s2           # 并集
s1 & s2           # 交集
s.discard(5)      # 安全删除（不报错）
add : set 的添加是 add 不是append，一次添加一个元素
update：一次添加多个元素

remove vs discard: 都是删除操作，都是删除指定值，区别在于remove不存在的元素会报错，discard不会。
pop：一次删除任意元素

union, intersection: 快速获得并集和交集，方便一些去重操作。
s1.intersection(s2)

用in 和 not in来判断

dict

字典，相当于其它语言中的map, hashtable, hashmap之类的

keys(), values(), items()这三个方法可以分别获得key, value, {key: value}的数组。

#遍历Key
for key in dict:
	print(key)

#遍历value:
for value in dict.values():

#遍历key，value
for key, value in dict.items():
my_dict = {'a': 3, 'b': 1, 'c': 2}

#字典按照值排序
items_list = list(my_dict.items())# 将字典的键值对转换为列表，元素形式为 (键, 值)
items_list.sort(key=lambda x: x[1],reverse=True)
sorted_dict = dict(items_list)# 再将排序后的列表转换回字典（注意，字典的顺序特性和原来有所不同）
print(sorted_dict)

#使用sorted
ls = sorted(dic, key=lambda key: dic[key], reverse=True) #输出的是键的列表

sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1]))#输出的是dict
print(sorted_dict)

元组

#取出元组的第0个元素作为列表
tuples_list = [('p', 8), ('q', 9), ('r', 10)]
k = 0  # 同样假设取第0个元素（即第一个元素）
result_list = list(map(lambda x: x[k], tuples_list))
print(result_list)

t.index(2)       # 查找元素索引
t.count(1)        # 统计元素出现次数
t + (4, 5)        # 拼接（返回新元组）

最大, 最小 number

在 python 中分别以 float(‘inf’) 和 float(‘-inf’)表示最大最小值

除法

>>> 3 / 2
1.5
>>> 3 // 2  整除
1

次方

>>> 2 ** 10
1024
pow(x,y)  x的y次方

三项表达式

res = a if condition else b

其它常用函数

round(x)：四舍五入
abs(x)/max()/min()：绝对值/最大值/最小值
range(start=0, stop, step=1])：返回一个可迭代对象，常用于for循环
pow(x, y, [z])：求幂函数x^y，运算完毕可以顺带对z取模
sorted(iterable, key, reverse)：采用Timsort的稳定排序算法，默认升序
int(x, base=10))/float()/str()：转整数(可自定义进制)/转浮点数/转字符串
bin()/oct()/hex()：10进制转二进制(返回0b开头的字符串)/10进制转八进制(返回0开头的字符串)/10进制转十六进制(返回0x开头的字符串)
ord()/chr()：字符转ASCII或ASCII转字符
math.gcd(x,y)：返回x和y的最大公约数

if ……elif……else注意不要用else if 

Counter

count:统计列表中某个元素出现的次数： print("l.count('d') -->", l.count('d'))
统计元素出现的频次，返回一个字典，使用.keys和.values来获取具体的值

from collections import Counter

list1 = ["a", "a", "a", "b", "c", "c", "f", "g", "g", "g", "f"]
dic = Counter(list1)
print(dic)
#结果:次数是从高到低的
#Counter({'a': 3, 'g': 3, 'c': 2, 'f': 2, 'b': 1})
print(dict(dic))
#结果:按字母顺序排序的
#{'a': 3, 'b': 1, 'c': 2, 'f': 2, 'g': 3}

print(dic.items()) #dic.items()获取字典的key和value
#结果:按字母顺序排序的
#dict_items([('a', 3), ('b', 1), ('c', 2), ('f', 2), ('g', 3)])

print(dic.keys())
#结果:
#dict_keys(['a', 'b', 'c', 'f', 'g'])
print(dic.values())
#结果：
#dict_values([3, 1, 2, 2, 3])

print(sorted(dic.items(), key=lambda s: (-s[1])))#默认升序，加负号变成降序
#结果:按统计次数降序排序
#[('a', 3), ('g', 3), ('c', 2), ('f', 2), ('b', 1)]

for i, v in dic.items():
    if v == 1:
        print(i)
#结果:
#b

Round

python3中round()对浮点数的取舍遵循的是四舍六入五平分 ，“五平分”就是根据取舍的位数前的小数奇偶性来判断，奇偶平分。奇数则舍弃，偶数则加一。

四舍五入：from decimal import Decimal
aa = Decimal('2.135').quantize(Decimal('0.00'))#2.14

其他刷题注意的

and or等前后顺序也会影响用例是否通过
可以用in / not in来判断列表、集合等数据结构中是否有某元素
input函数输入的是str类型，若是数，需要转化为int, int(input(‘’))
print(x, end="") end="" 可使输出不换行。

栈与队列

stack = []
stack.append()
stack.pop()

from collections import deque
queen = deque()
queen.append()
queen.popleft()#先入先出

二叉树

前中后遍历是根据根的位置来看的
深度优先搜索:根左右的遍历方式，先遍历一个分支。有点像递归，可以使用栈实现。
广度优先搜索:一层一层遍历，使用队列实现
二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存。

#链式存储二叉树的定义
class TreeNode:
    def __init__(self, val, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right
#通过列表创建二叉树
vals=[3,9,20,None,None,15,7]
def create_tree(vals, index=0):#需要索引定位位置
    if index >= len(vals) or vals[index] is None:
        return None
    root = TreeNode(vals[index])
    root.left = create_tree(vals, 2 * index + 1)
    root.right = create_tree(vals, 2 * index + 2)
    return root
root=create_tree(vals)
#root为二叉树结构