Python手撕常用模版

标准输出

a = 10

# 输出：10
print(a)

# 串联输出（通过字符串拼接或逗号分隔）
# 输出：Hello, World!
print("Hello" + ", " + "World!")
# 使用 sep 指定分隔符
print("Hello", "World!", sep=", ")

s = "abc"
# 输出：abc 10
print(s, a)

# 格式化输出
# 输出：abc 10
print(f"{s} {a}")

# print默认会添加末尾换行符，可使用end=""来消除
print(f"{s} {a}", end = "")

标准输入（ACM模式）

一般读入（stdin/input）

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

# while input()!= None:
while True:
    try:
        a=int(input().split(" ")[0])
        b=int(input().split(" ")[-1])
        # 或写为 a,b=map(int,input().split())
        print(a+b)
    except:
        break

读取多行输入且第一行为行数(即固定行数)

if __name__ == '__main__':
    n = input()  # 获取行数
    for _ in range(n)  # 从第二行开始获取内容并根据题目来操作
        # 这里我直接把输入转为数组
        print(list(map(int, input().split())))

读取多行输入但不知有多少行(以读入空行且是空字符串结束)

if __name__ == '__main__':
    # 以读入空行为结束
    arr = []
    for line in iter(input,''):
        arr.append(line.split())
    print(arr)

读取多行输入但不知有多少行(以读入空行结束)

if __name__ == '__main__':
    try:
        arr = []
        while True:
            str_input = input().strip()   # 这样即使遇到空行 也会转为空字符串 就是与上一个结束情况不同的地方所在
            if str_input == '':
                break
            arr.append(str_input.split())
        print(arr)
    except:
        pass

列表List

初始化

# 初始化一个空列表
nums = []

# 初始化一个包含元素 1, 3, 5 的列表
nums = [1, 3, 5]

# 初始化大小为 n，元素都为0的列表
n = 10
nums = [0] * n

# 二维列表，m 行 n 列，元素都为 1
m, n = 3, 4
matrix = [[1] * n for _ in range(m)]

常见方法

lst = [0] * 10

# 输出：False
print(len(lst) == 0)
# 输出：10
print(len(lst))
lst.append(4)     # 添加元素
lst.pop()         # 删除末尾元素   
lst.pop([index])  # 返回值：被移除的元素
lst.insert(i, x)  # 插入元素（在i位置添加x）
lst.extend(lst1)  # extend一次性添加多个元素
lst.remove(2)     # 删除第一个匹配元素
lst.sort()        # 原地排序
lst.reverse()     # 反转列表
lst[1] = 20       # 直接修改元素

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

# enumerate 枚举
lst = ["a", "b", "c"]
for i, v in enumerate(lst):
    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(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)

# 赋值：注意原来已有列表，需要整体改变这个列表的值，替换为列表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 in DIRS:
      nx,ny = x+ dx, y + dy

字符串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

双端队列Deque

from collections import deque

# 初始化双端队列
lst = deque([1, 2, 3, 4, 5])

# 检查是否为空，输出：False
print(len(lst) == 0)

# 获取大小，输出：5
print(len(lst))

# 在头部插入 0，尾部插入 6
lst.appendleft(0)
lst.append(6)

# 获取头部和尾部元素，输出：0 6
print(lst[0], lst[-1])

# 删除头部和尾部元素
lst.popleft()
lst.pop()

# 在索引 2 处插入 99
lst.insert(2, 99)

# 删除索引 1 处的元素
del lst[1]

# 遍历双端队列
# 输出：1 99 3 4 5
for val in lst:
    print(val, end=" ")
print()

队列Queue

from collections import deque

# 初始化队列
q = deque()

# 向队尾插入元素
q.append(10)
q.append(20)
q.append(30)

# 是否为空，输出：False
print(len(q) == 0)

# 大小，输出：3
print(len(q))

# 获取队头元素，不出队，输出：10
print(q[0])

# 队头元素出队
q.popleft()

# 新的队头元素，输出：20
print(q[0])

栈Stack

# 使用 list 作为栈
s = []

# 压栈
s.append(10)
s.append(20)
s.append(30)

# 是否为空，输出：False
print(len(s) == 0)

# 大小，输出：3
print(len(s))

# 栈顶元素，输出：30
print(s[-1])

# 出栈
s.pop()

# 新的栈顶元素，输出：20
print(s[-1])

字典Dict

# 初始化字典
hashmap = {1: "one", 2: "two", 3: "three"}

# 是否为空，输出：False
print(len(hashmap) == 0)

# 大小，输出：3
print(len(hashmap))

# 查找键
# 输出：Key 2 -> two
if 2 in hashmap:
    print(f"Key 2 -> {hashmap[2]}")
else:
    print("Key 2 not found.")

# 获取键对应的值，不存在则返回 None
# 输出：None
print(hashmap.get(4))

# 插入新键值对
hashmap[4] = "four"

# 获取新插入的值，输出：four
print(hashmap[4])

# 删除键 3
del hashmap[3]

# 检查删除后
if 3 in hashmap:
    print(f"Key 3 -> {hashmap[3]}")
else:
    print("Key 3 not found.")
# 输出：Key 3 not found.

# 遍历字典
# 输出：
# 1 -> one
# 2 -> two
# 4 -> four
for k, v in hashmap.items():
    print(f"{k} -> {v}")

集合Set

# 初始化集合
hashset = {1, 2, 3, 4}

# 是否为空，输出：False
print(len(hashset) == 0)

# 大小，输出：4
print(len(hashset))

# 查找元素
if 3 in hashset:
    print("Element 3 found.")
else:
    print("Element 3 not found.")
# 输出：Element 3 found.

# 插入新元素
hashset.add(5)

# 删除元素 2
hashset.discard(2)  # discard 不存在的元素不会报错

# 检查删除后
if 2 in hashset:
    print("Element 2 found.")
else:
    print("Element 2 not found.")
# 输出：Element 2 not found.

# 遍历集合，输出：
# 1
# 3
# 4
# 5
for element in hashset:
    print(element)

计数器Counter

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

经典二叉树模版

#链式存储二叉树的定义
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为二叉树结构